1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // rt766-sdca.c -- rt766 SDCA ALSA SoC audio driver 4 // 5 // Copyright(c) 2026 Realtek Semiconductor Corp. 6 // 7 // 8 9 #include <linux/bitops.h> 10 #include <sound/core.h> 11 #include <linux/delay.h> 12 #include <linux/init.h> 13 #include <sound/initval.h> 14 #include <sound/jack.h> 15 #include <linux/kernel.h> 16 #include <linux/module.h> 17 #include <linux/pm_runtime.h> 18 #include <linux/soundwire/sdw_registers.h> 19 #include <sound/pcm.h> 20 #include <sound/pcm_params.h> 21 #include <sound/sdw.h> 22 #include <sound/sdca.h> 23 #include <sound/sdca_asoc.h> 24 #include <sound/sdca_function.h> 25 #include <sound/sdca_hid.h> 26 #include <sound/sdca_regmap.h> 27 #include <sound/sdca_interrupts.h> 28 #include <linux/slab.h> 29 #include <sound/soc-dapm.h> 30 #include <sound/tlv.h> 31 #include "rt766-sdca.h" 32 #include "rt-sdw-common.h" 33 34 static int rt766_sdca_btn_detect(struct sdca_interrupt *interrupt) 35 { 36 struct rt766_sdca_priv *rt766 = interrupt->priv; 37 unsigned char *buf = NULL; 38 unsigned int offset, owner, length; 39 unsigned int det_mode, idx, val; 40 int ret; 41 42 ret = regmap_read(rt766->regmap, 43 RT766_SDCA_CTL(UAJ, GE49, SDCA_CTL_GE_DETECTED_MODE), 44 &det_mode); 45 if (ret < 0) 46 goto io_error; 47 48 /* get current UMP message owner */ 49 ret = regmap_read(rt766->regmap, 50 RT766_SDCA_CTL(HID, HID101, SDCA_CTL_HIDE_HIDTX_CURRENTOWNER), 51 &owner); 52 if (ret < 0) 53 goto io_error; 54 55 /* if owner is device then there is no button event from device */ 56 if (owner == 1) 57 return 0; 58 59 if (det_mode) { 60 /* read UMP message length */ 61 ret = regmap_read(rt766->regmap, 62 RT766_SDCA_CTL(HID, HID101, SDCA_CTL_HIDE_HIDTX_MESSAGELENGTH), 63 &length); 64 if (ret < 0) 65 goto _end_btn_det_; 66 67 /* read UMP message offset */ 68 ret = regmap_read(rt766->regmap, 69 RT766_SDCA_CTL(HID, HID101, SDCA_CTL_HIDE_HIDTX_MESSAGEOFFSET), 70 &offset); 71 if (ret < 0) 72 goto _end_btn_det_; 73 74 buf = devm_kzalloc(&rt766->slave->dev, length, GFP_KERNEL); 75 if (!buf) { 76 dev_err(&rt766->slave->dev, "%s: alloc buf failed\n", __func__); 77 goto _end_btn_det_; 78 } 79 80 for (idx = 0; idx < length; idx++) { 81 ret = regmap_read(rt766->regmap, 82 RT766_BUF_ADDR_HID1 + offset + idx, &val); 83 if (ret < 0) 84 goto _end_btn_det_; 85 buf[idx] = val & 0xff; 86 } 87 88 if (rt766->hid) 89 hid_input_report(rt766->hid, HID_INPUT_REPORT, 90 buf, length, 1); 91 } 92 93 _end_btn_det_: 94 if (buf) 95 devm_kfree(&rt766->slave->dev, buf); 96 97 /* Host is owner, so set back to device */ 98 if (owner == 0) { 99 regmap_write(rt766->regmap, 100 RT766_SDCA_CTL(HID, HID101, SDCA_CTL_HIDE_HIDTX_CURRENTOWNER), 0x01); 101 } 102 103 return 0; 104 105 io_error: 106 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 107 return ret; 108 } 109 110 static irqreturn_t rt766_sdca_irq_btn_handler(int irq, void *data) 111 { 112 struct sdca_interrupt *interrupt = data; 113 struct rt766_sdca_priv *rt766 = interrupt->priv; 114 115 if (!rt766->hs_jack) 116 return IRQ_HANDLED; 117 118 if (!rt766->component->card || !rt766->component->card->instantiated) 119 return IRQ_HANDLED; 120 121 mutex_lock(&rt766->disable_irq_lock); 122 if (!rt766->disable_irq) 123 rt766_sdca_btn_detect(interrupt); 124 mutex_unlock(&rt766->disable_irq_lock); 125 return IRQ_HANDLED; 126 } 127 128 static int rt766_sdca_headset_detect(struct rt766_sdca_priv *rt766) 129 { 130 unsigned int det_mode; 131 int ret; 132 133 /* get detected_mode */ 134 ret = regmap_read(rt766->regmap, 135 RT766_SDCA_CTL(UAJ, GE49, SDCA_CTL_GE_DETECTED_MODE), 136 &det_mode); 137 if (ret < 0) 138 goto io_error; 139 140 switch (det_mode) { 141 case 0x00: 142 rt766->jack_type = 0; 143 break; 144 case 0x03: 145 rt766->jack_type = SND_JACK_HEADPHONE; 146 break; 147 case 0x05: 148 rt766->jack_type = SND_JACK_HEADSET; 149 break; 150 } 151 152 /* write selected_mode */ 153 if (det_mode) { 154 ret = regmap_write(rt766->regmap, 155 RT766_SDCA_CTL(UAJ, GE49, SDCA_CTL_GE_SELECTED_MODE), 156 det_mode); 157 if (ret < 0) 158 goto io_error; 159 } 160 161 dev_dbg(&rt766->slave->dev, 162 "%s, detected_mode=0x%x\n", __func__, det_mode); 163 164 return 0; 165 166 io_error: 167 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret); 168 return ret; 169 } 170 171 static irqreturn_t rt766_sdca_irq_jd_handler(int irq, void *data) 172 { 173 struct sdca_interrupt *interrupt = data; 174 struct rt766_sdca_priv *rt766 = interrupt->priv; 175 176 if (!rt766->hs_jack) 177 return IRQ_HANDLED; 178 179 if (!rt766->component->card || !rt766->component->card->instantiated) { 180 /* trigger again if card is not instantiated */ 181 regmap_write(rt766->regmap, RT766_GE_DET_IRQ_MNL, 0x01); 182 return IRQ_HANDLED; 183 } 184 185 mutex_lock(&rt766->disable_irq_lock); 186 if (!rt766->disable_irq) 187 rt766_sdca_headset_detect(rt766); 188 mutex_unlock(&rt766->disable_irq_lock); 189 190 dev_dbg(&rt766->slave->dev, 191 "in %s, jack_type=%d\n", __func__, rt766->jack_type); 192 193 snd_soc_jack_report(rt766->hs_jack, rt766->jack_type, SND_JACK_HEADSET); 194 return IRQ_HANDLED; 195 } 196 197 static void rt766_sdca_destroy_hid_device(struct sdca_interrupt *interrupt) 198 { 199 struct rt766_sdca_priv *rt766 = interrupt->priv; 200 201 hid_destroy_device(rt766->hid); 202 } 203 204 static int rt766_sdca_irq_ctl(struct rt766_sdca_priv *rt766, 205 struct sdca_function_data *function, 206 struct snd_soc_component *component, 207 struct sdca_interrupt_info *info, 208 bool enabled) 209 { 210 struct device *dev = &rt766->slave->dev; 211 struct sdca_interrupt *interrupt; 212 struct sdca_control *control; 213 struct sdca_entity *entity; 214 irq_handler_t handler; 215 int i, j, irq, ret; 216 217 for (i = 0; i < function->num_entities; i++) { 218 entity = &function->entities[i]; 219 220 for (j = 0; j < entity->num_controls; j++) { 221 control = &entity->controls[j]; 222 irq = control->interrupt_position; 223 224 switch (SDCA_CTL_TYPE(entity->type, control->sel)) { 225 case SDCA_CTL_TYPE_S(GE, DETECTED_MODE): 226 handler = rt766_sdca_irq_jd_handler; 227 break; 228 case SDCA_CTL_TYPE_S(HIDE, HIDTX_CURRENTOWNER): 229 handler = rt766_sdca_irq_btn_handler; 230 break; 231 default: 232 continue; 233 } 234 235 interrupt = &info->irqs[irq]; 236 237 if (enabled) { 238 ret = sdca_irq_data_populate(dev, rt766->regmap, component, 239 function, entity, control, 240 interrupt); 241 if (ret) 242 return ret; 243 244 if (handler == rt766_sdca_irq_btn_handler) { 245 ret = sdca_add_hid_device(interrupt); 246 if (ret) 247 return ret; 248 249 interrupt->free_priv = rt766_sdca_destroy_hid_device; 250 rt766->hid = interrupt->priv; 251 } 252 253 interrupt->priv = rt766; 254 ret = sdca_irq_request(dev, info, irq, interrupt->name, 255 handler, interrupt); 256 if (ret) { 257 dev_err(dev, "failed to request irq %s: %d\n", 258 interrupt->name, ret); 259 sdca_irq_cleanup_late(dev, function, info); 260 return ret; 261 } 262 dev_dbg(dev, "Requesting IRQ %d InterruptName=%s\n", irq, interrupt->name); 263 } else { 264 sdca_irq_cleanup_late(dev, function, info); 265 dev_dbg(dev, "Freeing IRQ %d\n", irq); 266 } 267 } 268 } 269 270 return 0; 271 } 272 273 static int rt766_sdca_set_jack_detect(struct snd_soc_component *component, 274 struct snd_soc_jack *hs_jack, void *data) 275 { 276 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 277 int ret; 278 279 if (!rt766->uaj_func_data) { 280 dev_err(&rt766->slave->dev, "The SDCA UAJ function is not supported.\n"); 281 return -EINVAL; 282 } 283 284 rt766->hs_jack = hs_jack; 285 286 if (!rt766->first_hw_init) 287 return 0; 288 289 ret = pm_runtime_resume_and_get(component->dev); 290 if (ret < 0) { 291 if (ret != -EACCES) { 292 dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret); 293 return ret; 294 } 295 296 /* pm_runtime not enabled yet */ 297 dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__); 298 return 0; 299 } 300 301 /* disable interrupts if hs_jack is not set */ 302 if (!rt766->hs_jack) { 303 if (rt766->uaj_func_data) 304 rt766_sdca_irq_ctl(rt766, rt766->uaj_func_data, 305 rt766->component, rt766->irq_info, false); 306 307 if (rt766->hid_func_data) 308 rt766_sdca_irq_ctl(rt766, rt766->hid_func_data, 309 rt766->component, rt766->irq_info, false); 310 } else { 311 /* trigger GE interrupt */ 312 regmap_write(rt766->regmap, RT766_GE_DET_IRQ_MNL, 0x01); 313 } 314 315 pm_runtime_put_autosuspend(component->dev); 316 317 return 0; 318 } 319 320 static int rt766_sdca_set_fu_ctl(struct rt766_sdca_priv *rt766, int func_num, int fu_num) 321 { 322 unsigned int fu01_reg, fu02_reg; 323 unsigned int ch_01, ch_02; 324 unsigned int ch_mute; 325 unsigned int fu_reg; 326 int err, i; 327 328 switch (fu_num) { 329 case RT766_SDCA_ENT_USER_FU41: 330 ch_01 = (rt766->fu41_dapm_mute || rt766->fu41_mixer_l_mute) ? 0x01 : 0x00; 331 ch_02 = (rt766->fu41_dapm_mute || rt766->fu41_mixer_r_mute) ? 0x01 : 0x00; 332 break; 333 case RT766_SDCA_ENT_USER_FU36: 334 ch_01 = (rt766->fu36_dapm_mute || rt766->fu36_mixer_l_mute) ? 0x01 : 0x00; 335 ch_02 = (rt766->fu36_dapm_mute || rt766->fu36_mixer_r_mute) ? 0x01 : 0x00; 336 break; 337 case RT766_SDCA_ENT_USER_FU21: 338 ch_01 = (rt766->fu21_dapm_mute || rt766->fu21_mixer_l_mute) ? 0x01 : 0x00; 339 ch_02 = (rt766->fu21_dapm_mute || rt766->fu21_mixer_r_mute) ? 0x01 : 0x00; 340 break; 341 case RT766_SDCA_ENT_USER_FU113: 342 for (i = 0; i < ARRAY_SIZE(rt766->fu113_mixer_mute); i++) { 343 ch_mute = (rt766->fu113_dapm_mute || rt766->fu113_mixer_mute[i]) ? 0x01 : 0x00; 344 fu_reg = SDW_SDCA_CTL(func_num, fu_num, SDCA_CTL_FU_MUTE, 1) + i; 345 err = regmap_write(rt766->regmap, fu_reg, ch_mute); 346 if (err < 0) 347 return err; 348 } 349 return 0; 350 } 351 352 fu01_reg = SDW_SDCA_CTL(func_num, fu_num, SDCA_CTL_FU_MUTE, 1); 353 fu02_reg = SDW_SDCA_CTL(func_num, fu_num, SDCA_CTL_FU_MUTE, 2); 354 err = regmap_write(rt766->regmap, fu01_reg, ch_01); 355 if (err < 0) 356 return err; 357 err = regmap_write(rt766->regmap, fu02_reg, ch_02); 358 if (err < 0) 359 return err; 360 361 return 0; 362 } 363 364 static int rt766_sdca_fu41_playback_get(struct snd_kcontrol *kcontrol, 365 struct snd_ctl_elem_value *ucontrol) 366 { 367 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 368 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 369 370 ucontrol->value.integer.value[0] = !rt766->fu41_mixer_l_mute; 371 ucontrol->value.integer.value[1] = !rt766->fu41_mixer_r_mute; 372 return 0; 373 } 374 375 static int rt766_sdca_fu41_playback_put(struct snd_kcontrol *kcontrol, 376 struct snd_ctl_elem_value *ucontrol) 377 { 378 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 379 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 380 int err; 381 382 if (rt766->fu41_mixer_l_mute == !ucontrol->value.integer.value[0] && 383 rt766->fu41_mixer_r_mute == !ucontrol->value.integer.value[1]) 384 return 0; 385 386 rt766->fu41_mixer_l_mute = !ucontrol->value.integer.value[0]; 387 rt766->fu41_mixer_r_mute = !ucontrol->value.integer.value[1]; 388 389 err = rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_UAJ, RT766_SDCA_ENT_USER_FU41); 390 if (err < 0) 391 return err; 392 393 return 1; 394 } 395 396 static int rt766_sdca_fu36_capture_get(struct snd_kcontrol *kcontrol, 397 struct snd_ctl_elem_value *ucontrol) 398 { 399 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 400 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 401 402 ucontrol->value.integer.value[0] = !rt766->fu36_mixer_l_mute; 403 ucontrol->value.integer.value[1] = !rt766->fu36_mixer_r_mute; 404 return 0; 405 } 406 407 static int rt766_sdca_fu36_capture_put(struct snd_kcontrol *kcontrol, 408 struct snd_ctl_elem_value *ucontrol) 409 { 410 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 411 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 412 int err; 413 414 if (rt766->fu36_mixer_l_mute == !ucontrol->value.integer.value[0] && 415 rt766->fu36_mixer_r_mute == !ucontrol->value.integer.value[1]) 416 return 0; 417 418 rt766->fu36_mixer_l_mute = !ucontrol->value.integer.value[0]; 419 rt766->fu36_mixer_r_mute = !ucontrol->value.integer.value[1]; 420 err = rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_UAJ, RT766_SDCA_ENT_USER_FU36); 421 if (err < 0) 422 return err; 423 424 return 1; 425 } 426 427 static int rt766_sdca_fu21_playback_get(struct snd_kcontrol *kcontrol, 428 struct snd_ctl_elem_value *ucontrol) 429 { 430 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 431 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 432 433 ucontrol->value.integer.value[0] = !rt766->fu21_mixer_l_mute; 434 ucontrol->value.integer.value[1] = !rt766->fu21_mixer_r_mute; 435 return 0; 436 } 437 438 static int rt766_sdca_fu21_playback_put(struct snd_kcontrol *kcontrol, 439 struct snd_ctl_elem_value *ucontrol) 440 { 441 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 442 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 443 int err; 444 445 if (rt766->fu21_mixer_l_mute == !ucontrol->value.integer.value[0] && 446 rt766->fu21_mixer_r_mute == !ucontrol->value.integer.value[1]) 447 return 0; 448 449 rt766->fu21_mixer_l_mute = !ucontrol->value.integer.value[0]; 450 rt766->fu21_mixer_r_mute = !ucontrol->value.integer.value[1]; 451 452 err = rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_AMP, RT766_SDCA_ENT_USER_FU21); 453 if (err < 0) 454 return err; 455 456 return 1; 457 } 458 459 static int rt766_sdca_fu113_event(struct snd_soc_dapm_widget *w, 460 struct snd_kcontrol *kcontrol, int event) 461 { 462 struct snd_soc_component *component = 463 snd_soc_dapm_to_component(w->dapm); 464 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 465 466 switch (event) { 467 case SND_SOC_DAPM_POST_PMU: 468 rt766->fu113_dapm_mute = false; 469 rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_MIC, RT766_SDCA_ENT_USER_FU113); 470 break; 471 case SND_SOC_DAPM_PRE_PMD: 472 rt766->fu113_dapm_mute = true; 473 rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_MIC, RT766_SDCA_ENT_USER_FU113); 474 break; 475 } 476 return 0; 477 } 478 479 static int rt766_sdca_dmic_set_gain_get(struct snd_kcontrol *kcontrol, 480 struct snd_ctl_elem_value *ucontrol) 481 { 482 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 483 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 484 struct rt_sdca_dmic_kctrl_priv *p = 485 (struct rt_sdca_dmic_kctrl_priv *)kcontrol->private_value; 486 const unsigned int interval_offset = 0xc0; 487 unsigned int regvalue, ctl, i; 488 489 /* check all channels */ 490 for (i = 0; i < p->count; i++) { 491 regmap_read(rt766->regmap, p->reg_base + i, ®value); 492 ctl = p->max - (((0x1e00 - regvalue) & 0xffff) / interval_offset); 493 494 ucontrol->value.integer.value[i] = ctl; 495 } 496 497 return 0; 498 } 499 500 static int rt766_sdca_dmic_set_gain_put(struct snd_kcontrol *kcontrol, 501 struct snd_ctl_elem_value *ucontrol) 502 { 503 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 504 struct rt_sdca_dmic_kctrl_priv *p = 505 (struct rt_sdca_dmic_kctrl_priv *)kcontrol->private_value; 506 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 507 const unsigned int interval_offset = 0xc0; 508 unsigned int gain_val[4]; 509 unsigned int i, changed = 0; 510 unsigned int regvalue[4]; 511 int err; 512 513 /* check all channels */ 514 for (i = 0; i < p->count; i++) { 515 regmap_read(rt766->regmap, p->reg_base + i, ®value[i]); 516 517 gain_val[i] = ucontrol->value.integer.value[i]; 518 if (gain_val[i] > p->max) 519 gain_val[i] = p->max; 520 521 gain_val[i] = 0x1e00 - ((p->max - gain_val[i]) * interval_offset); 522 gain_val[i] &= 0xffff; 523 524 if (regvalue[i] != gain_val[i]) 525 changed = 1; 526 } 527 528 if (!changed) 529 return 0; 530 531 for (i = 0; i < p->count; i++) { 532 err = regmap_write(rt766->regmap, p->reg_base + i, gain_val[i]); 533 if (err < 0) 534 dev_err(&rt766->slave->dev, "0x%08x can't be set\n", p->reg_base + i); 535 } 536 537 return changed; 538 } 539 540 static int rt766_sdca_dmic_fu113_capture_get(struct snd_kcontrol *kcontrol, 541 struct snd_ctl_elem_value *ucontrol) 542 { 543 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 544 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 545 unsigned int i; 546 547 for (i = 0; i < 4; i++) 548 ucontrol->value.integer.value[i] = !rt766->fu113_mixer_mute[i]; 549 return 0; 550 } 551 552 static int rt766_sdca_dmic_fu113_capture_put(struct snd_kcontrol *kcontrol, 553 struct snd_ctl_elem_value *ucontrol) 554 { 555 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol); 556 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 557 int err, changed = 0, i; 558 559 for (i = 0; i < 4; i++) { 560 if (rt766->fu113_mixer_mute[i] != !ucontrol->value.integer.value[i]) 561 changed = 1; 562 rt766->fu113_mixer_mute[i] = !ucontrol->value.integer.value[i]; 563 } 564 565 err = rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_MIC, RT766_SDCA_ENT_USER_FU113); 566 if (err < 0) 567 return err; 568 return changed; 569 } 570 571 static int rt766_sdca_fu41_event(struct snd_soc_dapm_widget *w, 572 struct snd_kcontrol *kcontrol, int event) 573 { 574 struct snd_soc_component *component = 575 snd_soc_dapm_to_component(w->dapm); 576 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 577 578 switch (event) { 579 case SND_SOC_DAPM_POST_PMU: 580 rt766->fu41_dapm_mute = false; 581 rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_UAJ, RT766_SDCA_ENT_USER_FU41); 582 break; 583 case SND_SOC_DAPM_PRE_PMD: 584 rt766->fu41_dapm_mute = true; 585 rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_UAJ, RT766_SDCA_ENT_USER_FU41); 586 break; 587 } 588 return 0; 589 } 590 591 static int rt766_sdca_pde_event(struct snd_soc_dapm_widget *w, 592 struct snd_kcontrol *kcontrol, int event, int func_num, int pde_num, const char *pde_ent) 593 { 594 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm); 595 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 596 struct sdca_function_data *func_data; 597 unsigned char ps0 = 0x0, ps3 = 0x3; 598 const struct sdca_entity *entity; 599 unsigned int pde_req_reg; 600 int from_ps, to_ps; 601 int ret; 602 603 pde_req_reg = SDW_SDCA_CTL(func_num, pde_num, SDCA_CTL_PDE_REQUESTED_PS, 0); 604 605 switch (func_num) { 606 case RT766_FUNC_NUM_UAJ: 607 func_data = rt766->uaj_func_data; 608 break; 609 case RT766_FUNC_NUM_AMP: 610 func_data = rt766->sa_func_data; 611 break; 612 case RT766_FUNC_NUM_MIC: 613 func_data = rt766->sm_func_data; 614 break; 615 default: 616 dev_err(component->dev, "%s: unsupported func_num %d\n", 617 __func__, func_num); 618 return -EINVAL; 619 } 620 621 switch (event) { 622 case SND_SOC_DAPM_POST_PMU: 623 regmap_write(rt766->regmap, pde_req_reg, ps0); 624 from_ps = ps3; 625 to_ps = ps0; 626 break; 627 case SND_SOC_DAPM_PRE_PMD: 628 regmap_write(rt766->regmap, pde_req_reg, ps3); 629 from_ps = ps0; 630 to_ps = ps3; 631 break; 632 } 633 634 entity = sdca_find_entity_by_label(func_data, pde_ent); 635 if (!entity) { 636 dev_err(component->dev, "%s: failed to find entity %s\n", 637 __func__, pde_ent); 638 return -EINVAL; 639 } 640 641 ret = sdca_asoc_pde_poll_actual_ps(rt766->regmap, 642 func_num, 643 pde_num, 644 from_ps, to_ps, 645 entity->pde.max_delay, 646 entity->pde.num_max_delay); 647 if (ret) 648 dev_err(component->dev, "%s: PDE transition %x -> %x failed, err=%d\n", 649 __func__, from_ps, to_ps, ret); 650 651 return ret; 652 } 653 654 static int rt766_sdca_pde47_event(struct snd_soc_dapm_widget *w, 655 struct snd_kcontrol *kcontrol, int event) 656 { 657 return rt766_sdca_pde_event(w, kcontrol, event, 658 RT766_FUNC_NUM_UAJ, RT766_SDCA_ENT_PDE47, "PDE 47"); 659 } 660 661 static int rt766_sdca_fu36_event(struct snd_soc_dapm_widget *w, 662 struct snd_kcontrol *kcontrol, int event) 663 { 664 struct snd_soc_component *component = 665 snd_soc_dapm_to_component(w->dapm); 666 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 667 668 switch (event) { 669 case SND_SOC_DAPM_POST_PMU: 670 rt766->fu36_dapm_mute = false; 671 rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_UAJ, RT766_SDCA_ENT_USER_FU36); 672 break; 673 case SND_SOC_DAPM_PRE_PMD: 674 rt766->fu36_dapm_mute = true; 675 rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_UAJ, RT766_SDCA_ENT_USER_FU36); 676 break; 677 } 678 return 0; 679 } 680 681 static int rt766_sdca_pde34_event(struct snd_soc_dapm_widget *w, 682 struct snd_kcontrol *kcontrol, int event) 683 { 684 return rt766_sdca_pde_event(w, kcontrol, event, 685 RT766_FUNC_NUM_UAJ, RT766_SDCA_ENT_PDE34, "PDE 34"); 686 } 687 688 static int rt766_sdca_fu21_event(struct snd_soc_dapm_widget *w, 689 struct snd_kcontrol *kcontrol, int event) 690 { 691 struct snd_soc_component *component = 692 snd_soc_dapm_to_component(w->dapm); 693 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 694 695 switch (event) { 696 case SND_SOC_DAPM_POST_PMU: 697 rt766->fu21_dapm_mute = false; 698 rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_AMP, RT766_SDCA_ENT_USER_FU21); 699 break; 700 case SND_SOC_DAPM_PRE_PMD: 701 rt766->fu21_dapm_mute = true; 702 rt766_sdca_set_fu_ctl(rt766, RT766_FUNC_NUM_AMP, RT766_SDCA_ENT_USER_FU21); 703 break; 704 } 705 return 0; 706 } 707 708 static int rt766_sdca_pde23_event(struct snd_soc_dapm_widget *w, 709 struct snd_kcontrol *kcontrol, int event) 710 { 711 return rt766_sdca_pde_event(w, kcontrol, event, 712 RT766_FUNC_NUM_AMP, RT766_SDCA_ENT_PDE23, "PDE 23"); 713 } 714 715 static int rt766_sdca_pde11_event(struct snd_soc_dapm_widget *w, 716 struct snd_kcontrol *kcontrol, int event) 717 { 718 return rt766_sdca_pde_event(w, kcontrol, event, 719 RT766_FUNC_NUM_MIC, RT766_SDCA_ENT_PDE11, "PDE 11"); 720 } 721 722 static int rt766_dmic_fu_info(struct snd_kcontrol *kcontrol, 723 struct snd_ctl_elem_info *uinfo) 724 { 725 struct rt_sdca_dmic_kctrl_priv *p = 726 (struct rt_sdca_dmic_kctrl_priv *)kcontrol->private_value; 727 728 if (p->max == 1) 729 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN; 730 else 731 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER; 732 uinfo->count = p->count; 733 uinfo->value.integer.min = 0; 734 uinfo->value.integer.max = p->max; 735 return 0; 736 } 737 738 static const char * const rt766_rx_data_ch_select[] = { 739 "L,R", 740 "R,L", 741 "L,L", 742 "R,R", 743 "L,L+R", 744 "R,L+R", 745 "L+R,L", 746 "L+R,R", 747 "L+R,L+R", 748 }; 749 750 static SOC_ENUM_SINGLE_DECL(rt766_rx_data_ch_enum, 751 RT766_SDCA_CTL(AMP, PPU21, SDCA_CTL_PPU_POSTURENUMBER), 0, 752 rt766_rx_data_ch_select); 753 754 static const DECLARE_TLV_DB_SCALE(hp_vol_tlv, -9525, 75, 0); 755 static const DECLARE_TLV_DB_SCALE(spk_vol_tlv, -6525, 75, 0); 756 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, -1725, 75, 0); 757 static const DECLARE_TLV_DB_SCALE(boost_vol_tlv, -200, 200, 0); 758 759 #define RT766_P75DB_STEP 0xC0 /* 0.75 dB in Q7.8 format */ 760 #define RT766_2DB_STEP 0x200 /* 2 dB in Q7.8 format */ 761 #define RT766_HP_VOL_MIN (-127) /* -95.25 dB / 0.75 dB step */ 762 #define RT766_HS_VOL_MIN (-23) /* -17.25 dB / 0.75 dB step */ 763 #define RT766_HS_BOOST_VOL_MIN (-1) /* -2 dB / 2 dB step */ 764 #define RT766_SPK_VOL_MIN (-87) /* -65.25 dB / 0.75 dB step */ 765 #define RT766_P_VOL_MAX 0 /* 0 dB / 0.75 dB step */ 766 #define RT766_HS_VOL_MAX 40 /* 30 dB / 0.75 dB step */ 767 #define RT766_HS_BOOST_VOL_MAX 20 /* 40 dB / 2 dB step */ 768 769 static const struct snd_kcontrol_new rt766_sdca_controls[] = { 770 SOC_DOUBLE_EXT("FU41 Playback Switch", SND_SOC_NOPM, 0, 1, 1, 0, 771 rt766_sdca_fu41_playback_get, rt766_sdca_fu41_playback_put), 772 SDCA_DOUBLE_Q78_TLV("FU41 Playback Volume", 773 RT766_VOLUME_REG(UAJ, USER_FU41, 1), 774 RT766_VOLUME_REG(UAJ, USER_FU41, 2), 775 RT766_HP_VOL_MIN, RT766_P_VOL_MAX, RT766_P75DB_STEP, hp_vol_tlv), 776 SOC_DOUBLE_EXT("FU36 Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0, 777 rt766_sdca_fu36_capture_get, rt766_sdca_fu36_capture_put), 778 SDCA_DOUBLE_Q78_TLV("FU36 Capture Volume", 779 RT766_VOLUME_REG(UAJ, USER_FU36, 1), 780 RT766_VOLUME_REG(UAJ, USER_FU36, 2), 781 RT766_HS_VOL_MIN, RT766_HS_VOL_MAX, RT766_P75DB_STEP, mic_vol_tlv), 782 SDCA_DOUBLE_Q78_TLV("FU33 Boost Volume", 783 RT766_GAIN_REG(UAJ, PLATFORM_FU33, 1), 784 RT766_GAIN_REG(UAJ, PLATFORM_FU33, 2), 785 RT766_HS_BOOST_VOL_MIN, RT766_HS_BOOST_VOL_MAX, RT766_2DB_STEP, boost_vol_tlv), 786 787 SOC_DOUBLE_EXT("FU21 Playback Switch", SND_SOC_NOPM, 0, 1, 1, 0, 788 rt766_sdca_fu21_playback_get, rt766_sdca_fu21_playback_put), 789 SDCA_DOUBLE_Q78_TLV("FU21 Playback Volume", 790 RT766_VOLUME_REG(AMP, USER_FU21, 1), 791 RT766_VOLUME_REG(AMP, USER_FU21, 2), 792 RT766_SPK_VOL_MIN, RT766_P_VOL_MAX, RT766_P75DB_STEP, spk_vol_tlv), 793 SOC_ENUM("RX Channel Select", rt766_rx_data_ch_enum), 794 795 RT_SDCA_FU_CTRL("FU113 Capture Switch", 796 RT766_MUTE_REG(MIC, USER_FU113, 1), 1, 1, 4, rt766_dmic_fu_info, 797 rt766_sdca_dmic_fu113_capture_get, rt766_sdca_dmic_fu113_capture_put), 798 RT_SDCA_EXT_TLV("FU113 Capture Volume", 799 RT766_VOLUME_REG(MIC, USER_FU113, 1), 800 rt766_sdca_dmic_set_gain_get, rt766_sdca_dmic_set_gain_put, 801 4, 0x3f, mic_vol_tlv, rt766_dmic_fu_info), 802 }; 803 804 static const struct snd_soc_dapm_widget rt766_sdca_dapm_widgets[] = { 805 /* UAJ */ 806 SND_SOC_DAPM_OUTPUT("HP"), 807 SND_SOC_DAPM_INPUT("MIC2"), 808 SND_SOC_DAPM_SUPPLY("PDE 47", SND_SOC_NOPM, 0, 0, 809 rt766_sdca_pde47_event, 810 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 811 SND_SOC_DAPM_SUPPLY("PDE 34", SND_SOC_NOPM, 0, 0, 812 rt766_sdca_pde34_event, 813 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 814 SND_SOC_DAPM_DAC_E("FU 41", NULL, SND_SOC_NOPM, 0, 0, 815 rt766_sdca_fu41_event, 816 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 817 SND_SOC_DAPM_ADC_E("FU 36", NULL, SND_SOC_NOPM, 0, 0, 818 rt766_sdca_fu36_event, 819 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 820 SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0), 821 SND_SOC_DAPM_AIF_OUT("DP12TX", "DP12 Capture", 0, SND_SOC_NOPM, 0, 0), 822 823 /* AMP */ 824 SND_SOC_DAPM_OUTPUT("SPOL"), 825 SND_SOC_DAPM_OUTPUT("SPOR"), 826 SND_SOC_DAPM_DAC_E("FU 21", NULL, SND_SOC_NOPM, 0, 0, 827 rt766_sdca_fu21_event, 828 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 829 SND_SOC_DAPM_SUPPLY("PDE 23", SND_SOC_NOPM, 0, 0, 830 rt766_sdca_pde23_event, 831 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 832 SND_SOC_DAPM_AIF_IN("DP1RX", "DP1 Playback", 0, SND_SOC_NOPM, 0, 0), 833 834 /* DMIC */ 835 SND_SOC_DAPM_INPUT("DMIC1"), 836 SND_SOC_DAPM_INPUT("DMIC2"), 837 SND_SOC_DAPM_SUPPLY("PDE 11", SND_SOC_NOPM, 0, 0, 838 rt766_sdca_pde11_event, 839 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 840 SND_SOC_DAPM_ADC_E("FU 113", NULL, SND_SOC_NOPM, 0, 0, 841 rt766_sdca_fu113_event, 842 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD), 843 SND_SOC_DAPM_AIF_OUT("DP8TX", "DP8 Capture", 0, SND_SOC_NOPM, 0, 0), 844 }; 845 846 static const struct snd_soc_dapm_route rt766_sdca_audio_map[] = { 847 { "FU 41", NULL, "DP3RX" }, 848 { "DP12TX", NULL, "FU 36" }, 849 { "FU 36", NULL, "PDE 34" }, 850 { "FU 36", NULL, "MIC2" }, 851 { "HP", NULL, "PDE 47" }, 852 { "HP", NULL, "FU 41" }, 853 854 { "FU 21", NULL, "DP1RX" }, 855 { "FU 21", NULL, "PDE 23" }, 856 { "SPOL", NULL, "FU 21" }, 857 { "SPOR", NULL, "FU 21" }, 858 859 {"DP8TX", NULL, "FU 113"}, 860 {"FU 113", NULL, "PDE 11"}, 861 {"FU 113", NULL, "DMIC1"}, 862 {"FU 113", NULL, "DMIC2"}, 863 }; 864 865 static int rt766_sdca_probe(struct snd_soc_component *component) 866 { 867 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 868 struct device *dev = &rt766->slave->dev; 869 int ret; 870 871 rt766->component = component; 872 873 ret = pm_runtime_resume(component->dev); 874 if (ret < 0 && ret != -EACCES) 875 return ret; 876 877 if (rt766->uaj_func_data) { 878 dev_dbg(dev, "%s : irq %d\n", __func__, rt766->slave->irq); 879 880 rt766->irq_info = devm_sdca_irq_allocate(dev, rt766->regmap, rt766->slave->irq); 881 if (IS_ERR(rt766->irq_info)) 882 return PTR_ERR(rt766->irq_info); 883 884 ret = rt766_sdca_irq_ctl(rt766, rt766->uaj_func_data, 885 component, rt766->irq_info, true); 886 if (ret < 0) { 887 dev_err(dev, "Failed to request UAJ SDCA IRQ: %d\n", ret); 888 return ret; 889 } 890 891 if (rt766->hid_func_data) { 892 ret = rt766_sdca_irq_ctl(rt766, rt766->hid_func_data, 893 component, rt766->irq_info, true); 894 if (ret < 0) { 895 dev_err(dev, "Failed to request HID SDCA IRQ: %d\n", ret); 896 return ret; 897 } 898 } 899 } 900 901 return 0; 902 } 903 904 static void rt766_sdca_remove(struct snd_soc_component *component) 905 { 906 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 907 908 sdca_irq_cleanup_late(component->dev, rt766->uaj_func_data, rt766->irq_info); 909 sdca_irq_cleanup_late(component->dev, rt766->hid_func_data, rt766->irq_info); 910 } 911 912 static const struct snd_soc_component_driver soc_sdca_dev_rt766 = { 913 .probe = rt766_sdca_probe, 914 .remove = rt766_sdca_remove, 915 .controls = rt766_sdca_controls, 916 .num_controls = ARRAY_SIZE(rt766_sdca_controls), 917 .dapm_widgets = rt766_sdca_dapm_widgets, 918 .num_dapm_widgets = ARRAY_SIZE(rt766_sdca_dapm_widgets), 919 .dapm_routes = rt766_sdca_audio_map, 920 .num_dapm_routes = ARRAY_SIZE(rt766_sdca_audio_map), 921 .set_jack = rt766_sdca_set_jack_detect, 922 .endianness = 1, 923 }; 924 925 static int rt766_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream, 926 int direction) 927 { 928 snd_soc_dai_dma_data_set(dai, direction, sdw_stream); 929 930 return 0; 931 } 932 933 static void rt766_sdca_shutdown(struct snd_pcm_substream *substream, 934 struct snd_soc_dai *dai) 935 { 936 snd_soc_dai_set_dma_data(dai, substream, NULL); 937 } 938 939 static int rt766_sdca_pcm_hw_params(struct snd_pcm_substream *substream, 940 struct snd_pcm_hw_params *params, 941 struct snd_soc_dai *dai) 942 { 943 struct snd_soc_component *component = dai->component; 944 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 945 struct sdw_stream_config stream_config = {0}; 946 struct sdw_port_config port_config; 947 struct sdw_stream_runtime *sdw_stream; 948 unsigned int sampling_rate; 949 int retval, port; 950 951 dev_dbg(dai->dev, "%s %s id %d", __func__, dai->name, dai->id); 952 sdw_stream = snd_soc_dai_get_dma_data(dai, substream); 953 954 if (!sdw_stream) 955 return -EINVAL; 956 957 if (!rt766->slave) 958 return -EINVAL; 959 960 /* SoundWire specific configuration */ 961 snd_sdw_params_to_config(substream, params, &stream_config, &port_config); 962 963 /* SoundWire specific configuration */ 964 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) { 965 if (dai->id == RT766_AIF1) 966 port = 3; 967 else if (dai->id == RT766_AIF2) 968 port = 1; 969 else 970 return -EINVAL; 971 } else { 972 if (dai->id == RT766_AIF1) 973 port = 12; 974 else if (dai->id == RT766_AIF3) 975 port = 8; 976 else 977 return -EINVAL; 978 } 979 980 port_config.num = port; 981 retval = sdw_stream_add_slave(rt766->slave, &stream_config, 982 &port_config, 1, sdw_stream); 983 if (retval) { 984 dev_err(dai->dev, "%s: Unable to configure port\n", __func__); 985 return retval; 986 } 987 988 if (params_channels(params) > 16) { 989 dev_err(component->dev, "%s: Unsupported channels %d\n", 990 __func__, params_channels(params)); 991 return -EINVAL; 992 } 993 994 /* sampling rate configuration */ 995 switch (params_rate(params)) { 996 case 44100: 997 sampling_rate = RT766_SDCA_RATE_44100HZ; 998 break; 999 case 48000: 1000 sampling_rate = RT766_SDCA_RATE_48000HZ; 1001 break; 1002 case 96000: 1003 sampling_rate = RT766_SDCA_RATE_96000HZ; 1004 break; 1005 case 192000: 1006 sampling_rate = RT766_SDCA_RATE_192000HZ; 1007 break; 1008 default: 1009 dev_err(component->dev, "%s: Rate %d is not supported\n", 1010 __func__, params_rate(params)); 1011 return -EINVAL; 1012 } 1013 1014 /* set sampling frequency */ 1015 switch (dai->id) { 1016 case RT766_AIF1: 1017 regmap_write(rt766->regmap, 1018 RT766_SDCA_CTL(UAJ, CS41, SDCA_CTL_CS_SAMPLERATEINDEX), 1019 sampling_rate); 1020 regmap_write(rt766->regmap, 1021 RT766_SDCA_CTL(UAJ, CS36, SDCA_CTL_CS_SAMPLERATEINDEX), 1022 sampling_rate); 1023 break; 1024 case RT766_AIF2: 1025 regmap_write(rt766->regmap, 1026 RT766_SDCA_CTL(AMP, CS21, SDCA_CTL_CS_SAMPLERATEINDEX), 1027 sampling_rate); 1028 break; 1029 case RT766_AIF3: 1030 regmap_write(rt766->regmap, 1031 RT766_SDCA_CTL(MIC, CS113, SDCA_CTL_CS_SAMPLERATEINDEX), 1032 sampling_rate); 1033 break; 1034 default: 1035 dev_err(component->dev, "%s: Wrong DAI id\n", __func__); 1036 return -EINVAL; 1037 } 1038 1039 return 0; 1040 } 1041 1042 static int rt766_sdca_pcm_hw_free(struct snd_pcm_substream *substream, 1043 struct snd_soc_dai *dai) 1044 { 1045 struct snd_soc_component *component = dai->component; 1046 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component); 1047 struct sdw_stream_runtime *sdw_stream = 1048 snd_soc_dai_get_dma_data(dai, substream); 1049 1050 if (!rt766->slave) 1051 return -EINVAL; 1052 1053 sdw_stream_remove_slave(rt766->slave, sdw_stream); 1054 return 0; 1055 } 1056 1057 #define RT766_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \ 1058 SNDRV_PCM_RATE_192000) 1059 #define RT766_DAC_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE) 1060 #define RT766_ADC_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE | \ 1061 SNDRV_PCM_FMTBIT_S32_LE) 1062 1063 static const struct snd_soc_dai_ops rt766_sdca_ops = { 1064 .hw_params = rt766_sdca_pcm_hw_params, 1065 .hw_free = rt766_sdca_pcm_hw_free, 1066 .set_stream = rt766_sdca_set_sdw_stream, 1067 .shutdown = rt766_sdca_shutdown, 1068 }; 1069 1070 static struct snd_soc_dai_driver rt766_sdca_dai[] = { 1071 { 1072 .name = "rt766-sdca-aif1", 1073 .id = RT766_AIF1, 1074 .playback = { 1075 .stream_name = "DP3 Playback", 1076 .channels_min = 1, 1077 .channels_max = 2, 1078 .rates = RT766_STEREO_RATES, 1079 .formats = RT766_DAC_FORMATS, 1080 }, 1081 .capture = { 1082 .stream_name = "DP12 Capture", 1083 .channels_min = 1, 1084 .channels_max = 2, 1085 .rates = RT766_STEREO_RATES, 1086 .formats = RT766_ADC_FORMATS, 1087 }, 1088 .ops = &rt766_sdca_ops, 1089 .symmetric_rate = 1, 1090 }, 1091 { 1092 .name = "rt766-sdca-aif2", 1093 .id = RT766_AIF2, 1094 .playback = { 1095 .stream_name = "DP1 Playback", 1096 .channels_min = 1, 1097 .channels_max = 4, 1098 .rates = RT766_STEREO_RATES, 1099 .formats = RT766_DAC_FORMATS, 1100 }, 1101 .ops = &rt766_sdca_ops, 1102 }, 1103 { 1104 .name = "rt766-sdca-aif3", 1105 .id = RT766_AIF3, 1106 .capture = { 1107 .stream_name = "DP8 Capture", 1108 .channels_min = 1, 1109 .channels_max = 4, 1110 .rates = RT766_STEREO_RATES, 1111 .formats = RT766_ADC_FORMATS, 1112 }, 1113 .ops = &rt766_sdca_ops, 1114 } 1115 }; 1116 1117 static unsigned int rt766_find_dt_rates(struct device *dev, struct sdca_function_data *function, 1118 const char *label) 1119 { 1120 struct snd_soc_pcm_stream stream; 1121 struct sdca_entity *entity; 1122 int i, ret; 1123 1124 for (i = 0; i < function->num_entities; i++) { 1125 entity = &function->entities[i]; 1126 1127 if (strcmp(entity->label, label)) 1128 continue; 1129 1130 /* Can't check earlier as only terminals have an iot member. */ 1131 if (!entity->iot.is_dataport) 1132 continue; 1133 1134 ret = sdca_asoc_populate_rate_format(dev, function, entity, &stream); 1135 if (ret < 0) { 1136 dev_dbg(dev, "%s: failed to parse rates for entity %s\n", 1137 __func__, entity->label); 1138 return 0; 1139 } 1140 1141 dev_dbg(dev, "%s: %s supports rates 0x%08x\n", __func__, entity->label, stream.rates); 1142 } 1143 1144 return stream.rates; 1145 } 1146 1147 int rt766_sdca_init(struct device *dev, struct regmap *regmap, struct sdw_slave *slave) 1148 { 1149 struct sdca_function_data *func_data_ptr; 1150 struct snd_soc_dai_driver *dai_drv; 1151 struct rt766_sdca_priv *rt766; 1152 unsigned int rates; 1153 int ret; 1154 int i; 1155 1156 rt766 = devm_kzalloc(dev, sizeof(*rt766), GFP_KERNEL); 1157 if (!rt766) 1158 return -ENOMEM; 1159 1160 dev_set_drvdata(dev, rt766); 1161 rt766->slave = slave; 1162 rt766->regmap = regmap; 1163 1164 regcache_cache_only(rt766->regmap, true); 1165 1166 ret = devm_mutex_init(dev, &rt766->disable_irq_lock); 1167 if (ret < 0) { 1168 dev_err(dev, "Failed to initialize mutex\n"); 1169 return ret; 1170 } 1171 1172 /* 1173 * Mark hw_init to false 1174 * HW init will be performed when device reports present 1175 */ 1176 rt766->hw_init = false; 1177 rt766->first_hw_init = false; 1178 rt766->fu41_dapm_mute = true; 1179 rt766->fu41_mixer_l_mute = rt766->fu41_mixer_r_mute = false; 1180 rt766->fu36_dapm_mute = true; 1181 rt766->fu36_mixer_l_mute = rt766->fu36_mixer_r_mute = true; 1182 rt766->fu21_dapm_mute = true; 1183 rt766->fu21_mixer_l_mute = rt766->fu21_mixer_r_mute = false; 1184 rt766->fu113_dapm_mute = true; 1185 rt766->fu113_mixer_mute[0] = rt766->fu113_mixer_mute[1] = 1186 rt766->fu113_mixer_mute[2] = rt766->fu113_mixer_mute[3] = true; 1187 1188 dai_drv = devm_kzalloc(dev, sizeof(struct snd_soc_dai_driver) * ARRAY_SIZE(rt766_sdca_dai), GFP_KERNEL); 1189 if (!dai_drv) { 1190 dev_err(dev, "Failed to allocate memory for DAI driver\n"); 1191 ret = -ENOMEM; 1192 goto _sdw_init_err_; 1193 } 1194 memcpy(dai_drv, rt766_sdca_dai, sizeof(struct snd_soc_dai_driver) * ARRAY_SIZE(rt766_sdca_dai)); 1195 1196 /* get SDCA function data */ 1197 dev_dbg(dev, "SDCA functions found: %d", slave->sdca_data.num_functions); 1198 for (i = 0; i < slave->sdca_data.num_functions; i++) { 1199 func_data_ptr = devm_kzalloc(dev, sizeof(*func_data_ptr), GFP_KERNEL); 1200 if (!func_data_ptr) { 1201 dev_err(dev, "Failed to allocate memory for function data\n"); 1202 ret = -ENOMEM; 1203 goto _free_dai_drv_; 1204 } 1205 1206 func_data_ptr->desc = &slave->sdca_data.function[i]; 1207 ret = sdca_parse_function(dev, func_data_ptr); 1208 if (ret) { 1209 devm_kfree(dev, func_data_ptr); 1210 goto _free_dai_drv_; 1211 } 1212 dev_dbg(dev, "Function type=%d, num_entities=%d", 1213 slave->sdca_data.function[i].type, func_data_ptr->num_entities); 1214 1215 switch (slave->sdca_data.function[i].type) { 1216 case SDCA_FUNCTION_TYPE_UAJ: 1217 rt766->uaj_func_data = func_data_ptr; 1218 /* 1219 * Some machines may only support a subset of the sample rates supported by the codec. 1220 * Therefore, we need to parse the supported sample rates from the DisCo table and 1221 * configure them in the DAI. If the DisCo table does not provide sample rate information, 1222 * we will fall back to the default supported rates defined in the codec driver. 1223 */ 1224 rates = rt766_find_dt_rates(dev, func_data_ptr, "IT 41"); 1225 if (rates) 1226 dai_drv[RT766_DAI_UAJ].playback.rates = rates; 1227 1228 rates = rt766_find_dt_rates(dev, func_data_ptr, "OT 36"); 1229 if (rates) 1230 dai_drv[RT766_DAI_UAJ].capture.rates = rates; 1231 break; 1232 case SDCA_FUNCTION_TYPE_SMART_AMP: 1233 rt766->sa_func_data = func_data_ptr; 1234 rates = rt766_find_dt_rates(dev, func_data_ptr, "IT 21"); 1235 if (rates) 1236 dai_drv[RT766_DAI_AMP].playback.rates = rates; 1237 break; 1238 case SDCA_FUNCTION_TYPE_SMART_MIC: 1239 rt766->sm_func_data = func_data_ptr; 1240 rates = rt766_find_dt_rates(dev, func_data_ptr, "OT 113"); 1241 if (rates) 1242 dai_drv[RT766_DAI_MIC].capture.rates = rates; 1243 break; 1244 case SDCA_FUNCTION_TYPE_HID: 1245 rt766->hid_func_data = func_data_ptr; 1246 break; 1247 default: 1248 dev_dbg(dev, "Unexpected SDCA function type found: %d", 1249 slave->sdca_data.function[i].type); 1250 } 1251 } 1252 1253 ret = devm_snd_soc_register_component(dev, 1254 &soc_sdca_dev_rt766, dai_drv, ARRAY_SIZE(rt766_sdca_dai)); 1255 if (ret < 0) 1256 goto _free_dai_drv_; 1257 1258 /* set autosuspend parameters */ 1259 pm_runtime_set_autosuspend_delay(dev, 3000); 1260 pm_runtime_use_autosuspend(dev); 1261 1262 /* make sure the device does not suspend immediately */ 1263 pm_runtime_mark_last_busy(dev); 1264 1265 pm_runtime_enable(dev); 1266 dev_dbg(dev, "%s\n", __func__); 1267 return 0; 1268 1269 _free_dai_drv_: 1270 if (dai_drv) 1271 devm_kfree(dev, dai_drv); 1272 1273 _sdw_init_err_: 1274 return ret; 1275 } 1276 1277 static int rt766_func_initialize(struct rt766_sdca_priv *rt766, struct sdca_function_data *func_data) 1278 { 1279 struct device *dev = &rt766->slave->dev; 1280 unsigned int func_status_reg; 1281 unsigned int func_status; 1282 int ret; 1283 1284 switch (func_data->desc->type) { 1285 case SDCA_FUNCTION_TYPE_UAJ: 1286 func_status_reg = RT766_FUNC_STATUS_REG(UAJ); 1287 break; 1288 case SDCA_FUNCTION_TYPE_SMART_AMP: 1289 func_status_reg = RT766_FUNC_STATUS_REG(AMP); 1290 break; 1291 case SDCA_FUNCTION_TYPE_SMART_MIC: 1292 func_status_reg = RT766_FUNC_STATUS_REG(MIC); 1293 break; 1294 case SDCA_FUNCTION_TYPE_HID: 1295 func_status_reg = RT766_FUNC_STATUS_REG(HID); 1296 break; 1297 default: 1298 dev_dbg(dev, "Unexpected SDCA function type found: %d", 1299 func_data->desc->type); 1300 return -EINVAL; 1301 } 1302 1303 regmap_read(rt766->regmap, func_status_reg, &func_status); 1304 dev_dbg(dev, "%s, %s func_status=0x%x\n", __func__, func_data->desc->name, func_status); 1305 1306 if ((func_status & SDCA_CTL_ENTITY_0_FUNCTION_NEEDS_INITIALIZATION)) { 1307 ret = sdca_regmap_write_init(dev, rt766->regmap, func_data); 1308 if (ret) { 1309 dev_err(dev, "%s initialization table update failed\n", func_data->desc->name); 1310 goto _func_init_err_; 1311 } 1312 1313 regmap_write(rt766->regmap, func_status_reg, 1314 SDCA_CTL_ENTITY_0_FUNCTION_NEEDS_INITIALIZATION); 1315 } 1316 1317 return 0; 1318 1319 _func_init_err_: 1320 dev_err(dev, "%s: %s init writes failed, err=%d", __func__, func_data->desc->name, ret); 1321 return ret; 1322 } 1323 1324 int rt766_sdca_io_init(struct device *dev, struct sdw_slave *slave) 1325 { 1326 struct rt766_sdca_priv *rt766 = dev_get_drvdata(dev); 1327 unsigned int val; 1328 1329 rt766->disable_irq = false; 1330 1331 if (rt766->hw_init) 1332 return 0; 1333 1334 regcache_cache_only(rt766->regmap, false); 1335 if (rt766->first_hw_init) { 1336 regcache_cache_bypass(rt766->regmap, true); 1337 } else { 1338 /* 1339 * PM runtime status is marked as 'active' only when a Slave reports as Attached 1340 */ 1341 1342 /* update count of parent 'active' children */ 1343 pm_runtime_set_active(&slave->dev); 1344 } 1345 1346 pm_runtime_get_noresume(&slave->dev); 1347 1348 regmap_read(rt766->regmap, RT766_BOND_LATCH_ID, &val); 1349 dev_dbg(&slave->dev, "%s bond ID=0x%x (%s)\n", __func__, val, (val == 0x1) ? "RT767" : "RT766"); 1350 1351 /* check function status and initialize if needed */ 1352 if (rt766->uaj_func_data) 1353 rt766_func_initialize(rt766, rt766->uaj_func_data); 1354 if (rt766->sa_func_data) 1355 rt766_func_initialize(rt766, rt766->sa_func_data); 1356 if (rt766->sm_func_data) 1357 rt766_func_initialize(rt766, rt766->sm_func_data); 1358 if (rt766->hid_func_data) 1359 rt766_func_initialize(rt766, rt766->hid_func_data); 1360 1361 if (rt766->first_hw_init) { 1362 regcache_cache_bypass(rt766->regmap, false); 1363 regcache_mark_dirty(rt766->regmap); 1364 } else { 1365 rt766->first_hw_init = true; 1366 } 1367 1368 /* Mark Slave initialization complete */ 1369 rt766->hw_init = true; 1370 1371 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__); 1372 1373 pm_runtime_put_autosuspend(&slave->dev); 1374 1375 return 0; 1376 } 1377 1378 MODULE_DESCRIPTION("ASoC RT766 SDCA SDW driver"); 1379 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>"); 1380 MODULE_LICENSE("GPL"); 1381 MODULE_IMPORT_NS("SND_SOC_SDCA"); 1382