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
rt766_sdca_btn_detect(struct sdca_interrupt * interrupt)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
rt766_sdca_irq_btn_handler(int irq,void * data)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
rt766_sdca_headset_detect(struct rt766_sdca_priv * rt766)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
rt766_sdca_irq_jd_handler(int irq,void * data)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
rt766_sdca_destroy_hid_device(struct sdca_interrupt * interrupt)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
rt766_sdca_irq_ctl(struct rt766_sdca_priv * rt766,struct sdca_function_data * function,struct snd_soc_component * component,struct sdca_interrupt_info * info,bool enabled)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
rt766_sdca_set_jack_detect(struct snd_soc_component * component,struct snd_soc_jack * hs_jack,void * data)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
rt766_sdca_set_fu_ctl(struct rt766_sdca_priv * rt766,int func_num,int fu_num)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
rt766_sdca_fu41_playback_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
rt766_sdca_fu41_playback_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
rt766_sdca_fu36_capture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
rt766_sdca_fu36_capture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
rt766_sdca_fu21_playback_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
rt766_sdca_fu21_playback_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
rt766_sdca_fu113_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)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
rt766_sdca_dmic_set_gain_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
rt766_sdca_dmic_set_gain_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
rt766_sdca_dmic_fu113_capture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
rt766_sdca_dmic_fu113_capture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)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
rt766_sdca_fu41_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)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
rt766_sdca_pde_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event,int func_num,int pde_num,const char * pde_ent)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
rt766_sdca_pde47_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)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
rt766_sdca_fu36_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)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
rt766_sdca_pde34_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)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
rt766_sdca_fu21_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)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
rt766_sdca_pde23_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)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
rt766_sdca_pde11_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)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
rt766_dmic_fu_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)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
rt766_sdca_probe(struct snd_soc_component * component)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
rt766_sdca_remove(struct snd_soc_component * component)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
rt766_sdca_set_sdw_stream(struct snd_soc_dai * dai,void * sdw_stream,int direction)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
rt766_sdca_shutdown(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)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
rt766_sdca_pcm_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)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 = {0};
940 struct sdw_port_config port_config;
941 struct sdw_stream_runtime *sdw_stream;
942 unsigned int sampling_rate;
943 int retval, port;
944
945 dev_dbg(dai->dev, "%s %s id %d", __func__, dai->name, dai->id);
946 sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
947
948 if (!sdw_stream)
949 return -EINVAL;
950
951 if (!rt766->slave)
952 return -EINVAL;
953
954 /* SoundWire specific configuration */
955 snd_sdw_params_to_config(substream, params, &stream_config, &port_config);
956
957 /* SoundWire specific configuration */
958 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
959 if (dai->id == RT766_AIF1)
960 port = 3;
961 else if (dai->id == RT766_AIF2)
962 port = 1;
963 else
964 return -EINVAL;
965 } else {
966 if (dai->id == RT766_AIF1)
967 port = 12;
968 else if (dai->id == RT766_AIF3)
969 port = 8;
970 else
971 return -EINVAL;
972 }
973
974 port_config.num = port;
975 retval = sdw_stream_add_slave(rt766->slave, &stream_config,
976 &port_config, 1, sdw_stream);
977 if (retval) {
978 dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
979 return retval;
980 }
981
982 if (params_channels(params) > 16) {
983 dev_err(component->dev, "%s: Unsupported channels %d\n",
984 __func__, params_channels(params));
985 return -EINVAL;
986 }
987
988 /* sampling rate configuration */
989 switch (params_rate(params)) {
990 case 44100:
991 sampling_rate = RT766_SDCA_RATE_44100HZ;
992 break;
993 case 48000:
994 sampling_rate = RT766_SDCA_RATE_48000HZ;
995 break;
996 case 96000:
997 sampling_rate = RT766_SDCA_RATE_96000HZ;
998 break;
999 case 192000:
1000 sampling_rate = RT766_SDCA_RATE_192000HZ;
1001 break;
1002 default:
1003 dev_err(component->dev, "%s: Rate %d is not supported\n",
1004 __func__, params_rate(params));
1005 return -EINVAL;
1006 }
1007
1008 /* set sampling frequency */
1009 switch (dai->id) {
1010 case RT766_AIF1:
1011 regmap_write(rt766->regmap,
1012 RT766_SDCA_CTL(UAJ, CS41, SDCA_CTL_CS_SAMPLERATEINDEX),
1013 sampling_rate);
1014 regmap_write(rt766->regmap,
1015 RT766_SDCA_CTL(UAJ, CS36, SDCA_CTL_CS_SAMPLERATEINDEX),
1016 sampling_rate);
1017 break;
1018 case RT766_AIF2:
1019 regmap_write(rt766->regmap,
1020 RT766_SDCA_CTL(AMP, CS21, SDCA_CTL_CS_SAMPLERATEINDEX),
1021 sampling_rate);
1022 break;
1023 case RT766_AIF3:
1024 regmap_write(rt766->regmap,
1025 RT766_SDCA_CTL(MIC, CS113, SDCA_CTL_CS_SAMPLERATEINDEX),
1026 sampling_rate);
1027 break;
1028 default:
1029 dev_err(component->dev, "%s: Wrong DAI id\n", __func__);
1030 return -EINVAL;
1031 }
1032
1033 return 0;
1034 }
1035
rt766_sdca_pcm_hw_free(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)1036 static int rt766_sdca_pcm_hw_free(struct snd_pcm_substream *substream,
1037 struct snd_soc_dai *dai)
1038 {
1039 struct snd_soc_component *component = dai->component;
1040 struct rt766_sdca_priv *rt766 = snd_soc_component_get_drvdata(component);
1041 struct sdw_stream_runtime *sdw_stream =
1042 snd_soc_dai_get_dma_data(dai, substream);
1043
1044 if (!rt766->slave)
1045 return -EINVAL;
1046
1047 sdw_stream_remove_slave(rt766->slave, sdw_stream);
1048 return 0;
1049 }
1050
1051 #define RT766_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \
1052 SNDRV_PCM_RATE_192000)
1053 #define RT766_DAC_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE)
1054 #define RT766_ADC_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE | \
1055 SNDRV_PCM_FMTBIT_S32_LE)
1056
1057 static const struct snd_soc_dai_ops rt766_sdca_ops = {
1058 .hw_params = rt766_sdca_pcm_hw_params,
1059 .hw_free = rt766_sdca_pcm_hw_free,
1060 .set_stream = rt766_sdca_set_sdw_stream,
1061 .shutdown = rt766_sdca_shutdown,
1062 };
1063
1064 static struct snd_soc_dai_driver rt766_sdca_dai[] = {
1065 {
1066 .name = "rt766-sdca-aif1",
1067 .id = RT766_AIF1,
1068 .playback = {
1069 .stream_name = "DP3 Playback",
1070 .channels_min = 1,
1071 .channels_max = 2,
1072 .rates = RT766_STEREO_RATES,
1073 .formats = RT766_DAC_FORMATS,
1074 },
1075 .capture = {
1076 .stream_name = "DP12 Capture",
1077 .channels_min = 1,
1078 .channels_max = 2,
1079 .rates = RT766_STEREO_RATES,
1080 .formats = RT766_ADC_FORMATS,
1081 },
1082 .ops = &rt766_sdca_ops,
1083 .symmetric_rate = 1,
1084 },
1085 {
1086 .name = "rt766-sdca-aif2",
1087 .id = RT766_AIF2,
1088 .playback = {
1089 .stream_name = "DP1 Playback",
1090 .channels_min = 1,
1091 .channels_max = 4,
1092 .rates = RT766_STEREO_RATES,
1093 .formats = RT766_DAC_FORMATS,
1094 },
1095 .ops = &rt766_sdca_ops,
1096 },
1097 {
1098 .name = "rt766-sdca-aif3",
1099 .id = RT766_AIF3,
1100 .capture = {
1101 .stream_name = "DP8 Capture",
1102 .channels_min = 1,
1103 .channels_max = 4,
1104 .rates = RT766_STEREO_RATES,
1105 .formats = RT766_ADC_FORMATS,
1106 },
1107 .ops = &rt766_sdca_ops,
1108 }
1109 };
1110
rt766_find_dt_rates(struct device * dev,struct sdca_function_data * function,const char * label)1111 static unsigned int rt766_find_dt_rates(struct device *dev, struct sdca_function_data *function,
1112 const char *label)
1113 {
1114 struct snd_soc_pcm_stream stream;
1115 struct sdca_entity *entity;
1116 int i, ret;
1117
1118 for (i = 0; i < function->num_entities; i++) {
1119 entity = &function->entities[i];
1120
1121 if (strcmp(entity->label, label))
1122 continue;
1123
1124 /* Can't check earlier as only terminals have an iot member. */
1125 if (!entity->iot.is_dataport)
1126 continue;
1127
1128 ret = sdca_asoc_populate_rate_format(dev, function, entity, &stream);
1129 if (ret < 0) {
1130 dev_dbg(dev, "%s: failed to parse rates for entity %s\n",
1131 __func__, entity->label);
1132 return 0;
1133 }
1134
1135 dev_dbg(dev, "%s: %s supports rates 0x%08x\n", __func__, entity->label, stream.rates);
1136 }
1137
1138 return stream.rates;
1139 }
1140
rt766_sdca_init(struct device * dev,struct regmap * regmap,struct sdw_slave * slave)1141 int rt766_sdca_init(struct device *dev, struct regmap *regmap, struct sdw_slave *slave)
1142 {
1143 struct sdca_function_data *func_data_ptr;
1144 struct snd_soc_dai_driver *dai_drv;
1145 struct rt766_sdca_priv *rt766;
1146 unsigned int rates;
1147 int ret;
1148 int i;
1149
1150 rt766 = devm_kzalloc(dev, sizeof(*rt766), GFP_KERNEL);
1151 if (!rt766)
1152 return -ENOMEM;
1153
1154 dev_set_drvdata(dev, rt766);
1155 rt766->slave = slave;
1156 rt766->regmap = regmap;
1157
1158 regcache_cache_only(rt766->regmap, true);
1159
1160 ret = devm_mutex_init(dev, &rt766->disable_irq_lock);
1161 if (ret < 0) {
1162 dev_err(dev, "Failed to initialize mutex\n");
1163 return ret;
1164 }
1165
1166 /*
1167 * Mark hw_init to false
1168 * HW init will be performed when device reports present
1169 */
1170 rt766->hw_init = false;
1171 rt766->first_hw_init = false;
1172 rt766->fu41_dapm_mute = true;
1173 rt766->fu41_mixer_l_mute = rt766->fu41_mixer_r_mute = false;
1174 rt766->fu36_dapm_mute = true;
1175 rt766->fu36_mixer_l_mute = rt766->fu36_mixer_r_mute = true;
1176 rt766->fu21_dapm_mute = true;
1177 rt766->fu21_mixer_l_mute = rt766->fu21_mixer_r_mute = false;
1178 rt766->fu113_dapm_mute = true;
1179 rt766->fu113_mixer_mute[0] = rt766->fu113_mixer_mute[1] =
1180 rt766->fu113_mixer_mute[2] = rt766->fu113_mixer_mute[3] = true;
1181
1182 dai_drv = devm_kzalloc(dev, sizeof(struct snd_soc_dai_driver) * ARRAY_SIZE(rt766_sdca_dai), GFP_KERNEL);
1183 if (!dai_drv) {
1184 dev_err(dev, "Failed to allocate memory for DAI driver\n");
1185 ret = -ENOMEM;
1186 goto _sdw_init_err_;
1187 }
1188 memcpy(dai_drv, rt766_sdca_dai, sizeof(struct snd_soc_dai_driver) * ARRAY_SIZE(rt766_sdca_dai));
1189
1190 /* get SDCA function data */
1191 dev_dbg(dev, "SDCA functions found: %d", slave->sdca_data.num_functions);
1192 for (i = 0; i < slave->sdca_data.num_functions; i++) {
1193 func_data_ptr = devm_kzalloc(dev, sizeof(*func_data_ptr), GFP_KERNEL);
1194 if (!func_data_ptr) {
1195 dev_err(dev, "Failed to allocate memory for function data\n");
1196 ret = -ENOMEM;
1197 goto _free_dai_drv_;
1198 }
1199
1200 func_data_ptr->desc = &slave->sdca_data.function[i];
1201 ret = sdca_parse_function(dev, func_data_ptr);
1202 if (ret) {
1203 devm_kfree(dev, func_data_ptr);
1204 goto _free_dai_drv_;
1205 }
1206 dev_dbg(dev, "Function type=%d, num_entities=%d",
1207 slave->sdca_data.function[i].type, func_data_ptr->num_entities);
1208
1209 switch (slave->sdca_data.function[i].type) {
1210 case SDCA_FUNCTION_TYPE_UAJ:
1211 rt766->uaj_func_data = func_data_ptr;
1212 /*
1213 * Some machines may only support a subset of the sample rates supported by the codec.
1214 * Therefore, we need to parse the supported sample rates from the DisCo table and
1215 * configure them in the DAI. If the DisCo table does not provide sample rate information,
1216 * we will fall back to the default supported rates defined in the codec driver.
1217 */
1218 rates = rt766_find_dt_rates(dev, func_data_ptr, "IT 41");
1219 if (rates)
1220 dai_drv[RT766_DAI_UAJ].playback.rates = rates;
1221
1222 rates = rt766_find_dt_rates(dev, func_data_ptr, "OT 36");
1223 if (rates)
1224 dai_drv[RT766_DAI_UAJ].capture.rates = rates;
1225 break;
1226 case SDCA_FUNCTION_TYPE_SMART_AMP:
1227 rt766->sa_func_data = func_data_ptr;
1228 rates = rt766_find_dt_rates(dev, func_data_ptr, "IT 21");
1229 if (rates)
1230 dai_drv[RT766_DAI_AMP].playback.rates = rates;
1231 break;
1232 case SDCA_FUNCTION_TYPE_SMART_MIC:
1233 rt766->sm_func_data = func_data_ptr;
1234 rates = rt766_find_dt_rates(dev, func_data_ptr, "OT 113");
1235 if (rates)
1236 dai_drv[RT766_DAI_MIC].capture.rates = rates;
1237 break;
1238 case SDCA_FUNCTION_TYPE_HID:
1239 rt766->hid_func_data = func_data_ptr;
1240 break;
1241 default:
1242 dev_dbg(dev, "Unexpected SDCA function type found: %d",
1243 slave->sdca_data.function[i].type);
1244 }
1245 }
1246
1247 ret = devm_snd_soc_register_component(dev,
1248 &soc_sdca_dev_rt766, dai_drv, ARRAY_SIZE(rt766_sdca_dai));
1249 if (ret < 0)
1250 goto _free_dai_drv_;
1251
1252 /* set autosuspend parameters */
1253 pm_runtime_set_autosuspend_delay(dev, 3000);
1254 pm_runtime_use_autosuspend(dev);
1255
1256 /* make sure the device does not suspend immediately */
1257 pm_runtime_mark_last_busy(dev);
1258
1259 pm_runtime_enable(dev);
1260 dev_dbg(dev, "%s\n", __func__);
1261 return 0;
1262
1263 _free_dai_drv_:
1264 if (dai_drv)
1265 devm_kfree(dev, dai_drv);
1266
1267 _sdw_init_err_:
1268 return ret;
1269 }
1270
rt766_func_initialize(struct rt766_sdca_priv * rt766,struct sdca_function_data * func_data)1271 static int rt766_func_initialize(struct rt766_sdca_priv *rt766, struct sdca_function_data *func_data)
1272 {
1273 struct device *dev = &rt766->slave->dev;
1274 unsigned int func_status_reg;
1275 unsigned int func_status;
1276 int ret;
1277
1278 switch (func_data->desc->type) {
1279 case SDCA_FUNCTION_TYPE_UAJ:
1280 func_status_reg = RT766_FUNC_STATUS_REG(UAJ);
1281 break;
1282 case SDCA_FUNCTION_TYPE_SMART_AMP:
1283 func_status_reg = RT766_FUNC_STATUS_REG(AMP);
1284 break;
1285 case SDCA_FUNCTION_TYPE_SMART_MIC:
1286 func_status_reg = RT766_FUNC_STATUS_REG(MIC);
1287 break;
1288 case SDCA_FUNCTION_TYPE_HID:
1289 func_status_reg = RT766_FUNC_STATUS_REG(HID);
1290 break;
1291 default:
1292 dev_dbg(dev, "Unexpected SDCA function type found: %d",
1293 func_data->desc->type);
1294 return -EINVAL;
1295 }
1296
1297 regmap_read(rt766->regmap, func_status_reg, &func_status);
1298 dev_dbg(dev, "%s, %s func_status=0x%x\n", __func__, func_data->desc->name, func_status);
1299
1300 if ((func_status & SDCA_CTL_ENTITY_0_FUNCTION_NEEDS_INITIALIZATION) || (!rt766->first_hw_init)) {
1301 ret = sdca_regmap_write_init(dev, rt766->regmap, func_data);
1302 if (ret) {
1303 dev_err(dev, "%s initialization table update failed\n", func_data->desc->name);
1304 goto _func_init_err_;
1305 }
1306
1307 regmap_write(rt766->regmap, func_status_reg,
1308 SDCA_CTL_ENTITY_0_FUNCTION_NEEDS_INITIALIZATION);
1309 }
1310
1311 return 0;
1312
1313 _func_init_err_:
1314 dev_err(dev, "%s: %s init writes failed, err=%d", __func__, func_data->desc->name, ret);
1315 return ret;
1316 }
1317
rt766_sdca_io_init(struct device * dev,struct sdw_slave * slave)1318 int rt766_sdca_io_init(struct device *dev, struct sdw_slave *slave)
1319 {
1320 struct rt766_sdca_priv *rt766 = dev_get_drvdata(dev);
1321 unsigned int val;
1322
1323 rt766->disable_irq = false;
1324
1325 if (rt766->hw_init)
1326 return 0;
1327
1328 regcache_cache_only(rt766->regmap, false);
1329 if (rt766->first_hw_init) {
1330 regcache_cache_bypass(rt766->regmap, true);
1331 } else {
1332 /*
1333 * PM runtime status is marked as 'active' only when a Slave reports as Attached
1334 */
1335
1336 /* update count of parent 'active' children */
1337 pm_runtime_set_active(&slave->dev);
1338 }
1339
1340 pm_runtime_get_noresume(&slave->dev);
1341
1342 regmap_read(rt766->regmap, RT766_BOND_LATCH_ID, &val);
1343 dev_dbg(&slave->dev, "%s bond ID=0x%x (%s)\n", __func__, val, (val == 0x1) ? "RT767" : "RT766");
1344
1345 /* check function status and initialize if needed */
1346 if (rt766->uaj_func_data)
1347 rt766_func_initialize(rt766, rt766->uaj_func_data);
1348 if (rt766->sa_func_data)
1349 rt766_func_initialize(rt766, rt766->sa_func_data);
1350 if (rt766->sm_func_data)
1351 rt766_func_initialize(rt766, rt766->sm_func_data);
1352 if (rt766->hid_func_data)
1353 rt766_func_initialize(rt766, rt766->hid_func_data);
1354
1355 if (rt766->first_hw_init) {
1356 regcache_cache_bypass(rt766->regmap, false);
1357 regcache_mark_dirty(rt766->regmap);
1358 } else {
1359 rt766->first_hw_init = true;
1360 }
1361
1362 /* Mark Slave initialization complete */
1363 rt766->hw_init = true;
1364
1365 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
1366
1367 pm_runtime_put_autosuspend(&slave->dev);
1368
1369 return 0;
1370 }
1371
1372 MODULE_DESCRIPTION("ASoC RT766 SDCA SDW driver");
1373 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
1374 MODULE_LICENSE("GPL");
1375 MODULE_IMPORT_NS("SND_SOC_SDCA");
1376