1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // rt712-sdca.c -- rt712 SDCA ALSA SoC audio driver
4 //
5 // Copyright(c) 2023 Realtek Semiconductor Corp.
6 //
7 //
8
9 #include <linux/bitops.h>
10 #include <linux/cleanup.h>
11 #include <sound/core.h>
12 #include <linux/delay.h>
13 #include <linux/init.h>
14 #include <sound/initval.h>
15 #include <sound/jack.h>
16 #include <linux/kernel.h>
17 #include <linux/module.h>
18 #include <linux/moduleparam.h>
19 #include <linux/pm_runtime.h>
20 #include <sound/pcm.h>
21 #include <sound/pcm_params.h>
22 #include <sound/sdca.h>
23 #include <linux/soundwire/sdw_registers.h>
24 #include <linux/slab.h>
25 #include <sound/soc-dapm.h>
26 #include <sound/tlv.h>
27 #include "rt712-sdca.h"
28
rt712_sdca_index_write(struct rt712_sdca_priv * rt712,unsigned int nid,unsigned int reg,unsigned int value)29 static int rt712_sdca_index_write(struct rt712_sdca_priv *rt712,
30 unsigned int nid, unsigned int reg, unsigned int value)
31 {
32 int ret;
33 struct regmap *regmap = rt712->mbq_regmap;
34 unsigned int addr = (nid << 20) | reg;
35
36 ret = regmap_write(regmap, addr, value);
37 if (ret < 0)
38 dev_err(&rt712->slave->dev,
39 "%s: Failed to set private value: %06x <= %04x ret=%d\n",
40 __func__, addr, value, ret);
41
42 return ret;
43 }
44
rt712_sdca_index_read(struct rt712_sdca_priv * rt712,unsigned int nid,unsigned int reg,unsigned int * value)45 static int rt712_sdca_index_read(struct rt712_sdca_priv *rt712,
46 unsigned int nid, unsigned int reg, unsigned int *value)
47 {
48 int ret;
49 struct regmap *regmap = rt712->mbq_regmap;
50 unsigned int addr = (nid << 20) | reg;
51
52 ret = regmap_read(regmap, addr, value);
53 if (ret < 0)
54 dev_err(&rt712->slave->dev,
55 "%s: Failed to get private value: %06x => %04x ret=%d\n",
56 __func__, addr, *value, ret);
57
58 return ret;
59 }
60
rt712_sdca_index_update_bits(struct rt712_sdca_priv * rt712,unsigned int nid,unsigned int reg,unsigned int mask,unsigned int val)61 static int rt712_sdca_index_update_bits(struct rt712_sdca_priv *rt712,
62 unsigned int nid, unsigned int reg, unsigned int mask, unsigned int val)
63 {
64 unsigned int tmp;
65 int ret;
66
67 ret = rt712_sdca_index_read(rt712, nid, reg, &tmp);
68 if (ret < 0)
69 return ret;
70
71 set_mask_bits(&tmp, mask, val);
72 return rt712_sdca_index_write(rt712, nid, reg, tmp);
73 }
74
rt712_sdca_calibration(struct rt712_sdca_priv * rt712)75 static int rt712_sdca_calibration(struct rt712_sdca_priv *rt712)
76 {
77 unsigned int val, loop_rc = 0, loop_dc = 0;
78 struct device *dev;
79 struct regmap *regmap = rt712->regmap;
80 int chk_cnt = 100;
81 int ret = 0;
82
83 mutex_lock(&rt712->calibrate_mutex);
84 dev = regmap_get_device(regmap);
85
86 /* Set HP-JD source from JD1 */
87 if (rt712->version_id == RT712_VA)
88 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_CC_DET1, 0x043a);
89
90 /* FSM switch to calibration manual mode */
91 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_FSM_CTL, 0x4100);
92
93 /* Calibration setting */
94 rt712_sdca_index_write(rt712, RT712_VENDOR_CALI, RT712_DAC_DC_CALI_CTL1, 0x7883);
95
96 /* W1C Trigger DC calibration (HP & Class-D) */
97 rt712_sdca_index_write(rt712, RT712_VENDOR_CALI, RT712_DAC_DC_CALI_CTL1, 0xf893);
98
99 /* wait for calibration process */
100 rt712_sdca_index_read(rt712, RT712_VENDOR_CALI,
101 RT712_DAC_DC_CALI_CTL1, &val);
102
103 for (loop_dc = 0; loop_dc < chk_cnt &&
104 (val & RT712_DAC_DC_CALI_TRIGGER); loop_dc++) {
105 usleep_range(10000, 11000);
106 ret = rt712_sdca_index_read(rt712, RT712_VENDOR_CALI,
107 RT712_DAC_DC_CALI_CTL1, &val);
108 if (ret < 0)
109 goto _cali_fail_;
110 }
111 if (loop_dc == chk_cnt)
112 dev_err(dev, "%s, calibration time-out!\n", __func__);
113
114 if (loop_dc == chk_cnt || loop_rc == chk_cnt)
115 ret = -ETIMEDOUT;
116
117 _cali_fail_:
118 /* Enable Rldet in FSM */
119 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_FSM_CTL, 0x4500);
120
121 /* Sensing Lch+Rch */
122 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_IMS_DIGITAL_CTL1, 0x040f);
123
124 /* Sine gen path control */
125 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_IMS_DIGITAL_CTL5, 0x0000);
126
127 /* Release HP-JD, EN_CBJ_TIE_GL/R open, en_osw gating auto done bit */
128 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_DIGITAL_MISC_CTRL4, 0x0010);
129
130 mutex_unlock(&rt712->calibrate_mutex);
131 dev_dbg(dev, "%s calibration complete, ret=%d\n", __func__, ret);
132 return ret;
133 }
134
rt712_sdca_button_detect(struct rt712_sdca_priv * rt712)135 static unsigned int rt712_sdca_button_detect(struct rt712_sdca_priv *rt712)
136 {
137 unsigned int btn_type = 0, offset, idx, val, owner;
138 int ret;
139 unsigned char buf[3];
140
141 /* get current UMP message owner */
142 ret = regmap_read(rt712->regmap,
143 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_CURRENT_OWNER, 0),
144 &owner);
145 if (ret < 0)
146 return 0;
147
148 /* if owner is device then there is no button event from device */
149 if (owner == 1)
150 return 0;
151
152 /* read UMP message offset */
153 ret = regmap_read(rt712->regmap,
154 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0),
155 &offset);
156 if (ret < 0)
157 goto _end_btn_det_;
158
159 for (idx = 0; idx < sizeof(buf); idx++) {
160 ret = regmap_read(rt712->regmap,
161 RT712_BUF_ADDR_HID1 + offset + idx, &val);
162 if (ret < 0)
163 goto _end_btn_det_;
164 buf[idx] = val & 0xff;
165 }
166
167 if (buf[0] == 0x11) {
168 switch (buf[1] & 0xf0) {
169 case 0x10:
170 btn_type |= SND_JACK_BTN_2;
171 break;
172 case 0x20:
173 btn_type |= SND_JACK_BTN_3;
174 break;
175 case 0x40:
176 btn_type |= SND_JACK_BTN_0;
177 break;
178 case 0x80:
179 btn_type |= SND_JACK_BTN_1;
180 break;
181 }
182 switch (buf[2]) {
183 case 0x01:
184 case 0x10:
185 btn_type |= SND_JACK_BTN_2;
186 break;
187 case 0x02:
188 case 0x20:
189 btn_type |= SND_JACK_BTN_3;
190 break;
191 case 0x04:
192 case 0x40:
193 btn_type |= SND_JACK_BTN_0;
194 break;
195 case 0x08:
196 case 0x80:
197 btn_type |= SND_JACK_BTN_1;
198 break;
199 }
200 }
201
202 _end_btn_det_:
203 /* Host is owner, so set back to device */
204 if (owner == 0) {
205 /* set owner to device */
206 if (rt712->version_id == RT712_VA)
207 regmap_write(rt712->regmap,
208 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01,
209 RT712_SDCA_CTL_HIDTX_SET_OWNER_TO_DEVICE, 0), 0x01);
210 else
211 regmap_write(rt712->regmap,
212 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01,
213 RT712_SDCA_CTL_HIDTX_CURRENT_OWNER, 0), 0x01);
214 }
215
216 return btn_type;
217 }
218
rt712_sdca_headset_detect(struct rt712_sdca_priv * rt712)219 static int rt712_sdca_headset_detect(struct rt712_sdca_priv *rt712)
220 {
221 unsigned int det_mode;
222 int ret;
223
224 /* get detected_mode */
225 ret = regmap_read(rt712->regmap,
226 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_DETECTED_MODE, 0),
227 &det_mode);
228 if (ret < 0)
229 goto io_error;
230
231 switch (det_mode) {
232 case 0x00:
233 rt712->jack_type = 0;
234 break;
235 case 0x03:
236 rt712->jack_type = SND_JACK_HEADPHONE;
237 break;
238 case 0x05:
239 rt712->jack_type = SND_JACK_HEADSET;
240 break;
241 }
242
243 /* write selected_mode */
244 if (det_mode) {
245 ret = regmap_write(rt712->regmap,
246 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_SELECTED_MODE, 0),
247 det_mode);
248 if (ret < 0)
249 goto io_error;
250 }
251
252 dev_dbg(&rt712->slave->dev,
253 "%s, detected_mode=0x%x\n", __func__, det_mode);
254
255 return 0;
256
257 io_error:
258 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
259 return ret;
260 }
261
rt712_sdca_jack_detect_handler(struct work_struct * work)262 static void rt712_sdca_jack_detect_handler(struct work_struct *work)
263 {
264 struct rt712_sdca_priv *rt712 =
265 container_of(work, struct rt712_sdca_priv, jack_detect_work.work);
266 int btn_type = 0, ret;
267
268 if (!rt712->hs_jack)
269 return;
270
271 if (!rt712->component->card || !rt712->component->card->instantiated)
272 return;
273
274 /* SDW_SCP_SDCA_INT_SDCA_0 is used for jack detection */
275 if (rt712->scp_sdca_stat1 & SDW_SCP_SDCA_INT_SDCA_0) {
276 ret = rt712_sdca_headset_detect(rt712);
277 if (ret < 0)
278 return;
279 }
280
281 /* SDW_SCP_SDCA_INT_SDCA_8 is used for button detection */
282 if (rt712->scp_sdca_stat2 & SDW_SCP_SDCA_INT_SDCA_8)
283 btn_type = rt712_sdca_button_detect(rt712);
284
285 if (rt712->jack_type == 0)
286 btn_type = 0;
287
288 dev_dbg(&rt712->slave->dev,
289 "in %s, jack_type=0x%x\n", __func__, rt712->jack_type);
290 dev_dbg(&rt712->slave->dev,
291 "in %s, btn_type=0x%x\n", __func__, btn_type);
292 dev_dbg(&rt712->slave->dev,
293 "in %s, scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__,
294 rt712->scp_sdca_stat1, rt712->scp_sdca_stat2);
295
296 snd_soc_jack_report(rt712->hs_jack, rt712->jack_type | btn_type,
297 SND_JACK_HEADSET |
298 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
299 SND_JACK_BTN_2 | SND_JACK_BTN_3);
300
301 if (btn_type) {
302 /* button released */
303 snd_soc_jack_report(rt712->hs_jack, rt712->jack_type,
304 SND_JACK_HEADSET |
305 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
306 SND_JACK_BTN_2 | SND_JACK_BTN_3);
307
308 mod_delayed_work(system_power_efficient_wq,
309 &rt712->jack_btn_check_work, msecs_to_jiffies(200));
310 }
311 }
312
rt712_sdca_btn_check_handler(struct work_struct * work)313 static void rt712_sdca_btn_check_handler(struct work_struct *work)
314 {
315 struct rt712_sdca_priv *rt712 =
316 container_of(work, struct rt712_sdca_priv, jack_btn_check_work.work);
317 int btn_type = 0, ret, idx;
318 unsigned int det_mode, offset, val;
319 unsigned char buf[3];
320
321 ret = regmap_read(rt712->regmap,
322 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_DETECTED_MODE, 0),
323 &det_mode);
324 if (ret < 0)
325 goto io_error;
326
327 /* pin attached */
328 if (det_mode) {
329 /* read UMP message offset */
330 ret = regmap_read(rt712->regmap,
331 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0),
332 &offset);
333 if (ret < 0)
334 goto io_error;
335
336 for (idx = 0; idx < sizeof(buf); idx++) {
337 ret = regmap_read(rt712->regmap,
338 RT712_BUF_ADDR_HID1 + offset + idx, &val);
339 if (ret < 0)
340 goto io_error;
341 buf[idx] = val & 0xff;
342 }
343
344 if (buf[0] == 0x11) {
345 switch (buf[1] & 0xf0) {
346 case 0x10:
347 btn_type |= SND_JACK_BTN_2;
348 break;
349 case 0x20:
350 btn_type |= SND_JACK_BTN_3;
351 break;
352 case 0x40:
353 btn_type |= SND_JACK_BTN_0;
354 break;
355 case 0x80:
356 btn_type |= SND_JACK_BTN_1;
357 break;
358 }
359 switch (buf[2]) {
360 case 0x01:
361 case 0x10:
362 btn_type |= SND_JACK_BTN_2;
363 break;
364 case 0x02:
365 case 0x20:
366 btn_type |= SND_JACK_BTN_3;
367 break;
368 case 0x04:
369 case 0x40:
370 btn_type |= SND_JACK_BTN_0;
371 break;
372 case 0x08:
373 case 0x80:
374 btn_type |= SND_JACK_BTN_1;
375 break;
376 }
377 }
378 } else {
379 rt712->jack_type = 0;
380 }
381
382 dev_dbg(&rt712->slave->dev, "%s, btn_type=0x%x\n", __func__, btn_type);
383 snd_soc_jack_report(rt712->hs_jack, rt712->jack_type | btn_type,
384 SND_JACK_HEADSET |
385 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
386 SND_JACK_BTN_2 | SND_JACK_BTN_3);
387
388 if (btn_type) {
389 /* button released */
390 snd_soc_jack_report(rt712->hs_jack, rt712->jack_type,
391 SND_JACK_HEADSET |
392 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
393 SND_JACK_BTN_2 | SND_JACK_BTN_3);
394
395 mod_delayed_work(system_power_efficient_wq,
396 &rt712->jack_btn_check_work, msecs_to_jiffies(200));
397 }
398
399 return;
400
401 io_error:
402 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
403 }
404
rt712_sdca_jack_init(struct rt712_sdca_priv * rt712)405 static void rt712_sdca_jack_init(struct rt712_sdca_priv *rt712)
406 {
407 guard(mutex)(&rt712->calibrate_mutex);
408
409 if (rt712->hs_jack) {
410 /* Enable HID1 event & set button RTC mode */
411 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL,
412 RT712_UMP_HID_CTL5, 0xfff0);
413 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
414 RT712_UMP_HID_CTL0, 0x1100, 0x1100);
415 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
416 RT712_UMP_HID_CTL7, 0xf000, 0x0000);
417
418 /* detected_mode_change_event_en & hid1_push_button_event_en */
419 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
420 RT712_GE_RELATED_CTL1, 0x0c00, 0x0c00);
421 /* ge_inbox_en */
422 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
423 RT712_GE_RELATED_CTL2, 0x0020, 0x0000);
424
425 switch (rt712->jd_src) {
426 case RT712_JD1:
427 /* Set HP-JD source from JD1, VB uses JD1 in default */
428 if (rt712->version_id == RT712_VA)
429 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_CC_DET1, 0x043a);
430 break;
431 default:
432 dev_warn(rt712->component->dev, "Wrong JD source\n");
433 break;
434 }
435
436 /* set SCP_SDCA_IntMask1[0]=1 */
437 sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INTMASK1, SDW_SCP_SDCA_INTMASK_SDCA_0);
438 /* set SCP_SDCA_IntMask2[0]=1 */
439 sdw_write_no_pm(rt712->slave, SDW_SCP_SDCA_INTMASK2, SDW_SCP_SDCA_INTMASK_SDCA_8);
440 dev_dbg(&rt712->slave->dev, "in %s enable\n", __func__);
441
442 /* trigger GE interrupt */
443 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
444 RT712_GE_RELATED_CTL1, 0x0080, 0x0080);
445 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
446 RT712_GE_RELATED_CTL1, 0x0080, 0x0000);
447 } else {
448 /* disable HID1 & detected_mode_change event */
449 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
450 RT712_GE_RELATED_CTL1, 0x0c00, 0x0000);
451
452 dev_dbg(&rt712->slave->dev, "in %s disable\n", __func__);
453 }
454 }
455
rt712_sdca_set_jack_detect(struct snd_soc_component * component,struct snd_soc_jack * hs_jack,void * data)456 static int rt712_sdca_set_jack_detect(struct snd_soc_component *component,
457 struct snd_soc_jack *hs_jack, void *data)
458 {
459 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
460 int ret;
461
462 rt712->hs_jack = hs_jack;
463
464 if (!rt712->first_hw_init)
465 return 0;
466
467 ret = pm_runtime_resume_and_get(component->dev);
468 if (ret < 0) {
469 if (ret != -EACCES) {
470 dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret);
471 return ret;
472 }
473
474 /* pm_runtime not enabled yet */
475 dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__);
476 return 0;
477 }
478
479 rt712_sdca_jack_init(rt712);
480
481 pm_runtime_put_autosuspend(component->dev);
482
483 return 0;
484 }
485
486 /* For SDCA control DAC/ADC Gain */
rt712_sdca_set_gain_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)487 static int rt712_sdca_set_gain_put(struct snd_kcontrol *kcontrol,
488 struct snd_ctl_elem_value *ucontrol)
489 {
490 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
491 struct soc_mixer_control *mc =
492 (struct soc_mixer_control *)kcontrol->private_value;
493 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
494 unsigned int read_l, read_r, gain_l_val, gain_r_val;
495 unsigned int adc_vol_flag = 0;
496 unsigned int lvalue, rvalue;
497 const unsigned int interval_offset = 0xc0;
498 const unsigned int tendB = 0xa00;
499
500 if (strstr(ucontrol->id.name, "FU0F Capture Volume"))
501 adc_vol_flag = 1;
502
503 regmap_read(rt712->mbq_regmap, mc->reg, &lvalue);
504 regmap_read(rt712->mbq_regmap, mc->rreg, &rvalue);
505
506 /* L Channel */
507 gain_l_val = ucontrol->value.integer.value[0];
508 if (gain_l_val > mc->max)
509 gain_l_val = mc->max;
510
511 if (mc->shift == 8) /* boost gain */
512 gain_l_val = gain_l_val * tendB;
513 else {
514 /* ADC/DAC gain */
515 if (adc_vol_flag)
516 gain_l_val = 0x1e00 - ((mc->max - gain_l_val) * interval_offset);
517 else
518 gain_l_val = 0 - ((mc->max - gain_l_val) * interval_offset);
519 gain_l_val &= 0xffff;
520 }
521
522 /* R Channel */
523 gain_r_val = ucontrol->value.integer.value[1];
524 if (gain_r_val > mc->max)
525 gain_r_val = mc->max;
526
527 if (mc->shift == 8) /* boost gain */
528 gain_r_val = gain_r_val * tendB;
529 else {
530 /* ADC/DAC gain */
531 if (adc_vol_flag)
532 gain_r_val = 0x1e00 - ((mc->max - gain_r_val) * interval_offset);
533 else
534 gain_r_val = 0 - ((mc->max - gain_r_val) * interval_offset);
535 gain_r_val &= 0xffff;
536 }
537
538 if (lvalue == gain_l_val && rvalue == gain_r_val)
539 return 0;
540
541 /* Lch*/
542 regmap_write(rt712->mbq_regmap, mc->reg, gain_l_val);
543 /* Rch */
544 regmap_write(rt712->mbq_regmap, mc->rreg, gain_r_val);
545
546 regmap_read(rt712->mbq_regmap, mc->reg, &read_l);
547 regmap_read(rt712->mbq_regmap, mc->rreg, &read_r);
548 if (read_r == gain_r_val && read_l == gain_l_val)
549 return 1;
550
551 return -EIO;
552 }
553
rt712_sdca_set_gain_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)554 static int rt712_sdca_set_gain_get(struct snd_kcontrol *kcontrol,
555 struct snd_ctl_elem_value *ucontrol)
556 {
557 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
558 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
559 struct soc_mixer_control *mc =
560 (struct soc_mixer_control *)kcontrol->private_value;
561 unsigned int read_l, read_r, ctl_l = 0, ctl_r = 0;
562 unsigned int adc_vol_flag = 0;
563 const unsigned int interval_offset = 0xc0;
564 const unsigned int tendB = 0xa00;
565
566 if (strstr(ucontrol->id.name, "FU0F Capture Volume"))
567 adc_vol_flag = 1;
568
569 regmap_read(rt712->mbq_regmap, mc->reg, &read_l);
570 regmap_read(rt712->mbq_regmap, mc->rreg, &read_r);
571
572 if (mc->shift == 8) /* boost gain */
573 ctl_l = read_l / tendB;
574 else {
575 if (adc_vol_flag)
576 ctl_l = mc->max - (((0x1e00 - read_l) & 0xffff) / interval_offset);
577 else
578 ctl_l = mc->max - (((0 - read_l) & 0xffff) / interval_offset);
579 }
580
581 if (read_l != read_r) {
582 if (mc->shift == 8) /* boost gain */
583 ctl_r = read_r / tendB;
584 else { /* ADC/DAC gain */
585 if (adc_vol_flag)
586 ctl_r = mc->max - (((0x1e00 - read_r) & 0xffff) / interval_offset);
587 else
588 ctl_r = mc->max - (((0 - read_r) & 0xffff) / interval_offset);
589 }
590 } else
591 ctl_r = ctl_l;
592
593 ucontrol->value.integer.value[0] = ctl_l;
594 ucontrol->value.integer.value[1] = ctl_r;
595
596 return 0;
597 }
598
rt712_sdca_set_fu0f_capture_ctl(struct rt712_sdca_priv * rt712)599 static int rt712_sdca_set_fu0f_capture_ctl(struct rt712_sdca_priv *rt712)
600 {
601 int err;
602 unsigned int ch_01, ch_02;
603
604 ch_01 = (rt712->fu0f_dapm_mute || rt712->fu0f_mixer_l_mute) ? 0x01 : 0x00;
605 ch_02 = (rt712->fu0f_dapm_mute || rt712->fu0f_mixer_r_mute) ? 0x01 : 0x00;
606
607 err = regmap_write(rt712->regmap,
608 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F,
609 RT712_SDCA_CTL_FU_MUTE, CH_01), ch_01);
610 if (err < 0)
611 return err;
612
613 err = regmap_write(rt712->regmap,
614 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F,
615 RT712_SDCA_CTL_FU_MUTE, CH_02), ch_02);
616 if (err < 0)
617 return err;
618
619 return 0;
620 }
621
rt712_sdca_fu0f_capture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)622 static int rt712_sdca_fu0f_capture_get(struct snd_kcontrol *kcontrol,
623 struct snd_ctl_elem_value *ucontrol)
624 {
625 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
626 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
627
628 ucontrol->value.integer.value[0] = !rt712->fu0f_mixer_l_mute;
629 ucontrol->value.integer.value[1] = !rt712->fu0f_mixer_r_mute;
630 return 0;
631 }
632
rt712_sdca_fu0f_capture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)633 static int rt712_sdca_fu0f_capture_put(struct snd_kcontrol *kcontrol,
634 struct snd_ctl_elem_value *ucontrol)
635 {
636 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
637 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
638 int err;
639
640 if (rt712->fu0f_mixer_l_mute == !ucontrol->value.integer.value[0] &&
641 rt712->fu0f_mixer_r_mute == !ucontrol->value.integer.value[1])
642 return 0;
643
644 rt712->fu0f_mixer_l_mute = !ucontrol->value.integer.value[0];
645 rt712->fu0f_mixer_r_mute = !ucontrol->value.integer.value[1];
646 err = rt712_sdca_set_fu0f_capture_ctl(rt712);
647 if (err < 0)
648 return err;
649
650 return 1;
651 }
652
rt712_sdca_set_fu05_playback_ctl(struct rt712_sdca_priv * rt712)653 static int rt712_sdca_set_fu05_playback_ctl(struct rt712_sdca_priv *rt712)
654 {
655 int err;
656 unsigned int ch_01, ch_02;
657
658 ch_01 = (rt712->fu05_dapm_mute || rt712->fu05_mixer_l_mute) ? 0x01 : 0x00;
659 ch_02 = (rt712->fu05_dapm_mute || rt712->fu05_mixer_r_mute) ? 0x01 : 0x00;
660
661 err = regmap_write(rt712->regmap,
662 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05,
663 RT712_SDCA_CTL_FU_MUTE, CH_01), ch_01);
664 if (err < 0)
665 return err;
666
667 err = regmap_write(rt712->regmap,
668 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05,
669 RT712_SDCA_CTL_FU_MUTE, CH_02), ch_02);
670 if (err < 0)
671 return err;
672
673 return 0;
674 }
675
rt712_sdca_fu05_playback_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)676 static int rt712_sdca_fu05_playback_get(struct snd_kcontrol *kcontrol,
677 struct snd_ctl_elem_value *ucontrol)
678 {
679 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
680 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
681
682 ucontrol->value.integer.value[0] = !rt712->fu05_mixer_l_mute;
683 ucontrol->value.integer.value[1] = !rt712->fu05_mixer_r_mute;
684 return 0;
685 }
686
rt712_sdca_fu05_playback_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)687 static int rt712_sdca_fu05_playback_put(struct snd_kcontrol *kcontrol,
688 struct snd_ctl_elem_value *ucontrol)
689 {
690 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
691 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
692 int err;
693
694 if (rt712->fu05_mixer_l_mute == !ucontrol->value.integer.value[0] &&
695 rt712->fu05_mixer_r_mute == !ucontrol->value.integer.value[1])
696 return 0;
697
698 rt712->fu05_mixer_l_mute = !ucontrol->value.integer.value[0];
699 rt712->fu05_mixer_r_mute = !ucontrol->value.integer.value[1];
700
701 err = rt712_sdca_set_fu05_playback_ctl(rt712);
702 if (err < 0)
703 return err;
704
705 return 1;
706 }
707
708 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
709 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, -1725, 75, 0);
710 static const DECLARE_TLV_DB_SCALE(boost_vol_tlv, 0, 1000, 0);
711
712 static const struct snd_kcontrol_new rt712_sdca_controls[] = {
713 SOC_DOUBLE_R_EXT_TLV("FU05 Playback Volume",
714 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05, RT712_SDCA_CTL_FU_VOLUME, CH_01),
715 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05, RT712_SDCA_CTL_FU_VOLUME, CH_02),
716 0, 0x57, 0,
717 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, out_vol_tlv),
718 SOC_DOUBLE_EXT("FU0F Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0,
719 rt712_sdca_fu0f_capture_get, rt712_sdca_fu0f_capture_put),
720 SOC_DOUBLE_R_EXT_TLV("FU0F Capture Volume",
721 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F, RT712_SDCA_CTL_FU_VOLUME, CH_01),
722 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F, RT712_SDCA_CTL_FU_VOLUME, CH_02),
723 0, 0x3f, 0,
724 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, mic_vol_tlv),
725 SOC_DOUBLE_R_EXT_TLV("FU44 Boost Volume",
726 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PLATFORM_FU44, RT712_SDCA_CTL_FU_CH_GAIN, CH_01),
727 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PLATFORM_FU44, RT712_SDCA_CTL_FU_CH_GAIN, CH_02),
728 8, 3, 0,
729 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, boost_vol_tlv),
730 SOC_DOUBLE_EXT("FU05 Playback Switch", SND_SOC_NOPM, 0, 1, 1, 0,
731 rt712_sdca_fu05_playback_get, rt712_sdca_fu05_playback_put),
732 };
733
734 static const struct snd_kcontrol_new rt712_sdca_spk_controls[] = {
735 SOC_DOUBLE_R_EXT_TLV("FU06 Playback Volume",
736 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_VOLUME, CH_01),
737 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_VOLUME, CH_02),
738 0, 0x57, 0,
739 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, out_vol_tlv),
740 };
741
rt712_sdca_mux_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)742 static int rt712_sdca_mux_get(struct snd_kcontrol *kcontrol,
743 struct snd_ctl_elem_value *ucontrol)
744 {
745 struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol);
746 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
747 unsigned int val = 0, mask = 0x3300;
748
749 rt712_sdca_index_read(rt712, RT712_VENDOR_HDA_CTL, RT712_MIXER_CTL1, &val);
750
751 val = val & mask;
752 switch (val) {
753 case 0x3000:
754 val = 1;
755 break;
756 case 0x0300:
757 val = 0;
758 break;
759 }
760
761 ucontrol->value.enumerated.item[0] = val;
762
763 return 0;
764 }
765
rt712_sdca_mux_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)766 static int rt712_sdca_mux_put(struct snd_kcontrol *kcontrol,
767 struct snd_ctl_elem_value *ucontrol)
768 {
769 struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol);
770 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_to_dapm(kcontrol);
771 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
772 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
773 unsigned int *item = ucontrol->value.enumerated.item;
774 unsigned int mask_sft;
775 unsigned int val;
776
777 if (item[0] >= e->items)
778 return -EINVAL;
779
780 if (ucontrol->value.enumerated.item[0] == 0)
781 mask_sft = 12;
782 else if (ucontrol->value.enumerated.item[0] == 1)
783 mask_sft = 8;
784 else
785 return -EINVAL;
786
787 rt712_sdca_index_read(rt712, RT712_VENDOR_HDA_CTL, RT712_MIXER_CTL1, &val);
788 val = (val >> mask_sft) & 0x3;
789 if (!val)
790 return 0;
791
792 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL,
793 RT712_MIXER_CTL1, 0x3fff);
794 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
795 RT712_MIXER_CTL1, 0x3 << mask_sft, 0);
796
797 snd_soc_dapm_mux_update_power(dapm, kcontrol,
798 item[0], e, NULL);
799
800 return 1;
801 }
802
803 static const char * const adc_mux_text[] = {
804 "MIC2",
805 "LINE2",
806 };
807
808 static SOC_ENUM_SINGLE_DECL(
809 rt712_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
810
811 static const struct snd_kcontrol_new rt712_sdca_adc23_mux =
812 SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt712_adc23_enum,
813 rt712_sdca_mux_get, rt712_sdca_mux_put);
814
rt712_sdca_fu05_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)815 static int rt712_sdca_fu05_event(struct snd_soc_dapm_widget *w,
816 struct snd_kcontrol *kcontrol, int event)
817 {
818 struct snd_soc_component *component =
819 snd_soc_dapm_to_component(w->dapm);
820 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
821
822 switch (event) {
823 case SND_SOC_DAPM_POST_PMU:
824 rt712->fu05_dapm_mute = false;
825 rt712_sdca_set_fu05_playback_ctl(rt712);
826 break;
827 case SND_SOC_DAPM_PRE_PMD:
828 rt712->fu05_dapm_mute = true;
829 rt712_sdca_set_fu05_playback_ctl(rt712);
830 break;
831 }
832 return 0;
833 }
834
rt712_sdca_fu0f_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)835 static int rt712_sdca_fu0f_event(struct snd_soc_dapm_widget *w,
836 struct snd_kcontrol *kcontrol, int event)
837 {
838 struct snd_soc_component *component =
839 snd_soc_dapm_to_component(w->dapm);
840 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
841
842 switch (event) {
843 case SND_SOC_DAPM_POST_PMU:
844 rt712->fu0f_dapm_mute = false;
845 rt712_sdca_set_fu0f_capture_ctl(rt712);
846 break;
847 case SND_SOC_DAPM_PRE_PMD:
848 rt712->fu0f_dapm_mute = true;
849 rt712_sdca_set_fu0f_capture_ctl(rt712);
850 break;
851 }
852 return 0;
853 }
854
rt712_sdca_pde40_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)855 static int rt712_sdca_pde40_event(struct snd_soc_dapm_widget *w,
856 struct snd_kcontrol *kcontrol, int event)
857 {
858 struct snd_soc_component *component =
859 snd_soc_dapm_to_component(w->dapm);
860 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
861 unsigned char ps0 = 0x0, ps3 = 0x3;
862
863 switch (event) {
864 case SND_SOC_DAPM_POST_PMU:
865 regmap_write(rt712->regmap,
866 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE40,
867 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
868 ps0);
869 break;
870 case SND_SOC_DAPM_PRE_PMD:
871 regmap_write(rt712->regmap,
872 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE40,
873 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
874 ps3);
875 break;
876 }
877 return 0;
878 }
879
rt712_sdca_pde12_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)880 static int rt712_sdca_pde12_event(struct snd_soc_dapm_widget *w,
881 struct snd_kcontrol *kcontrol, int event)
882 {
883 struct snd_soc_component *component =
884 snd_soc_dapm_to_component(w->dapm);
885 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
886 unsigned char ps0 = 0x0, ps3 = 0x3;
887
888 switch (event) {
889 case SND_SOC_DAPM_POST_PMU:
890 regmap_write(rt712->regmap,
891 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE12,
892 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
893 ps0);
894 break;
895 case SND_SOC_DAPM_PRE_PMD:
896 regmap_write(rt712->regmap,
897 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE12,
898 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
899 ps3);
900 break;
901 }
902 return 0;
903 }
904
rt712_sdca_pde23_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)905 static int rt712_sdca_pde23_event(struct snd_soc_dapm_widget *w,
906 struct snd_kcontrol *kcontrol, int event)
907 {
908 struct snd_soc_component *component =
909 snd_soc_dapm_to_component(w->dapm);
910 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
911 unsigned char ps0 = 0x0, ps3 = 0x3;
912
913 switch (event) {
914 case SND_SOC_DAPM_POST_PMU:
915 regmap_write(rt712->regmap,
916 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_PDE23,
917 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
918 ps0);
919 break;
920 case SND_SOC_DAPM_PRE_PMD:
921 regmap_write(rt712->regmap,
922 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_PDE23,
923 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
924 ps3);
925 break;
926
927 default:
928 break;
929 }
930
931 return 0;
932 }
933
934 static const struct snd_kcontrol_new rt712_spk_l_dac =
935 SOC_DAPM_SINGLE_AUTODISABLE("Switch",
936 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_MUTE, CH_01),
937 0, 1, 1);
938 static const struct snd_kcontrol_new rt712_spk_r_dac =
939 SOC_DAPM_SINGLE_AUTODISABLE("Switch",
940 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_MUTE, CH_02),
941 0, 1, 1);
942
943 static const struct snd_soc_dapm_widget rt712_sdca_dapm_widgets[] = {
944 SND_SOC_DAPM_OUTPUT("HP"),
945 SND_SOC_DAPM_INPUT("MIC2"),
946 SND_SOC_DAPM_INPUT("LINE2"),
947
948 SND_SOC_DAPM_SUPPLY("PDE 40", SND_SOC_NOPM, 0, 0,
949 rt712_sdca_pde40_event,
950 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
951 SND_SOC_DAPM_SUPPLY("PDE 12", SND_SOC_NOPM, 0, 0,
952 rt712_sdca_pde12_event,
953 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
954
955 SND_SOC_DAPM_DAC_E("FU 05", NULL, SND_SOC_NOPM, 0, 0,
956 rt712_sdca_fu05_event,
957 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
958 SND_SOC_DAPM_ADC_E("FU 0F", NULL, SND_SOC_NOPM, 0, 0,
959 rt712_sdca_fu0f_event,
960 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
961 SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
962 &rt712_sdca_adc23_mux),
963
964 SND_SOC_DAPM_AIF_IN("DP1RX", "DP1 Playback", 0, SND_SOC_NOPM, 0, 0),
965 SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
966 };
967
968 static const struct snd_soc_dapm_route rt712_sdca_audio_map[] = {
969 { "FU 05", NULL, "DP1RX" },
970 { "DP4TX", NULL, "FU 0F" },
971
972 { "FU 0F", NULL, "PDE 12" },
973 { "FU 0F", NULL, "ADC 23 Mux" },
974 { "ADC 23 Mux", "LINE2", "LINE2" },
975 { "ADC 23 Mux", "MIC2", "MIC2" },
976
977 { "HP", NULL, "PDE 40" },
978 { "HP", NULL, "FU 05" },
979 };
980
981 static const struct snd_soc_dapm_widget rt712_sdca_spk_dapm_widgets[] = {
982 SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
983
984 /* Digital Interface */
985 SND_SOC_DAPM_PGA("FU06", SND_SOC_NOPM, 0, 0, NULL, 0),
986
987 SND_SOC_DAPM_SUPPLY("PDE 23", SND_SOC_NOPM, 0, 0,
988 rt712_sdca_pde23_event,
989 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
990
991 /* Output */
992 SND_SOC_DAPM_SWITCH("OT23 L", SND_SOC_NOPM, 0, 0, &rt712_spk_l_dac),
993 SND_SOC_DAPM_SWITCH("OT23 R", SND_SOC_NOPM, 0, 0, &rt712_spk_r_dac),
994 SND_SOC_DAPM_OUTPUT("SPOL"),
995 SND_SOC_DAPM_OUTPUT("SPOR"),
996 };
997
998 static const struct snd_soc_dapm_route rt712_sdca_spk_dapm_routes[] = {
999 { "FU06", NULL, "DP3RX" },
1000 { "FU06", NULL, "PDE 23" },
1001 { "OT23 L", "Switch", "FU06" },
1002 { "OT23 R", "Switch", "FU06" },
1003 { "SPOL", NULL, "OT23 L" },
1004 { "SPOR", NULL, "OT23 R" },
1005 };
1006
rt712_sdca_parse_dt(struct rt712_sdca_priv * rt712,struct device * dev)1007 static int rt712_sdca_parse_dt(struct rt712_sdca_priv *rt712, struct device *dev)
1008 {
1009 device_property_read_u32(dev, "realtek,jd-src", &rt712->jd_src);
1010
1011 return 0;
1012 }
1013
rt712_sdca_probe(struct snd_soc_component * component)1014 static int rt712_sdca_probe(struct snd_soc_component *component)
1015 {
1016 struct snd_soc_dapm_context *dapm = snd_soc_component_to_dapm(component);
1017 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1018 int ret;
1019
1020 rt712_sdca_parse_dt(rt712, &rt712->slave->dev);
1021 rt712->component = component;
1022
1023 /* add SPK route */
1024 if (rt712->hw_id != RT712_DEV_ID_713) {
1025 snd_soc_add_component_controls(component,
1026 rt712_sdca_spk_controls, ARRAY_SIZE(rt712_sdca_spk_controls));
1027 snd_soc_dapm_new_controls(dapm,
1028 rt712_sdca_spk_dapm_widgets, ARRAY_SIZE(rt712_sdca_spk_dapm_widgets));
1029 snd_soc_dapm_add_routes(dapm,
1030 rt712_sdca_spk_dapm_routes, ARRAY_SIZE(rt712_sdca_spk_dapm_routes));
1031 }
1032
1033 if (!rt712->first_hw_init)
1034 return 0;
1035
1036 ret = pm_runtime_resume(component->dev);
1037 if (ret < 0 && ret != -EACCES)
1038 return ret;
1039
1040 return 0;
1041 }
1042
rt712_sdca_dmic_set_gain_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1043 static int rt712_sdca_dmic_set_gain_get(struct snd_kcontrol *kcontrol,
1044 struct snd_ctl_elem_value *ucontrol)
1045 {
1046 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
1047 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1048 struct rt712_dmic_kctrl_priv *p =
1049 (struct rt712_dmic_kctrl_priv *)kcontrol->private_value;
1050 unsigned int regvalue, ctl, i;
1051 unsigned int adc_vol_flag = 0;
1052 const unsigned int interval_offset = 0xc0;
1053
1054 if (strstr(ucontrol->id.name, "FU1E Capture Volume"))
1055 adc_vol_flag = 1;
1056
1057 /* check all channels */
1058 for (i = 0; i < p->count; i++) {
1059 regmap_read(rt712->mbq_regmap, p->reg_base + i, ®value);
1060
1061 if (!adc_vol_flag) /* boost gain */
1062 ctl = regvalue / 0x0a00;
1063 else /* ADC gain */
1064 ctl = p->max - (((0x1e00 - regvalue) & 0xffff) / interval_offset);
1065
1066 ucontrol->value.integer.value[i] = ctl;
1067 }
1068
1069 return 0;
1070 }
1071
rt712_sdca_dmic_set_gain_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1072 static int rt712_sdca_dmic_set_gain_put(struct snd_kcontrol *kcontrol,
1073 struct snd_ctl_elem_value *ucontrol)
1074 {
1075 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
1076 struct rt712_dmic_kctrl_priv *p =
1077 (struct rt712_dmic_kctrl_priv *)kcontrol->private_value;
1078 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1079 unsigned int gain_val[4];
1080 unsigned int i, adc_vol_flag = 0, changed = 0;
1081 unsigned int regvalue[4];
1082 const unsigned int interval_offset = 0xc0;
1083 int err;
1084
1085 if (strstr(ucontrol->id.name, "FU1E Capture Volume"))
1086 adc_vol_flag = 1;
1087
1088 /* check all channels */
1089 for (i = 0; i < p->count; i++) {
1090 regmap_read(rt712->mbq_regmap, p->reg_base + i, ®value[i]);
1091
1092 gain_val[i] = ucontrol->value.integer.value[i];
1093 if (gain_val[i] > p->max)
1094 gain_val[i] = p->max;
1095
1096 if (!adc_vol_flag) /* boost gain */
1097 gain_val[i] = gain_val[i] * 0x0a00;
1098 else { /* ADC gain */
1099 gain_val[i] = 0x1e00 - ((p->max - gain_val[i]) * interval_offset);
1100 gain_val[i] &= 0xffff;
1101 }
1102
1103 if (regvalue[i] != gain_val[i])
1104 changed = 1;
1105 }
1106
1107 if (!changed)
1108 return 0;
1109
1110 for (i = 0; i < p->count; i++) {
1111 err = regmap_write(rt712->mbq_regmap, p->reg_base + i, gain_val[i]);
1112 if (err < 0)
1113 dev_err(&rt712->slave->dev, "0x%08x can't be set\n", p->reg_base + i);
1114 }
1115
1116 return changed;
1117 }
1118
rt712_sdca_set_fu1e_capture_ctl(struct rt712_sdca_priv * rt712)1119 static int rt712_sdca_set_fu1e_capture_ctl(struct rt712_sdca_priv *rt712)
1120 {
1121 int err, i;
1122 unsigned int ch_mute;
1123
1124 for (i = 0; i < ARRAY_SIZE(rt712->fu1e_mixer_mute); i++) {
1125 ch_mute = (rt712->fu1e_dapm_mute || rt712->fu1e_mixer_mute[i]) ? 0x01 : 0x00;
1126 err = regmap_write(rt712->regmap,
1127 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_USER_FU1E,
1128 RT712_SDCA_CTL_FU_MUTE, CH_01) + i, ch_mute);
1129 if (err < 0)
1130 return err;
1131 }
1132
1133 return 0;
1134 }
1135
rt712_sdca_dmic_fu1e_capture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1136 static int rt712_sdca_dmic_fu1e_capture_get(struct snd_kcontrol *kcontrol,
1137 struct snd_ctl_elem_value *ucontrol)
1138 {
1139 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
1140 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1141 struct rt712_dmic_kctrl_priv *p =
1142 (struct rt712_dmic_kctrl_priv *)kcontrol->private_value;
1143 unsigned int i;
1144
1145 for (i = 0; i < p->count; i++)
1146 ucontrol->value.integer.value[i] = !rt712->fu1e_mixer_mute[i];
1147
1148 return 0;
1149 }
1150
rt712_sdca_dmic_fu1e_capture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1151 static int rt712_sdca_dmic_fu1e_capture_put(struct snd_kcontrol *kcontrol,
1152 struct snd_ctl_elem_value *ucontrol)
1153 {
1154 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
1155 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1156 struct rt712_dmic_kctrl_priv *p =
1157 (struct rt712_dmic_kctrl_priv *)kcontrol->private_value;
1158 int err, changed = 0, i;
1159
1160 for (i = 0; i < p->count; i++) {
1161 if (rt712->fu1e_mixer_mute[i] != !ucontrol->value.integer.value[i])
1162 changed = 1;
1163 rt712->fu1e_mixer_mute[i] = !ucontrol->value.integer.value[i];
1164 }
1165
1166 err = rt712_sdca_set_fu1e_capture_ctl(rt712);
1167 if (err < 0)
1168 return err;
1169
1170 return changed;
1171 }
1172
rt712_sdca_fu_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)1173 static int rt712_sdca_fu_info(struct snd_kcontrol *kcontrol,
1174 struct snd_ctl_elem_info *uinfo)
1175 {
1176 struct rt712_dmic_kctrl_priv *p =
1177 (struct rt712_dmic_kctrl_priv *)kcontrol->private_value;
1178
1179 if (p->max == 1)
1180 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
1181 else
1182 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
1183 uinfo->count = p->count;
1184 uinfo->value.integer.min = 0;
1185 uinfo->value.integer.max = p->max;
1186 return 0;
1187 }
1188
1189 #define RT712_SDCA_PR_VALUE(xreg_base, xcount, xmax, xinvert) \
1190 ((unsigned long)&(struct rt712_dmic_kctrl_priv) \
1191 {.reg_base = xreg_base, .count = xcount, .max = xmax, \
1192 .invert = xinvert})
1193
1194 #define RT712_SDCA_FU_CTRL(xname, reg_base, xmax, xinvert, xcount) \
1195 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
1196 .info = rt712_sdca_fu_info, \
1197 .get = rt712_sdca_dmic_fu1e_capture_get, \
1198 .put = rt712_sdca_dmic_fu1e_capture_put, \
1199 .private_value = RT712_SDCA_PR_VALUE(reg_base, xcount, xmax, xinvert)}
1200
1201 #define RT712_SDCA_EXT_TLV(xname, reg_base, xhandler_get,\
1202 xhandler_put, xcount, xmax, tlv_array) \
1203 { .iface = SNDRV_CTL_ELEM_IFACE_MIXER, .name = (xname), \
1204 .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ | \
1205 SNDRV_CTL_ELEM_ACCESS_READWRITE, \
1206 .tlv.p = (tlv_array), \
1207 .info = rt712_sdca_fu_info, \
1208 .get = xhandler_get, .put = xhandler_put, \
1209 .private_value = RT712_SDCA_PR_VALUE(reg_base, xcount, xmax, 0) }
1210
1211 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0);
1212 static const DECLARE_TLV_DB_SCALE(dmic_vol_tlv, 0, 1000, 0);
1213
1214 static const struct snd_kcontrol_new rt712_sdca_dmic_snd_controls[] = {
1215 RT712_SDCA_FU_CTRL("FU1E Capture Switch",
1216 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_USER_FU1E, RT712_SDCA_CTL_FU_MUTE, CH_01),
1217 1, 1, 4),
1218 RT712_SDCA_EXT_TLV("FU1E Capture Volume",
1219 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_USER_FU1E, RT712_SDCA_CTL_FU_VOLUME, CH_01),
1220 rt712_sdca_dmic_set_gain_get, rt712_sdca_dmic_set_gain_put, 4, 0x3f, in_vol_tlv),
1221 RT712_SDCA_EXT_TLV("FU15 Boost Volume",
1222 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_PLATFORM_FU15, RT712_SDCA_CTL_FU_CH_GAIN, CH_01),
1223 rt712_sdca_dmic_set_gain_get, rt712_sdca_dmic_set_gain_put, 4, 3, dmic_vol_tlv),
1224 };
1225
rt712_sdca_dmic_mux_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1226 static int rt712_sdca_dmic_mux_get(struct snd_kcontrol *kcontrol,
1227 struct snd_ctl_elem_value *ucontrol)
1228 {
1229 struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol);
1230 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1231 unsigned int val = 0, mask_sft;
1232
1233 if (strstr(ucontrol->id.name, "ADC 0A Mux"))
1234 mask_sft = 0;
1235 else if (strstr(ucontrol->id.name, "ADC 0B Mux"))
1236 mask_sft = 4;
1237 else
1238 return -EINVAL;
1239
1240 rt712_sdca_index_read(rt712, RT712_VENDOR_HDA_CTL,
1241 RT712_HDA_LEGACY_MUX_CTL0, &val);
1242
1243 ucontrol->value.enumerated.item[0] = (((val >> mask_sft) & 0xf) == 0x4) ? 0 : 1;
1244
1245 return 0;
1246 }
1247
rt712_sdca_dmic_mux_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1248 static int rt712_sdca_dmic_mux_put(struct snd_kcontrol *kcontrol,
1249 struct snd_ctl_elem_value *ucontrol)
1250 {
1251 struct snd_soc_component *component = snd_soc_dapm_kcontrol_to_component(kcontrol);
1252 struct snd_soc_dapm_context *dapm = snd_soc_dapm_kcontrol_to_dapm(kcontrol);
1253 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1254 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
1255 unsigned int *item = ucontrol->value.enumerated.item;
1256 unsigned int val, val2 = 0, change, mask_sft;
1257
1258 if (item[0] >= e->items)
1259 return -EINVAL;
1260
1261 if (strstr(ucontrol->id.name, "ADC 0A Mux"))
1262 mask_sft = 0;
1263 else if (strstr(ucontrol->id.name, "ADC 0B Mux"))
1264 mask_sft = 4;
1265 else
1266 return -EINVAL;
1267
1268 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
1269
1270 rt712_sdca_index_read(rt712, RT712_VENDOR_HDA_CTL,
1271 RT712_HDA_LEGACY_MUX_CTL0, &val2);
1272 val2 = ((0xf << mask_sft) & val2) >> mask_sft;
1273
1274 if (val == 0)
1275 val = 0x4;
1276 else if (val >= 1)
1277 val = 0xe;
1278
1279 if (val == val2)
1280 change = 0;
1281 else
1282 change = 1;
1283
1284 if (change)
1285 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
1286 RT712_HDA_LEGACY_MUX_CTL0, 0xf << mask_sft,
1287 val << mask_sft);
1288
1289 snd_soc_dapm_mux_update_power(dapm, kcontrol, item[0], e, NULL);
1290
1291 return change;
1292 }
1293
1294 static const char * const adc_dmic_mux_text[] = {
1295 "DMIC1",
1296 "DMIC2",
1297 };
1298
1299 static SOC_ENUM_SINGLE_DECL(
1300 rt712_adc0a_enum, SND_SOC_NOPM, 0, adc_dmic_mux_text);
1301
1302 static SOC_ENUM_SINGLE_DECL(
1303 rt712_adc0b_enum, SND_SOC_NOPM, 0, adc_dmic_mux_text);
1304
1305 static const struct snd_kcontrol_new rt712_sdca_dmic_adc0a_mux =
1306 SOC_DAPM_ENUM_EXT("ADC 0A Mux", rt712_adc0a_enum,
1307 rt712_sdca_dmic_mux_get, rt712_sdca_dmic_mux_put);
1308
1309 static const struct snd_kcontrol_new rt712_sdca_dmic_adc0b_mux =
1310 SOC_DAPM_ENUM_EXT("ADC 0B Mux", rt712_adc0b_enum,
1311 rt712_sdca_dmic_mux_get, rt712_sdca_dmic_mux_put);
1312
rt712_sdca_dmic_fu1e_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1313 static int rt712_sdca_dmic_fu1e_event(struct snd_soc_dapm_widget *w,
1314 struct snd_kcontrol *kcontrol, int event)
1315 {
1316 struct snd_soc_component *component =
1317 snd_soc_dapm_to_component(w->dapm);
1318 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1319
1320 switch (event) {
1321 case SND_SOC_DAPM_POST_PMU:
1322 rt712->fu1e_dapm_mute = false;
1323 rt712_sdca_set_fu1e_capture_ctl(rt712);
1324 break;
1325 case SND_SOC_DAPM_PRE_PMD:
1326 rt712->fu1e_dapm_mute = true;
1327 rt712_sdca_set_fu1e_capture_ctl(rt712);
1328 break;
1329 }
1330 return 0;
1331 }
1332
rt712_sdca_dmic_pde11_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1333 static int rt712_sdca_dmic_pde11_event(struct snd_soc_dapm_widget *w,
1334 struct snd_kcontrol *kcontrol, int event)
1335 {
1336 struct snd_soc_component *component =
1337 snd_soc_dapm_to_component(w->dapm);
1338 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1339 unsigned char ps0 = 0x0, ps3 = 0x3;
1340
1341 switch (event) {
1342 case SND_SOC_DAPM_POST_PMU:
1343 regmap_write(rt712->regmap,
1344 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_PDE11,
1345 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
1346 ps0);
1347 break;
1348 case SND_SOC_DAPM_PRE_PMD:
1349 regmap_write(rt712->regmap,
1350 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_PDE11,
1351 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
1352 ps3);
1353 break;
1354 }
1355 return 0;
1356 }
1357
1358 static const struct snd_soc_dapm_widget rt712_sdca_dmic_dapm_widgets[] = {
1359 SND_SOC_DAPM_INPUT("DMIC1"),
1360 SND_SOC_DAPM_INPUT("DMIC2"),
1361
1362 SND_SOC_DAPM_SUPPLY("PDE 11", SND_SOC_NOPM, 0, 0,
1363 rt712_sdca_dmic_pde11_event,
1364 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1365
1366 SND_SOC_DAPM_ADC_E("FU 1E", NULL, SND_SOC_NOPM, 0, 0,
1367 rt712_sdca_dmic_fu1e_event,
1368 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1369 SND_SOC_DAPM_MUX("ADC 0A Mux", SND_SOC_NOPM, 0, 0,
1370 &rt712_sdca_dmic_adc0a_mux),
1371 SND_SOC_DAPM_MUX("ADC 0B Mux", SND_SOC_NOPM, 0, 0,
1372 &rt712_sdca_dmic_adc0b_mux),
1373
1374 SND_SOC_DAPM_AIF_OUT("DP8TX", "DP8 Capture", 0, SND_SOC_NOPM, 0, 0),
1375 };
1376
1377 static const struct snd_soc_dapm_route rt712_sdca_dmic_audio_map[] = {
1378 {"DP8TX", NULL, "FU 1E"},
1379
1380 {"FU 1E", NULL, "PDE 11"},
1381 {"FU 1E", NULL, "ADC 0A Mux"},
1382 {"FU 1E", NULL, "ADC 0B Mux"},
1383 {"ADC 0A Mux", "DMIC1", "DMIC1"},
1384 {"ADC 0A Mux", "DMIC2", "DMIC2"},
1385 {"ADC 0B Mux", "DMIC1", "DMIC1"},
1386 {"ADC 0B Mux", "DMIC2", "DMIC2"},
1387 };
1388
rt712_sdca_dmic_probe(struct snd_soc_component * component)1389 static int rt712_sdca_dmic_probe(struct snd_soc_component *component)
1390 {
1391 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1392 int ret;
1393
1394 rt712->dmic_component = component;
1395
1396 if (!rt712->first_hw_init)
1397 return 0;
1398
1399 ret = pm_runtime_resume(component->dev);
1400 if (ret < 0 && ret != -EACCES)
1401 return ret;
1402
1403 return 0;
1404 }
1405
1406 static const struct snd_soc_component_driver soc_sdca_dev_rt712 = {
1407 .probe = rt712_sdca_probe,
1408 .controls = rt712_sdca_controls,
1409 .num_controls = ARRAY_SIZE(rt712_sdca_controls),
1410 .dapm_widgets = rt712_sdca_dapm_widgets,
1411 .num_dapm_widgets = ARRAY_SIZE(rt712_sdca_dapm_widgets),
1412 .dapm_routes = rt712_sdca_audio_map,
1413 .num_dapm_routes = ARRAY_SIZE(rt712_sdca_audio_map),
1414 .set_jack = rt712_sdca_set_jack_detect,
1415 .endianness = 1,
1416 };
1417
1418 static const struct snd_soc_component_driver soc_sdca_dev_rt712_dmic = {
1419 .probe = rt712_sdca_dmic_probe,
1420 .controls = rt712_sdca_dmic_snd_controls,
1421 .num_controls = ARRAY_SIZE(rt712_sdca_dmic_snd_controls),
1422 .dapm_widgets = rt712_sdca_dmic_dapm_widgets,
1423 .num_dapm_widgets = ARRAY_SIZE(rt712_sdca_dmic_dapm_widgets),
1424 .dapm_routes = rt712_sdca_dmic_audio_map,
1425 .num_dapm_routes = ARRAY_SIZE(rt712_sdca_dmic_audio_map),
1426 .endianness = 1,
1427 #ifdef CONFIG_DEBUG_FS
1428 .debugfs_prefix = "dmic",
1429 #endif
1430 };
1431
rt712_sdca_set_sdw_stream(struct snd_soc_dai * dai,void * sdw_stream,int direction)1432 static int rt712_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
1433 int direction)
1434 {
1435 snd_soc_dai_dma_data_set(dai, direction, sdw_stream);
1436
1437 return 0;
1438 }
1439
rt712_sdca_shutdown(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)1440 static void rt712_sdca_shutdown(struct snd_pcm_substream *substream,
1441 struct snd_soc_dai *dai)
1442 {
1443 snd_soc_dai_set_dma_data(dai, substream, NULL);
1444 }
1445
rt712_sdca_pcm_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)1446 static int rt712_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
1447 struct snd_pcm_hw_params *params,
1448 struct snd_soc_dai *dai)
1449 {
1450 struct snd_soc_component *component = dai->component;
1451 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1452 struct sdw_stream_config stream_config;
1453 struct sdw_port_config port_config;
1454 enum sdw_data_direction direction;
1455 struct sdw_stream_runtime *sdw_stream;
1456 int retval, port, num_channels;
1457 unsigned int sampling_rate;
1458
1459 dev_dbg(dai->dev, "%s %s id %d", __func__, dai->name, dai->id);
1460 sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
1461
1462 if (!sdw_stream)
1463 return -EINVAL;
1464
1465 if (!rt712->slave)
1466 return -EINVAL;
1467
1468 /* VA doesn't support AIF3 */
1469 if (dai->id == RT712_AIF3 && rt712->version_id == RT712_VA)
1470 return -EINVAL;
1471
1472 /* SoundWire specific configuration */
1473 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1474 direction = SDW_DATA_DIR_RX;
1475 if (dai->id == RT712_AIF1)
1476 port = 1;
1477 else if (dai->id == RT712_AIF2)
1478 port = 3;
1479 else
1480 return -EINVAL;
1481 } else {
1482 direction = SDW_DATA_DIR_TX;
1483 if (dai->id == RT712_AIF1)
1484 port = 4;
1485 else if (dai->id == RT712_AIF3)
1486 port = 8;
1487 else
1488 return -EINVAL;
1489 }
1490
1491 stream_config.frame_rate = params_rate(params);
1492 stream_config.ch_count = params_channels(params);
1493 stream_config.bps = snd_pcm_format_width(params_format(params));
1494 stream_config.direction = direction;
1495
1496 num_channels = params_channels(params);
1497 port_config.ch_mask = GENMASK(num_channels - 1, 0);
1498 port_config.num = port;
1499
1500 retval = sdw_stream_add_slave(rt712->slave, &stream_config,
1501 &port_config, 1, sdw_stream);
1502 if (retval) {
1503 dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
1504 return retval;
1505 }
1506
1507 if (params_channels(params) > 16) {
1508 dev_err(component->dev, "%s: Unsupported channels %d\n",
1509 __func__, params_channels(params));
1510 return -EINVAL;
1511 }
1512
1513 /* sampling rate configuration */
1514 switch (params_rate(params)) {
1515 case 44100:
1516 sampling_rate = RT712_SDCA_RATE_44100HZ;
1517 break;
1518 case 48000:
1519 sampling_rate = RT712_SDCA_RATE_48000HZ;
1520 break;
1521 case 96000:
1522 sampling_rate = RT712_SDCA_RATE_96000HZ;
1523 break;
1524 case 192000:
1525 sampling_rate = RT712_SDCA_RATE_192000HZ;
1526 break;
1527 default:
1528 dev_err(component->dev, "%s: Rate %d is not supported\n",
1529 __func__, params_rate(params));
1530 return -EINVAL;
1531 }
1532
1533 /* set sampling frequency */
1534 switch (dai->id) {
1535 case RT712_AIF1:
1536 regmap_write(rt712->regmap,
1537 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_CS01, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1538 sampling_rate);
1539 regmap_write(rt712->regmap,
1540 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_CS11, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1541 sampling_rate);
1542 break;
1543 case RT712_AIF2:
1544 regmap_write(rt712->regmap,
1545 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_CS31, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1546 sampling_rate);
1547 break;
1548 case RT712_AIF3:
1549 regmap_write(rt712->regmap,
1550 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_CS1F, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1551 sampling_rate);
1552 regmap_write(rt712->regmap,
1553 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_CS1C, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1554 sampling_rate);
1555 break;
1556 default:
1557 dev_err(component->dev, "%s: Wrong DAI id\n", __func__);
1558 return -EINVAL;
1559 }
1560
1561 return 0;
1562 }
1563
rt712_sdca_pcm_hw_free(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)1564 static int rt712_sdca_pcm_hw_free(struct snd_pcm_substream *substream,
1565 struct snd_soc_dai *dai)
1566 {
1567 struct snd_soc_component *component = dai->component;
1568 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(component);
1569 struct sdw_stream_runtime *sdw_stream =
1570 snd_soc_dai_get_dma_data(dai, substream);
1571
1572 if (!rt712->slave)
1573 return -EINVAL;
1574
1575 sdw_stream_remove_slave(rt712->slave, sdw_stream);
1576 return 0;
1577 }
1578
1579 #define RT712_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \
1580 SNDRV_PCM_RATE_192000)
1581 #define RT712_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
1582 SNDRV_PCM_FMTBIT_S24_LE)
1583
1584 static const struct snd_soc_dai_ops rt712_sdca_ops = {
1585 .hw_params = rt712_sdca_pcm_hw_params,
1586 .hw_free = rt712_sdca_pcm_hw_free,
1587 .set_stream = rt712_sdca_set_sdw_stream,
1588 .shutdown = rt712_sdca_shutdown,
1589 };
1590
1591 static struct snd_soc_dai_driver rt712_sdca_dai[] = {
1592 {
1593 .name = "rt712-sdca-aif1",
1594 .id = RT712_AIF1,
1595 .playback = {
1596 .stream_name = "DP1 Playback",
1597 .channels_min = 1,
1598 .channels_max = 2,
1599 .rates = RT712_STEREO_RATES,
1600 .formats = RT712_FORMATS,
1601 },
1602 .capture = {
1603 .stream_name = "DP4 Capture",
1604 .channels_min = 1,
1605 .channels_max = 2,
1606 .rates = RT712_STEREO_RATES,
1607 .formats = RT712_FORMATS,
1608 },
1609 .ops = &rt712_sdca_ops,
1610 },
1611 {
1612 .name = "rt712-sdca-aif2",
1613 .id = RT712_AIF2,
1614 .playback = {
1615 .stream_name = "DP3 Playback",
1616 .channels_min = 1,
1617 .channels_max = 2,
1618 .rates = RT712_STEREO_RATES,
1619 .formats = RT712_FORMATS,
1620 },
1621 .ops = &rt712_sdca_ops,
1622 }
1623 };
1624
1625 static struct snd_soc_dai_driver rt712_sdca_dmic_dai[] = {
1626 {
1627 .name = "rt712-sdca-aif3",
1628 .id = RT712_AIF3,
1629 .capture = {
1630 .stream_name = "DP8 Capture",
1631 .channels_min = 1,
1632 .channels_max = 4,
1633 .rates = RT712_STEREO_RATES,
1634 .formats = RT712_FORMATS,
1635 },
1636 .ops = &rt712_sdca_ops,
1637 }
1638 };
1639
rt712_sdca_init(struct device * dev,struct regmap * regmap,struct regmap * mbq_regmap,struct sdw_slave * slave)1640 int rt712_sdca_init(struct device *dev, struct regmap *regmap,
1641 struct regmap *mbq_regmap, struct sdw_slave *slave)
1642 {
1643 struct rt712_sdca_priv *rt712;
1644 int ret;
1645
1646 rt712 = devm_kzalloc(dev, sizeof(*rt712), GFP_KERNEL);
1647 if (!rt712)
1648 return -ENOMEM;
1649
1650 dev_set_drvdata(dev, rt712);
1651 rt712->slave = slave;
1652 rt712->regmap = regmap;
1653 rt712->mbq_regmap = mbq_regmap;
1654
1655 regcache_cache_only(rt712->regmap, true);
1656 regcache_cache_only(rt712->mbq_regmap, true);
1657
1658 mutex_init(&rt712->calibrate_mutex);
1659 mutex_init(&rt712->disable_irq_lock);
1660
1661 INIT_DELAYED_WORK(&rt712->jack_detect_work, rt712_sdca_jack_detect_handler);
1662 INIT_DELAYED_WORK(&rt712->jack_btn_check_work, rt712_sdca_btn_check_handler);
1663
1664 /*
1665 * Mark hw_init to false
1666 * HW init will be performed when device reports present
1667 */
1668 rt712->hw_init = false;
1669 rt712->first_hw_init = false;
1670 rt712->fu0f_dapm_mute = true;
1671 rt712->fu0f_mixer_l_mute = rt712->fu0f_mixer_r_mute = true;
1672 rt712->fu1e_dapm_mute = true;
1673 rt712->fu1e_mixer_mute[0] = rt712->fu1e_mixer_mute[1] =
1674 rt712->fu1e_mixer_mute[2] = rt712->fu1e_mixer_mute[3] = true;
1675 rt712->fu05_dapm_mute = true;
1676 rt712->fu05_mixer_l_mute = rt712->fu05_mixer_r_mute = false;
1677
1678 /* JD source uses JD1 in default */
1679 rt712->jd_src = RT712_JD1;
1680
1681 if (slave->id.part_id != RT712_PART_ID_713)
1682 ret = devm_snd_soc_register_component(dev,
1683 &soc_sdca_dev_rt712, rt712_sdca_dai, ARRAY_SIZE(rt712_sdca_dai));
1684 else
1685 ret = devm_snd_soc_register_component(dev,
1686 &soc_sdca_dev_rt712, rt712_sdca_dai, 1);
1687 if (ret < 0)
1688 return ret;
1689
1690 /* only add the dmic component if a SMART_MIC function is exposed in ACPI */
1691 if (sdca_device_quirk_match(slave, SDCA_QUIRKS_RT712_VB)) {
1692 ret = devm_snd_soc_register_component(dev,
1693 &soc_sdca_dev_rt712_dmic,
1694 rt712_sdca_dmic_dai,
1695 ARRAY_SIZE(rt712_sdca_dmic_dai));
1696 if (ret < 0)
1697 return ret;
1698 rt712->dmic_function_found = true;
1699 }
1700
1701 /* set autosuspend parameters */
1702 pm_runtime_set_autosuspend_delay(dev, 3000);
1703 pm_runtime_use_autosuspend(dev);
1704
1705 /* make sure the device does not suspend immediately */
1706 pm_runtime_mark_last_busy(dev);
1707
1708 pm_runtime_enable(dev);
1709
1710 /* important note: the device is NOT tagged as 'active' and will remain
1711 * 'suspended' until the hardware is enumerated/initialized. This is required
1712 * to make sure the ASoC framework use of pm_runtime_get_sync() does not silently
1713 * fail with -EACCESS because of race conditions between card creation and enumeration
1714 */
1715
1716 dev_dbg(dev, "%s\n", __func__);
1717
1718 return 0;
1719 }
1720
rt712_sdca_va_io_init(struct rt712_sdca_priv * rt712)1721 static void rt712_sdca_va_io_init(struct rt712_sdca_priv *rt712)
1722 {
1723 int ret = 0;
1724 unsigned int hibernation_flag;
1725 struct device *dev = &rt712->slave->dev;
1726
1727 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_ANALOG_BIAS_CTL3, 0xaa81);
1728 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_LDO2_3_CTL1, 0xa1e0);
1729 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_HP_DETECT_RLDET_CTL1, 0x0000);
1730 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_HP_DETECT_RLDET_CTL2, 0x0000);
1731 rt712_sdca_index_write(rt712, RT712_VENDOR_ANALOG_CTL, RT712_MISC_POWER_CTL7, 0x0000);
1732 regmap_write(rt712->regmap, RT712_RC_CAL, 0x23);
1733
1734 /* calibration */
1735 rt712_sdca_index_read(rt712, RT712_VENDOR_REG, RT712_SW_CONFIG1, &hibernation_flag);
1736 if (!hibernation_flag) {
1737 ret = rt712_sdca_calibration(rt712);
1738 if (ret < 0)
1739 dev_err(dev, "%s, calibration failed!\n", __func__);
1740 }
1741
1742 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
1743 RT712_MIXER_CTL1, 0x3000, 0x0000);
1744 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL,
1745 RT712_ADC0A_08_PDE_FLOAT_CTL, 0x1112);
1746 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL,
1747 RT712_MIC2_LINE2_PDE_FLOAT_CTL, 0x3412);
1748 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL,
1749 RT712_DAC03_HP_PDE_FLOAT_CTL, 0x4040);
1750
1751 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
1752 RT712_HDA_LEGACY_GPIO_WAKE_EN_CTL, 0x0001, 0x0000);
1753 regmap_write(rt712->regmap, 0x2f50, 0x00);
1754 regmap_write(rt712->regmap, 0x2f54, 0x00);
1755 regmap_write(rt712->regmap,
1756 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_IT09, RT712_SDCA_CTL_VENDOR_DEF, 0), 0x01);
1757
1758 /* add SPK settings */
1759 if (rt712->hw_id != RT712_DEV_ID_713) {
1760 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_AMP_PDE_FLOAT_CTL, 0x2323);
1761 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_EAPD_CTL, 0x0002);
1762 regmap_write(rt712->regmap,
1763 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_OT23, RT712_SDCA_CTL_VENDOR_DEF, 0), 0x04);
1764 }
1765 }
1766
rt712_sdca_vb_io_init(struct rt712_sdca_priv * rt712)1767 static void rt712_sdca_vb_io_init(struct rt712_sdca_priv *rt712)
1768 {
1769 int ret = 0;
1770 unsigned int jack_func_status, mic_func_status, amp_func_status;
1771 struct device *dev = &rt712->slave->dev;
1772
1773 regmap_read(rt712->regmap,
1774 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0), &jack_func_status);
1775 regmap_read(rt712->regmap,
1776 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0), &mic_func_status);
1777 regmap_read(rt712->regmap,
1778 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0), &_func_status);
1779 dev_dbg(dev, "%s jack/mic/amp func_status=0x%x, 0x%x, 0x%x\n",
1780 __func__, jack_func_status, mic_func_status, amp_func_status);
1781
1782 /* DMIC */
1783 if ((mic_func_status & FUNCTION_NEEDS_INITIALIZATION) || (!rt712->first_hw_init)) {
1784 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_DMIC2_FU_IT_FLOAT_CTL, 0x1526);
1785 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_DMIC2_FU_CH12_FLOAT_CTL, 0x0304);
1786 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_ADC0A_CS_ADC0B_FU_FLOAT_CTL, 0x1f1e);
1787 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_ADC0B_FU_CH12_FLOAT_CTL, 0x0304);
1788 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_HDA_LEGACY_CONFIG_CTL0, 0x8010);
1789 regmap_write(rt712->regmap,
1790 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT_IT11, RT712_SDCA_CTL_VENDOR_DEF, 0), 0x01);
1791 rt712_sdca_index_write(rt712, RT712_ULTRA_SOUND_DET, RT712_ULTRA_SOUND_DETECTOR6, 0x3200);
1792 regmap_write(rt712->regmap, RT712_RC_CAL, 0x23);
1793
1794 /* clear flag */
1795 regmap_write(rt712->regmap,
1796 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0),
1797 FUNCTION_NEEDS_INITIALIZATION);
1798 }
1799
1800 /* Jack */
1801 if ((jack_func_status & FUNCTION_NEEDS_INITIALIZATION) || (!rt712->first_hw_init)) {
1802 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_SEL_VEE2_HP_CTL1, 0x042a);
1803 rt712_sdca_index_write(rt712, RT712_CHARGE_PUMP, RT712_HP_DET_CTL3, 0x1fff);
1804 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_IO_CTL, 0xec67);
1805 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_ANALOG_BIAS_CTL3, 0xaa81);
1806 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_LDO2_3_CTL1, 0xa1e0);
1807 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_HP_DETECT_RLDET_CTL1, 0x0000);
1808 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_HP_DETECT_RLDET_CTL2, 0x0000);
1809 regmap_write(rt712->regmap, RT712_RC_CAL, 0x23);
1810 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_JD_CTL1, 0x2802);
1811 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_CLASSD_AMP_CTL6, 0xf215);
1812
1813 /* calibration */
1814 ret = rt712_sdca_calibration(rt712);
1815 if (ret < 0)
1816 dev_err(dev, "%s, calibration failed!\n", __func__);
1817
1818 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL, RT712_MIXER_CTL1, 0x3000, 0x0000);
1819 regmap_write(rt712->regmap,
1820 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_IT09, RT712_SDCA_CTL_VENDOR_DEF, 0), 0x01);
1821 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_MISC_CTL_FOR_UAJ, 0x0003);
1822
1823 /* clear flag */
1824 regmap_write(rt712->regmap,
1825 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0),
1826 FUNCTION_NEEDS_INITIALIZATION);
1827 }
1828
1829 /* SPK */
1830 if ((amp_func_status & FUNCTION_NEEDS_INITIALIZATION) || (!rt712->first_hw_init)) {
1831 if (rt712->hw_id != RT712_DEV_ID_713) {
1832 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_IO_CTL, 0xec63);
1833 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_CLASSD_AMP_CTL1, 0xfff5);
1834 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_EAPD_CTL, 0x0002);
1835 regmap_write(rt712->regmap,
1836 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_OT23, RT712_SDCA_CTL_VENDOR_DEF, 0), 0x04);
1837 }
1838 /* clear flag */
1839 regmap_write(rt712->regmap,
1840 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT0, RT712_SDCA_CTL_FUNC_STATUS, 0),
1841 FUNCTION_NEEDS_INITIALIZATION);
1842 }
1843 }
1844
rt712_sdca_reset(struct rt712_sdca_priv * rt712)1845 static void rt712_sdca_reset(struct rt712_sdca_priv *rt712)
1846 {
1847 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_REG,
1848 RT712_PARA_VERB_CTL, RT712_HIDDEN_REG_SW_RESET,
1849 RT712_HIDDEN_REG_SW_RESET);
1850 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
1851 RT712_HDA_LEGACY_RESET_CTL, 0x1, 0x1);
1852 }
1853
rt712_sdca_io_init(struct device * dev,struct sdw_slave * slave)1854 int rt712_sdca_io_init(struct device *dev, struct sdw_slave *slave)
1855 {
1856 struct rt712_sdca_priv *rt712 = dev_get_drvdata(dev);
1857 unsigned int val;
1858 struct sdw_slave_prop *prop = &slave->prop;
1859
1860 rt712->disable_irq = false;
1861
1862 if (rt712->hw_init)
1863 return 0;
1864
1865 regcache_cache_only(rt712->regmap, false);
1866 regcache_cache_only(rt712->mbq_regmap, false);
1867 if (rt712->first_hw_init) {
1868 regcache_cache_bypass(rt712->regmap, true);
1869 regcache_cache_bypass(rt712->mbq_regmap, true);
1870 } else {
1871 /*
1872 * PM runtime status is marked as 'active' only when a Slave reports as Attached
1873 */
1874
1875 /* update count of parent 'active' children */
1876 pm_runtime_set_active(&slave->dev);
1877 }
1878
1879 pm_runtime_get_noresume(&slave->dev);
1880
1881 rt712_sdca_reset(rt712);
1882
1883 rt712_sdca_index_read(rt712, RT712_VENDOR_REG, RT712_JD_PRODUCT_NUM, &val);
1884 rt712->hw_id = (val & 0xf000) >> 12;
1885 rt712->version_id = (val & 0x0f00) >> 8;
1886 dev_dbg(&slave->dev, "%s hw_id=0x%x, version_id=0x%x\n", __func__, rt712->hw_id, rt712->version_id);
1887
1888 if (rt712->version_id == RT712_VA) {
1889 if (rt712->dmic_function_found) {
1890 dev_err(&slave->dev, "%s RT712 VA detected but SMART_MIC function exposed in ACPI\n",
1891 __func__);
1892 goto suspend;
1893 }
1894
1895 rt712_sdca_va_io_init(rt712);
1896 } else {
1897 if (!rt712->dmic_function_found)
1898 dev_warn(&slave->dev, "%s RT712 VB detected but no SMART_MIC function exposed in ACPI\n",
1899 __func__);
1900
1901 /* multilanes and DMIC are supported by rt712vb */
1902 prop->lane_control_support = true;
1903 rt712_sdca_vb_io_init(rt712);
1904 }
1905
1906 /*
1907 * if set_jack callback occurred early than io_init,
1908 * we set up the jack detection function now
1909 */
1910 if (rt712->hs_jack)
1911 rt712_sdca_jack_init(rt712);
1912
1913 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_SW_CONFIG1, 0x0001);
1914
1915 if (rt712->first_hw_init) {
1916 regcache_cache_bypass(rt712->regmap, false);
1917 regcache_mark_dirty(rt712->regmap);
1918 regcache_cache_bypass(rt712->mbq_regmap, false);
1919 regcache_mark_dirty(rt712->mbq_regmap);
1920 } else
1921 rt712->first_hw_init = true;
1922
1923 /* Mark Slave initialization complete */
1924 rt712->hw_init = true;
1925
1926 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
1927
1928 suspend:
1929 pm_runtime_put_autosuspend(&slave->dev);
1930
1931 return 0;
1932 }
1933
1934 MODULE_DESCRIPTION("ASoC RT712 SDCA SDW driver");
1935 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
1936 MODULE_LICENSE("GPL");
1937