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