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