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 <linux/soundwire/sdw_registers.h>
22#include <linux/slab.h>
23#include <sound/soc-dapm.h>
24#include <sound/tlv.h>
25#include "rt712-sdca.h"
26
27static int rt712_sdca_index_write(struct rt712_sdca_priv *rt712,
28 unsigned int nid, unsigned int reg, unsigned int value)
29{
30 int ret;
31 struct regmap *regmap = rt712->mbq_regmap;
32 unsigned int addr = (nid << 20) | reg;
33
34 ret = regmap_write(map: regmap, reg: addr, val: value);
35 if (ret < 0)
36 dev_err(&rt712->slave->dev,
37 "%s: Failed to set private value: %06x <= %04x ret=%d\n",
38 __func__, addr, value, ret);
39
40 return ret;
41}
42
43static int rt712_sdca_index_read(struct rt712_sdca_priv *rt712,
44 unsigned int nid, unsigned int reg, unsigned int *value)
45{
46 int ret;
47 struct regmap *regmap = rt712->mbq_regmap;
48 unsigned int addr = (nid << 20) | reg;
49
50 ret = regmap_read(map: regmap, reg: addr, val: value);
51 if (ret < 0)
52 dev_err(&rt712->slave->dev,
53 "%s: Failed to get private value: %06x => %04x ret=%d\n",
54 __func__, addr, *value, ret);
55
56 return ret;
57}
58
59static int rt712_sdca_index_update_bits(struct rt712_sdca_priv *rt712,
60 unsigned int nid, unsigned int reg, unsigned int mask, unsigned int val)
61{
62 unsigned int tmp;
63 int ret;
64
65 ret = rt712_sdca_index_read(rt712, nid, reg, value: &tmp);
66 if (ret < 0)
67 return ret;
68
69 set_mask_bits(&tmp, mask, val);
70 return rt712_sdca_index_write(rt712, nid, reg, value: tmp);
71}
72
73static int rt712_sdca_calibration(struct rt712_sdca_priv *rt712)
74{
75 unsigned int val, loop_rc = 0, loop_dc = 0;
76 struct device *dev;
77 struct regmap *regmap = rt712->regmap;
78 int chk_cnt = 100;
79 int ret = 0;
80
81 mutex_lock(&rt712->calibrate_mutex);
82 dev = regmap_get_device(map: regmap);
83
84 /* Set HP-JD source from JD1 */
85 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_CC_DET1, value: 0x043a);
86
87 /* FSM switch to calibration manual mode */
88 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_FSM_CTL, value: 0x4100);
89
90 /* Calibration setting */
91 rt712_sdca_index_write(rt712, RT712_VENDOR_CALI, RT712_DAC_DC_CALI_CTL1, value: 0x7883);
92
93 /* W1C Trigger DC calibration (HP & Class-D) */
94 rt712_sdca_index_write(rt712, RT712_VENDOR_CALI, RT712_DAC_DC_CALI_CTL1, value: 0xf893);
95
96 /* wait for calibration process */
97 rt712_sdca_index_read(rt712, RT712_VENDOR_CALI,
98 RT712_DAC_DC_CALI_CTL1, value: &val);
99
100 for (loop_dc = 0; loop_dc < chk_cnt &&
101 (val & RT712_DAC_DC_CALI_TRIGGER); loop_dc++) {
102 usleep_range(min: 10000, max: 11000);
103 ret = rt712_sdca_index_read(rt712, RT712_VENDOR_CALI,
104 RT712_DAC_DC_CALI_CTL1, value: &val);
105 if (ret < 0)
106 goto _cali_fail_;
107 }
108 if (loop_dc == chk_cnt)
109 dev_err(dev, "%s, calibration time-out!\n", __func__);
110
111 if (loop_dc == chk_cnt || loop_rc == chk_cnt)
112 ret = -ETIMEDOUT;
113
114_cali_fail_:
115 /* Enable Rldet in FSM */
116 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_FSM_CTL, value: 0x4500);
117
118 /* Sensing Lch+Rch */
119 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_IMS_DIGITAL_CTL1, value: 0x040f);
120
121 /* Sine gen path control */
122 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_IMS_DIGITAL_CTL5, value: 0x0000);
123
124 /* Release HP-JD, EN_CBJ_TIE_GL/R open, en_osw gating auto done bit */
125 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_DIGITAL_MISC_CTRL4, value: 0x0010);
126
127 mutex_unlock(lock: &rt712->calibrate_mutex);
128 dev_dbg(dev, "%s calibration complete, ret=%d\n", __func__, ret);
129 return ret;
130}
131
132static unsigned int rt712_sdca_button_detect(struct rt712_sdca_priv *rt712)
133{
134 unsigned int btn_type = 0, offset, idx, val, owner;
135 int ret;
136 unsigned char buf[3];
137
138 /* get current UMP message owner */
139 ret = regmap_read(map: rt712->regmap,
140 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_CURRENT_OWNER, 0),
141 val: &owner);
142 if (ret < 0)
143 return 0;
144
145 /* if owner is device then there is no button event from device */
146 if (owner == 1)
147 return 0;
148
149 /* read UMP message offset */
150 ret = regmap_read(map: rt712->regmap,
151 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0),
152 val: &offset);
153 if (ret < 0)
154 goto _end_btn_det_;
155
156 for (idx = 0; idx < sizeof(buf); idx++) {
157 ret = regmap_read(map: rt712->regmap,
158 RT712_BUF_ADDR_HID1 + offset + idx, val: &val);
159 if (ret < 0)
160 goto _end_btn_det_;
161 buf[idx] = val & 0xff;
162 }
163
164 if (buf[0] == 0x11) {
165 switch (buf[1] & 0xf0) {
166 case 0x10:
167 btn_type |= SND_JACK_BTN_2;
168 break;
169 case 0x20:
170 btn_type |= SND_JACK_BTN_3;
171 break;
172 case 0x40:
173 btn_type |= SND_JACK_BTN_0;
174 break;
175 case 0x80:
176 btn_type |= SND_JACK_BTN_1;
177 break;
178 }
179 switch (buf[2]) {
180 case 0x01:
181 case 0x10:
182 btn_type |= SND_JACK_BTN_2;
183 break;
184 case 0x02:
185 case 0x20:
186 btn_type |= SND_JACK_BTN_3;
187 break;
188 case 0x04:
189 case 0x40:
190 btn_type |= SND_JACK_BTN_0;
191 break;
192 case 0x08:
193 case 0x80:
194 btn_type |= SND_JACK_BTN_1;
195 break;
196 }
197 }
198
199_end_btn_det_:
200 /* Host is owner, so set back to device */
201 if (owner == 0)
202 /* set owner to device */
203 regmap_write(map: rt712->regmap,
204 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01,
205 RT712_SDCA_CTL_HIDTX_SET_OWNER_TO_DEVICE, 0), val: 0x01);
206
207 return btn_type;
208}
209
210static int rt712_sdca_headset_detect(struct rt712_sdca_priv *rt712)
211{
212 unsigned int det_mode;
213 int ret;
214
215 /* get detected_mode */
216 ret = regmap_read(map: rt712->regmap,
217 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_DETECTED_MODE, 0),
218 val: &det_mode);
219 if (ret < 0)
220 goto io_error;
221
222 switch (det_mode) {
223 case 0x00:
224 rt712->jack_type = 0;
225 break;
226 case 0x03:
227 rt712->jack_type = SND_JACK_HEADPHONE;
228 break;
229 case 0x05:
230 rt712->jack_type = SND_JACK_HEADSET;
231 break;
232 }
233
234 /* write selected_mode */
235 if (det_mode) {
236 ret = regmap_write(map: rt712->regmap,
237 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_SELECTED_MODE, 0),
238 val: det_mode);
239 if (ret < 0)
240 goto io_error;
241 }
242
243 dev_dbg(&rt712->slave->dev,
244 "%s, detected_mode=0x%x\n", __func__, det_mode);
245
246 return 0;
247
248io_error:
249 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
250 return ret;
251}
252
253static void rt712_sdca_jack_detect_handler(struct work_struct *work)
254{
255 struct rt712_sdca_priv *rt712 =
256 container_of(work, struct rt712_sdca_priv, jack_detect_work.work);
257 int btn_type = 0, ret;
258
259 if (!rt712->hs_jack)
260 return;
261
262 if (!rt712->component->card || !rt712->component->card->instantiated)
263 return;
264
265 /* SDW_SCP_SDCA_INT_SDCA_0 is used for jack detection */
266 if (rt712->scp_sdca_stat1 & SDW_SCP_SDCA_INT_SDCA_0) {
267 ret = rt712_sdca_headset_detect(rt712);
268 if (ret < 0)
269 return;
270 }
271
272 /* SDW_SCP_SDCA_INT_SDCA_8 is used for button detection */
273 if (rt712->scp_sdca_stat2 & SDW_SCP_SDCA_INT_SDCA_8)
274 btn_type = rt712_sdca_button_detect(rt712);
275
276 if (rt712->jack_type == 0)
277 btn_type = 0;
278
279 dev_dbg(&rt712->slave->dev,
280 "in %s, jack_type=0x%x\n", __func__, rt712->jack_type);
281 dev_dbg(&rt712->slave->dev,
282 "in %s, btn_type=0x%x\n", __func__, btn_type);
283 dev_dbg(&rt712->slave->dev,
284 "in %s, scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__,
285 rt712->scp_sdca_stat1, rt712->scp_sdca_stat2);
286
287 snd_soc_jack_report(jack: rt712->hs_jack, status: rt712->jack_type | btn_type,
288 mask: SND_JACK_HEADSET |
289 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
290 SND_JACK_BTN_2 | SND_JACK_BTN_3);
291
292 if (btn_type) {
293 /* button released */
294 snd_soc_jack_report(jack: rt712->hs_jack, status: rt712->jack_type,
295 mask: SND_JACK_HEADSET |
296 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
297 SND_JACK_BTN_2 | SND_JACK_BTN_3);
298
299 mod_delayed_work(wq: system_power_efficient_wq,
300 dwork: &rt712->jack_btn_check_work, delay: msecs_to_jiffies(m: 200));
301 }
302}
303
304static void rt712_sdca_btn_check_handler(struct work_struct *work)
305{
306 struct rt712_sdca_priv *rt712 =
307 container_of(work, struct rt712_sdca_priv, jack_btn_check_work.work);
308 int btn_type = 0, ret, idx;
309 unsigned int det_mode, offset, val;
310 unsigned char buf[3];
311
312 ret = regmap_read(map: rt712->regmap,
313 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_GE49, RT712_SDCA_CTL_DETECTED_MODE, 0),
314 val: &det_mode);
315 if (ret < 0)
316 goto io_error;
317
318 /* pin attached */
319 if (det_mode) {
320 /* read UMP message offset */
321 ret = regmap_read(map: rt712->regmap,
322 SDW_SDCA_CTL(FUNC_NUM_HID, RT712_SDCA_ENT_HID01, RT712_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0),
323 val: &offset);
324 if (ret < 0)
325 goto io_error;
326
327 for (idx = 0; idx < sizeof(buf); idx++) {
328 ret = regmap_read(map: rt712->regmap,
329 RT712_BUF_ADDR_HID1 + offset + idx, val: &val);
330 if (ret < 0)
331 goto io_error;
332 buf[idx] = val & 0xff;
333 }
334
335 if (buf[0] == 0x11) {
336 switch (buf[1] & 0xf0) {
337 case 0x10:
338 btn_type |= SND_JACK_BTN_2;
339 break;
340 case 0x20:
341 btn_type |= SND_JACK_BTN_3;
342 break;
343 case 0x40:
344 btn_type |= SND_JACK_BTN_0;
345 break;
346 case 0x80:
347 btn_type |= SND_JACK_BTN_1;
348 break;
349 }
350 switch (buf[2]) {
351 case 0x01:
352 case 0x10:
353 btn_type |= SND_JACK_BTN_2;
354 break;
355 case 0x02:
356 case 0x20:
357 btn_type |= SND_JACK_BTN_3;
358 break;
359 case 0x04:
360 case 0x40:
361 btn_type |= SND_JACK_BTN_0;
362 break;
363 case 0x08:
364 case 0x80:
365 btn_type |= SND_JACK_BTN_1;
366 break;
367 }
368 }
369 } else {
370 rt712->jack_type = 0;
371 }
372
373 dev_dbg(&rt712->slave->dev, "%s, btn_type=0x%x\n", __func__, btn_type);
374 snd_soc_jack_report(jack: rt712->hs_jack, status: rt712->jack_type | btn_type,
375 mask: SND_JACK_HEADSET |
376 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
377 SND_JACK_BTN_2 | SND_JACK_BTN_3);
378
379 if (btn_type) {
380 /* button released */
381 snd_soc_jack_report(jack: rt712->hs_jack, status: rt712->jack_type,
382 mask: SND_JACK_HEADSET |
383 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
384 SND_JACK_BTN_2 | SND_JACK_BTN_3);
385
386 mod_delayed_work(wq: system_power_efficient_wq,
387 dwork: &rt712->jack_btn_check_work, delay: msecs_to_jiffies(m: 200));
388 }
389
390 return;
391
392io_error:
393 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
394}
395
396static void rt712_sdca_jack_init(struct rt712_sdca_priv *rt712)
397{
398 mutex_lock(&rt712->calibrate_mutex);
399
400 if (rt712->hs_jack) {
401 /* Enable HID1 event & set button RTC mode */
402 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL,
403 RT712_UMP_HID_CTL5, value: 0xfff0);
404 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
405 RT712_UMP_HID_CTL0, mask: 0x1100, val: 0x1100);
406 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
407 RT712_UMP_HID_CTL7, mask: 0xf000, val: 0x0000);
408
409 /* detected_mode_change_event_en & hid1_push_button_event_en */
410 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
411 RT712_GE_RELATED_CTL1, mask: 0x0c00, val: 0x0c00);
412 /* ge_inbox_en */
413 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
414 RT712_GE_RELATED_CTL2, mask: 0x0020, val: 0x0000);
415
416 switch (rt712->jd_src) {
417 case RT712_JD1:
418 /* Set HP-JD source from JD1 */
419 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_CC_DET1, value: 0x043a);
420 break;
421 default:
422 dev_warn(rt712->component->dev, "Wrong JD source\n");
423 break;
424 }
425
426 /* set SCP_SDCA_IntMask1[0]=1 */
427 sdw_write_no_pm(slave: rt712->slave, SDW_SCP_SDCA_INTMASK1, SDW_SCP_SDCA_INTMASK_SDCA_0);
428 /* set SCP_SDCA_IntMask2[0]=1 */
429 sdw_write_no_pm(slave: rt712->slave, SDW_SCP_SDCA_INTMASK2, SDW_SCP_SDCA_INTMASK_SDCA_8);
430 dev_dbg(&rt712->slave->dev, "in %s enable\n", __func__);
431
432 /* trigger GE interrupt */
433 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
434 RT712_GE_RELATED_CTL1, mask: 0x0080, val: 0x0080);
435 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
436 RT712_GE_RELATED_CTL1, mask: 0x0080, val: 0x0000);
437 } else {
438 /* disable HID1 & detected_mode_change event */
439 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
440 RT712_GE_RELATED_CTL1, mask: 0x0c00, val: 0x0000);
441
442 dev_dbg(&rt712->slave->dev, "in %s disable\n", __func__);
443 }
444
445 mutex_unlock(lock: &rt712->calibrate_mutex);
446}
447
448static int rt712_sdca_set_jack_detect(struct snd_soc_component *component,
449 struct snd_soc_jack *hs_jack, void *data)
450{
451 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
452 int ret;
453
454 rt712->hs_jack = hs_jack;
455
456 if (!rt712->first_hw_init)
457 return 0;
458
459 ret = pm_runtime_resume_and_get(dev: component->dev);
460 if (ret < 0) {
461 if (ret != -EACCES) {
462 dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret);
463 return ret;
464 }
465
466 /* pm_runtime not enabled yet */
467 dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__);
468 return 0;
469 }
470
471 rt712_sdca_jack_init(rt712);
472
473 pm_runtime_mark_last_busy(dev: component->dev);
474 pm_runtime_put_autosuspend(dev: component->dev);
475
476 return 0;
477}
478
479/* For SDCA control DAC/ADC Gain */
480static int rt712_sdca_set_gain_put(struct snd_kcontrol *kcontrol,
481 struct snd_ctl_elem_value *ucontrol)
482{
483 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
484 struct soc_mixer_control *mc =
485 (struct soc_mixer_control *)kcontrol->private_value;
486 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
487 unsigned int read_l, read_r, gain_l_val, gain_r_val;
488 unsigned int adc_vol_flag = 0;
489 unsigned int lvalue, rvalue;
490 const unsigned int interval_offset = 0xc0;
491 const unsigned int tendB = 0xa00;
492
493 if (strstr(ucontrol->id.name, "FU0F Capture Volume"))
494 adc_vol_flag = 1;
495
496 regmap_read(map: rt712->mbq_regmap, reg: mc->reg, val: &lvalue);
497 regmap_read(map: rt712->mbq_regmap, reg: mc->rreg, val: &rvalue);
498
499 /* L Channel */
500 gain_l_val = ucontrol->value.integer.value[0];
501 if (gain_l_val > mc->max)
502 gain_l_val = mc->max;
503
504 if (mc->shift == 8) /* boost gain */
505 gain_l_val = gain_l_val * tendB;
506 else {
507 /* ADC/DAC gain */
508 if (adc_vol_flag)
509 gain_l_val = 0x1e00 - ((mc->max - gain_l_val) * interval_offset);
510 else
511 gain_l_val = 0 - ((mc->max - gain_l_val) * interval_offset);
512 gain_l_val &= 0xffff;
513 }
514
515 /* R Channel */
516 gain_r_val = ucontrol->value.integer.value[1];
517 if (gain_r_val > mc->max)
518 gain_r_val = mc->max;
519
520 if (mc->shift == 8) /* boost gain */
521 gain_r_val = gain_r_val * tendB;
522 else {
523 /* ADC/DAC gain */
524 if (adc_vol_flag)
525 gain_r_val = 0x1e00 - ((mc->max - gain_r_val) * interval_offset);
526 else
527 gain_r_val = 0 - ((mc->max - gain_r_val) * interval_offset);
528 gain_r_val &= 0xffff;
529 }
530
531 if (lvalue == gain_l_val && rvalue == gain_r_val)
532 return 0;
533
534 /* Lch*/
535 regmap_write(map: rt712->mbq_regmap, reg: mc->reg, val: gain_l_val);
536 /* Rch */
537 regmap_write(map: rt712->mbq_regmap, reg: mc->rreg, val: gain_r_val);
538
539 regmap_read(map: rt712->mbq_regmap, reg: mc->reg, val: &read_l);
540 regmap_read(map: rt712->mbq_regmap, reg: mc->rreg, val: &read_r);
541 if (read_r == gain_r_val && read_l == gain_l_val)
542 return 1;
543
544 return -EIO;
545}
546
547static int rt712_sdca_set_gain_get(struct snd_kcontrol *kcontrol,
548 struct snd_ctl_elem_value *ucontrol)
549{
550 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
551 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
552 struct soc_mixer_control *mc =
553 (struct soc_mixer_control *)kcontrol->private_value;
554 unsigned int read_l, read_r, ctl_l = 0, ctl_r = 0;
555 unsigned int adc_vol_flag = 0;
556 const unsigned int interval_offset = 0xc0;
557 const unsigned int tendB = 0xa00;
558
559 if (strstr(ucontrol->id.name, "FU0F Capture Volume"))
560 adc_vol_flag = 1;
561
562 regmap_read(map: rt712->mbq_regmap, reg: mc->reg, val: &read_l);
563 regmap_read(map: rt712->mbq_regmap, reg: mc->rreg, val: &read_r);
564
565 if (mc->shift == 8) /* boost gain */
566 ctl_l = read_l / tendB;
567 else {
568 if (adc_vol_flag)
569 ctl_l = mc->max - (((0x1e00 - read_l) & 0xffff) / interval_offset);
570 else
571 ctl_l = mc->max - (((0 - read_l) & 0xffff) / interval_offset);
572 }
573
574 if (read_l != read_r) {
575 if (mc->shift == 8) /* boost gain */
576 ctl_r = read_r / tendB;
577 else { /* ADC/DAC gain */
578 if (adc_vol_flag)
579 ctl_r = mc->max - (((0x1e00 - read_r) & 0xffff) / interval_offset);
580 else
581 ctl_r = mc->max - (((0 - read_r) & 0xffff) / interval_offset);
582 }
583 } else
584 ctl_r = ctl_l;
585
586 ucontrol->value.integer.value[0] = ctl_l;
587 ucontrol->value.integer.value[1] = ctl_r;
588
589 return 0;
590}
591
592static int rt712_sdca_set_fu0f_capture_ctl(struct rt712_sdca_priv *rt712)
593{
594 int err;
595 unsigned int ch_l, ch_r;
596
597 ch_l = (rt712->fu0f_dapm_mute || rt712->fu0f_mixer_l_mute) ? 0x01 : 0x00;
598 ch_r = (rt712->fu0f_dapm_mute || rt712->fu0f_mixer_r_mute) ? 0x01 : 0x00;
599
600 err = regmap_write(map: rt712->regmap,
601 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F,
602 RT712_SDCA_CTL_FU_MUTE, CH_L), val: ch_l);
603 if (err < 0)
604 return err;
605
606 err = regmap_write(map: rt712->regmap,
607 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F,
608 RT712_SDCA_CTL_FU_MUTE, CH_R), val: ch_r);
609 if (err < 0)
610 return err;
611
612 return 0;
613}
614
615static int rt712_sdca_fu0f_capture_get(struct snd_kcontrol *kcontrol,
616 struct snd_ctl_elem_value *ucontrol)
617{
618 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
619 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
620
621 ucontrol->value.integer.value[0] = !rt712->fu0f_mixer_l_mute;
622 ucontrol->value.integer.value[1] = !rt712->fu0f_mixer_r_mute;
623 return 0;
624}
625
626static int rt712_sdca_fu0f_capture_put(struct snd_kcontrol *kcontrol,
627 struct snd_ctl_elem_value *ucontrol)
628{
629 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
630 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
631 int err;
632
633 if (rt712->fu0f_mixer_l_mute == !ucontrol->value.integer.value[0] &&
634 rt712->fu0f_mixer_r_mute == !ucontrol->value.integer.value[1])
635 return 0;
636
637 rt712->fu0f_mixer_l_mute = !ucontrol->value.integer.value[0];
638 rt712->fu0f_mixer_r_mute = !ucontrol->value.integer.value[1];
639 err = rt712_sdca_set_fu0f_capture_ctl(rt712);
640 if (err < 0)
641 return err;
642
643 return 1;
644}
645
646static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
647static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, -1725, 75, 0);
648static const DECLARE_TLV_DB_SCALE(boost_vol_tlv, 0, 1000, 0);
649
650static const struct snd_kcontrol_new rt712_sdca_controls[] = {
651 SOC_DOUBLE_R_EXT_TLV("FU05 Playback Volume",
652 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05, RT712_SDCA_CTL_FU_VOLUME, CH_L),
653 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05, RT712_SDCA_CTL_FU_VOLUME, CH_R),
654 0, 0x57, 0,
655 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, out_vol_tlv),
656 SOC_DOUBLE_EXT("FU0F Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0,
657 rt712_sdca_fu0f_capture_get, rt712_sdca_fu0f_capture_put),
658 SOC_DOUBLE_R_EXT_TLV("FU0F Capture Volume",
659 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F, RT712_SDCA_CTL_FU_VOLUME, CH_L),
660 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU0F, RT712_SDCA_CTL_FU_VOLUME, CH_R),
661 0, 0x3f, 0,
662 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, mic_vol_tlv),
663 SOC_DOUBLE_R_EXT_TLV("FU44 Boost Volume",
664 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PLATFORM_FU44, RT712_SDCA_CTL_FU_CH_GAIN, CH_L),
665 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PLATFORM_FU44, RT712_SDCA_CTL_FU_CH_GAIN, CH_R),
666 8, 3, 0,
667 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, boost_vol_tlv),
668};
669
670static const struct snd_kcontrol_new rt712_sdca_spk_controls[] = {
671 SOC_DOUBLE_R_EXT_TLV("FU06 Playback Volume",
672 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_VOLUME, CH_L),
673 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_VOLUME, CH_R),
674 0, 0x57, 0,
675 rt712_sdca_set_gain_get, rt712_sdca_set_gain_put, out_vol_tlv),
676};
677
678static int rt712_sdca_mux_get(struct snd_kcontrol *kcontrol,
679 struct snd_ctl_elem_value *ucontrol)
680{
681 struct snd_soc_component *component =
682 snd_soc_dapm_kcontrol_component(kcontrol);
683 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
684 unsigned int val = 0, mask = 0x3300;
685
686 rt712_sdca_index_read(rt712, RT712_VENDOR_HDA_CTL, RT712_MIXER_CTL1, value: &val);
687
688 val = val & mask;
689 switch (val) {
690 case 0x3000:
691 val = 1;
692 break;
693 case 0x0300:
694 val = 0;
695 break;
696 }
697
698 ucontrol->value.enumerated.item[0] = val;
699
700 return 0;
701}
702
703static int rt712_sdca_mux_put(struct snd_kcontrol *kcontrol,
704 struct snd_ctl_elem_value *ucontrol)
705{
706 struct snd_soc_component *component =
707 snd_soc_dapm_kcontrol_component(kcontrol);
708 struct snd_soc_dapm_context *dapm =
709 snd_soc_dapm_kcontrol_dapm(kcontrol);
710 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
711 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
712 unsigned int *item = ucontrol->value.enumerated.item;
713 unsigned int mask_sft;
714 unsigned int val;
715
716 if (item[0] >= e->items)
717 return -EINVAL;
718
719 if (ucontrol->value.enumerated.item[0] == 0)
720 mask_sft = 12;
721 else if (ucontrol->value.enumerated.item[0] == 1)
722 mask_sft = 8;
723 else
724 return -EINVAL;
725
726 rt712_sdca_index_read(rt712, RT712_VENDOR_HDA_CTL, RT712_MIXER_CTL1, value: &val);
727 val = (val >> mask_sft) & 0x3;
728 if (!val)
729 return 0;
730
731 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL,
732 RT712_MIXER_CTL1, value: 0x3fff);
733 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
734 RT712_MIXER_CTL1, mask: 0x3 << mask_sft, val: 0);
735
736 snd_soc_dapm_mux_update_power(dapm, kcontrol,
737 mux: item[0], e, NULL);
738
739 return 1;
740}
741
742static const char * const adc_mux_text[] = {
743 "MIC2",
744 "LINE2",
745};
746
747static SOC_ENUM_SINGLE_DECL(
748 rt712_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
749
750static const struct snd_kcontrol_new rt712_sdca_adc23_mux =
751 SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt712_adc23_enum,
752 rt712_sdca_mux_get, rt712_sdca_mux_put);
753
754static int rt712_sdca_fu05_event(struct snd_soc_dapm_widget *w,
755 struct snd_kcontrol *kcontrol, int event)
756{
757 struct snd_soc_component *component =
758 snd_soc_dapm_to_component(dapm: w->dapm);
759 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
760 unsigned char unmute = 0x0, mute = 0x1;
761
762 switch (event) {
763 case SND_SOC_DAPM_POST_PMU:
764 regmap_write(map: rt712->regmap,
765 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05,
766 RT712_SDCA_CTL_FU_MUTE, CH_L),
767 val: unmute);
768 regmap_write(map: rt712->regmap,
769 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05,
770 RT712_SDCA_CTL_FU_MUTE, CH_R),
771 val: unmute);
772 break;
773 case SND_SOC_DAPM_PRE_PMD:
774 regmap_write(map: rt712->regmap,
775 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05,
776 RT712_SDCA_CTL_FU_MUTE, CH_L),
777 val: mute);
778 regmap_write(map: rt712->regmap,
779 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_USER_FU05,
780 RT712_SDCA_CTL_FU_MUTE, CH_R),
781 val: mute);
782 break;
783 }
784 return 0;
785}
786
787static int rt712_sdca_fu0f_event(struct snd_soc_dapm_widget *w,
788 struct snd_kcontrol *kcontrol, int event)
789{
790 struct snd_soc_component *component =
791 snd_soc_dapm_to_component(dapm: w->dapm);
792 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
793
794 switch (event) {
795 case SND_SOC_DAPM_POST_PMU:
796 rt712->fu0f_dapm_mute = false;
797 rt712_sdca_set_fu0f_capture_ctl(rt712);
798 break;
799 case SND_SOC_DAPM_PRE_PMD:
800 rt712->fu0f_dapm_mute = true;
801 rt712_sdca_set_fu0f_capture_ctl(rt712);
802 break;
803 }
804 return 0;
805}
806
807static int rt712_sdca_pde40_event(struct snd_soc_dapm_widget *w,
808 struct snd_kcontrol *kcontrol, int event)
809{
810 struct snd_soc_component *component =
811 snd_soc_dapm_to_component(dapm: w->dapm);
812 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
813 unsigned char ps0 = 0x0, ps3 = 0x3;
814
815 switch (event) {
816 case SND_SOC_DAPM_POST_PMU:
817 regmap_write(map: rt712->regmap,
818 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE40,
819 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
820 val: ps0);
821 break;
822 case SND_SOC_DAPM_PRE_PMD:
823 regmap_write(map: rt712->regmap,
824 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE40,
825 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
826 val: ps3);
827 break;
828 }
829 return 0;
830}
831
832static int rt712_sdca_pde12_event(struct snd_soc_dapm_widget *w,
833 struct snd_kcontrol *kcontrol, int event)
834{
835 struct snd_soc_component *component =
836 snd_soc_dapm_to_component(dapm: w->dapm);
837 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
838 unsigned char ps0 = 0x0, ps3 = 0x3;
839
840 switch (event) {
841 case SND_SOC_DAPM_POST_PMU:
842 regmap_write(map: rt712->regmap,
843 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE12,
844 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
845 val: ps0);
846 break;
847 case SND_SOC_DAPM_PRE_PMD:
848 regmap_write(map: rt712->regmap,
849 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_PDE12,
850 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
851 val: ps3);
852 break;
853 }
854 return 0;
855}
856
857static int rt712_sdca_classd_event(struct snd_soc_dapm_widget *w,
858 struct snd_kcontrol *kcontrol, int event)
859{
860 struct snd_soc_component *component =
861 snd_soc_dapm_to_component(dapm: w->dapm);
862 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
863 unsigned char ps0 = 0x0, ps3 = 0x3;
864
865 switch (event) {
866 case SND_SOC_DAPM_POST_PMU:
867 regmap_write(map: rt712->regmap,
868 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_PDE23,
869 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
870 val: ps0);
871 break;
872 case SND_SOC_DAPM_PRE_PMD:
873 regmap_write(map: rt712->regmap,
874 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_PDE23,
875 RT712_SDCA_CTL_REQ_POWER_STATE, 0),
876 val: ps3);
877 break;
878
879 default:
880 break;
881 }
882
883 return 0;
884}
885
886static const struct snd_kcontrol_new rt712_spk_sto_dac =
887 SOC_DAPM_DOUBLE_R("Switch",
888 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_MUTE, CH_L),
889 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_USER_FU06, RT712_SDCA_CTL_FU_MUTE, CH_R),
890 0, 1, 1);
891
892static const struct snd_soc_dapm_widget rt712_sdca_dapm_widgets[] = {
893 SND_SOC_DAPM_OUTPUT("HP"),
894 SND_SOC_DAPM_INPUT("MIC2"),
895 SND_SOC_DAPM_INPUT("LINE2"),
896
897 SND_SOC_DAPM_SUPPLY("PDE 40", SND_SOC_NOPM, 0, 0,
898 rt712_sdca_pde40_event,
899 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
900 SND_SOC_DAPM_SUPPLY("PDE 12", SND_SOC_NOPM, 0, 0,
901 rt712_sdca_pde12_event,
902 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
903
904 SND_SOC_DAPM_DAC_E("FU 05", NULL, SND_SOC_NOPM, 0, 0,
905 rt712_sdca_fu05_event,
906 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
907 SND_SOC_DAPM_ADC_E("FU 0F", NULL, SND_SOC_NOPM, 0, 0,
908 rt712_sdca_fu0f_event,
909 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
910 SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
911 &rt712_sdca_adc23_mux),
912
913 SND_SOC_DAPM_AIF_IN("DP1RX", "DP1 Playback", 0, SND_SOC_NOPM, 0, 0),
914 SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
915};
916
917static const struct snd_soc_dapm_route rt712_sdca_audio_map[] = {
918 { "FU 05", NULL, "DP1RX" },
919 { "DP4TX", NULL, "FU 0F" },
920
921 { "FU 0F", NULL, "PDE 12" },
922 { "FU 0F", NULL, "ADC 23 Mux" },
923 { "ADC 23 Mux", "LINE2", "LINE2" },
924 { "ADC 23 Mux", "MIC2", "MIC2" },
925
926 { "HP", NULL, "PDE 40" },
927 { "HP", NULL, "FU 05" },
928};
929
930static const struct snd_soc_dapm_widget rt712_sdca_spk_dapm_widgets[] = {
931 SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
932
933 /* Digital Interface */
934 SND_SOC_DAPM_SWITCH("FU06", SND_SOC_NOPM, 0, 0, &rt712_spk_sto_dac),
935
936 /* Output */
937 SND_SOC_DAPM_PGA_E("CLASS D", SND_SOC_NOPM, 0, 0, NULL, 0,
938 rt712_sdca_classd_event, SND_SOC_DAPM_PRE_PMD | SND_SOC_DAPM_POST_PMU),
939 SND_SOC_DAPM_OUTPUT("SPOL"),
940 SND_SOC_DAPM_OUTPUT("SPOR"),
941};
942
943static const struct snd_soc_dapm_route rt712_sdca_spk_dapm_routes[] = {
944 { "FU06", "Switch", "DP3RX" },
945 { "CLASS D", NULL, "FU06" },
946 { "SPOL", NULL, "CLASS D" },
947 { "SPOR", NULL, "CLASS D" },
948};
949
950static int rt712_sdca_parse_dt(struct rt712_sdca_priv *rt712, struct device *dev)
951{
952 device_property_read_u32(dev, propname: "realtek,jd-src", val: &rt712->jd_src);
953
954 return 0;
955}
956
957static int rt712_sdca_probe(struct snd_soc_component *component)
958{
959 struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
960 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
961 int ret;
962
963 rt712_sdca_parse_dt(rt712, dev: &rt712->slave->dev);
964 rt712->component = component;
965
966 /* add SPK route */
967 if (rt712->hw_id != RT712_DEV_ID_713) {
968 snd_soc_add_component_controls(component,
969 controls: rt712_sdca_spk_controls, ARRAY_SIZE(rt712_sdca_spk_controls));
970 snd_soc_dapm_new_controls(dapm,
971 widget: rt712_sdca_spk_dapm_widgets, ARRAY_SIZE(rt712_sdca_spk_dapm_widgets));
972 snd_soc_dapm_add_routes(dapm,
973 route: rt712_sdca_spk_dapm_routes, ARRAY_SIZE(rt712_sdca_spk_dapm_routes));
974 }
975
976 if (!rt712->first_hw_init)
977 return 0;
978
979 ret = pm_runtime_resume(dev: component->dev);
980 if (ret < 0 && ret != -EACCES)
981 return ret;
982
983 return 0;
984}
985
986static const struct snd_soc_component_driver soc_sdca_dev_rt712 = {
987 .probe = rt712_sdca_probe,
988 .controls = rt712_sdca_controls,
989 .num_controls = ARRAY_SIZE(rt712_sdca_controls),
990 .dapm_widgets = rt712_sdca_dapm_widgets,
991 .num_dapm_widgets = ARRAY_SIZE(rt712_sdca_dapm_widgets),
992 .dapm_routes = rt712_sdca_audio_map,
993 .num_dapm_routes = ARRAY_SIZE(rt712_sdca_audio_map),
994 .set_jack = rt712_sdca_set_jack_detect,
995 .endianness = 1,
996};
997
998static int rt712_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
999 int direction)
1000{
1001 snd_soc_dai_dma_data_set(dai, stream: direction, data: sdw_stream);
1002
1003 return 0;
1004}
1005
1006static void rt712_sdca_shutdown(struct snd_pcm_substream *substream,
1007 struct snd_soc_dai *dai)
1008{
1009 snd_soc_dai_set_dma_data(dai, substream, NULL);
1010}
1011
1012static int rt712_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
1013 struct snd_pcm_hw_params *params,
1014 struct snd_soc_dai *dai)
1015{
1016 struct snd_soc_component *component = dai->component;
1017 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
1018 struct sdw_stream_config stream_config;
1019 struct sdw_port_config port_config;
1020 enum sdw_data_direction direction;
1021 struct sdw_stream_runtime *sdw_stream;
1022 int retval, port, num_channels;
1023 unsigned int sampling_rate;
1024
1025 dev_dbg(dai->dev, "%s %s", __func__, dai->name);
1026 sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
1027
1028 if (!sdw_stream)
1029 return -EINVAL;
1030
1031 if (!rt712->slave)
1032 return -EINVAL;
1033
1034 /* SoundWire specific configuration */
1035 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1036 direction = SDW_DATA_DIR_RX;
1037 if (dai->id == RT712_AIF1)
1038 port = 1;
1039 else if (dai->id == RT712_AIF2)
1040 port = 3;
1041 else
1042 return -EINVAL;
1043 } else {
1044 direction = SDW_DATA_DIR_TX;
1045 if (dai->id == RT712_AIF1)
1046 port = 4;
1047 else
1048 return -EINVAL;
1049 }
1050
1051 stream_config.frame_rate = params_rate(p: params);
1052 stream_config.ch_count = params_channels(p: params);
1053 stream_config.bps = snd_pcm_format_width(format: params_format(p: params));
1054 stream_config.direction = direction;
1055
1056 num_channels = params_channels(p: params);
1057 port_config.ch_mask = GENMASK(num_channels - 1, 0);
1058 port_config.num = port;
1059
1060 retval = sdw_stream_add_slave(slave: rt712->slave, stream_config: &stream_config,
1061 port_config: &port_config, num_ports: 1, stream: sdw_stream);
1062 if (retval) {
1063 dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
1064 return retval;
1065 }
1066
1067 if (params_channels(p: params) > 16) {
1068 dev_err(component->dev, "%s: Unsupported channels %d\n",
1069 __func__, params_channels(params));
1070 return -EINVAL;
1071 }
1072
1073 /* sampling rate configuration */
1074 switch (params_rate(p: params)) {
1075 case 44100:
1076 sampling_rate = RT712_SDCA_RATE_44100HZ;
1077 break;
1078 case 48000:
1079 sampling_rate = RT712_SDCA_RATE_48000HZ;
1080 break;
1081 case 96000:
1082 sampling_rate = RT712_SDCA_RATE_96000HZ;
1083 break;
1084 case 192000:
1085 sampling_rate = RT712_SDCA_RATE_192000HZ;
1086 break;
1087 default:
1088 dev_err(component->dev, "%s: Rate %d is not supported\n",
1089 __func__, params_rate(params));
1090 return -EINVAL;
1091 }
1092
1093 /* set sampling frequency */
1094 switch (dai->id) {
1095 case RT712_AIF1:
1096 regmap_write(map: rt712->regmap,
1097 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_CS01, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1098 val: sampling_rate);
1099 regmap_write(map: rt712->regmap,
1100 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_CS11, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1101 val: sampling_rate);
1102 break;
1103 case RT712_AIF2:
1104 regmap_write(map: rt712->regmap,
1105 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_CS31, RT712_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1106 val: sampling_rate);
1107 break;
1108 default:
1109 dev_err(component->dev, "%s: Wrong DAI id\n", __func__);
1110 return -EINVAL;
1111 }
1112
1113 return 0;
1114}
1115
1116static int rt712_sdca_pcm_hw_free(struct snd_pcm_substream *substream,
1117 struct snd_soc_dai *dai)
1118{
1119 struct snd_soc_component *component = dai->component;
1120 struct rt712_sdca_priv *rt712 = snd_soc_component_get_drvdata(c: component);
1121 struct sdw_stream_runtime *sdw_stream =
1122 snd_soc_dai_get_dma_data(dai, substream);
1123
1124 if (!rt712->slave)
1125 return -EINVAL;
1126
1127 sdw_stream_remove_slave(slave: rt712->slave, stream: sdw_stream);
1128 return 0;
1129}
1130
1131#define RT712_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \
1132 SNDRV_PCM_RATE_192000)
1133#define RT712_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
1134 SNDRV_PCM_FMTBIT_S24_LE)
1135
1136static const struct snd_soc_dai_ops rt712_sdca_ops = {
1137 .hw_params = rt712_sdca_pcm_hw_params,
1138 .hw_free = rt712_sdca_pcm_hw_free,
1139 .set_stream = rt712_sdca_set_sdw_stream,
1140 .shutdown = rt712_sdca_shutdown,
1141};
1142
1143static struct snd_soc_dai_driver rt712_sdca_dai[] = {
1144 {
1145 .name = "rt712-sdca-aif1",
1146 .id = RT712_AIF1,
1147 .playback = {
1148 .stream_name = "DP1 Playback",
1149 .channels_min = 1,
1150 .channels_max = 2,
1151 .rates = RT712_STEREO_RATES,
1152 .formats = RT712_FORMATS,
1153 },
1154 .capture = {
1155 .stream_name = "DP4 Capture",
1156 .channels_min = 1,
1157 .channels_max = 2,
1158 .rates = RT712_STEREO_RATES,
1159 .formats = RT712_FORMATS,
1160 },
1161 .ops = &rt712_sdca_ops,
1162 },
1163 {
1164 .name = "rt712-sdca-aif2",
1165 .id = RT712_AIF2,
1166 .playback = {
1167 .stream_name = "DP3 Playback",
1168 .channels_min = 1,
1169 .channels_max = 2,
1170 .rates = RT712_STEREO_RATES,
1171 .formats = RT712_FORMATS,
1172 },
1173 .ops = &rt712_sdca_ops,
1174 }
1175};
1176
1177int rt712_sdca_init(struct device *dev, struct regmap *regmap,
1178 struct regmap *mbq_regmap, struct sdw_slave *slave)
1179{
1180 struct rt712_sdca_priv *rt712;
1181 int ret;
1182
1183 rt712 = devm_kzalloc(dev, size: sizeof(*rt712), GFP_KERNEL);
1184 if (!rt712)
1185 return -ENOMEM;
1186
1187 dev_set_drvdata(dev, data: rt712);
1188 rt712->slave = slave;
1189 rt712->regmap = regmap;
1190 rt712->mbq_regmap = mbq_regmap;
1191
1192 regcache_cache_only(map: rt712->regmap, enable: true);
1193 regcache_cache_only(map: rt712->mbq_regmap, enable: true);
1194
1195 mutex_init(&rt712->calibrate_mutex);
1196 mutex_init(&rt712->disable_irq_lock);
1197
1198 INIT_DELAYED_WORK(&rt712->jack_detect_work, rt712_sdca_jack_detect_handler);
1199 INIT_DELAYED_WORK(&rt712->jack_btn_check_work, rt712_sdca_btn_check_handler);
1200
1201 /*
1202 * Mark hw_init to false
1203 * HW init will be performed when device reports present
1204 */
1205 rt712->hw_init = false;
1206 rt712->first_hw_init = false;
1207 rt712->fu0f_dapm_mute = true;
1208 rt712->fu0f_mixer_l_mute = rt712->fu0f_mixer_r_mute = true;
1209
1210 /* JD source uses JD1 in default */
1211 rt712->jd_src = RT712_JD1;
1212
1213 if (slave->id.part_id != RT712_PART_ID_713)
1214 ret = devm_snd_soc_register_component(dev,
1215 component_driver: &soc_sdca_dev_rt712, dai_drv: rt712_sdca_dai, ARRAY_SIZE(rt712_sdca_dai));
1216 else
1217 ret = devm_snd_soc_register_component(dev,
1218 component_driver: &soc_sdca_dev_rt712, dai_drv: rt712_sdca_dai, num_dai: 1);
1219 if (ret < 0)
1220 return ret;
1221
1222 /* set autosuspend parameters */
1223 pm_runtime_set_autosuspend_delay(dev, delay: 3000);
1224 pm_runtime_use_autosuspend(dev);
1225
1226 /* make sure the device does not suspend immediately */
1227 pm_runtime_mark_last_busy(dev);
1228
1229 pm_runtime_enable(dev);
1230
1231 /* important note: the device is NOT tagged as 'active' and will remain
1232 * 'suspended' until the hardware is enumerated/initialized. This is required
1233 * to make sure the ASoC framework use of pm_runtime_get_sync() does not silently
1234 * fail with -EACCESS because of race conditions between card creation and enumeration
1235 */
1236
1237 dev_dbg(dev, "%s\n", __func__);
1238
1239 return 0;
1240}
1241
1242int rt712_sdca_io_init(struct device *dev, struct sdw_slave *slave)
1243{
1244 struct rt712_sdca_priv *rt712 = dev_get_drvdata(dev);
1245 int ret = 0;
1246 unsigned int val, hibernation_flag;
1247
1248 rt712->disable_irq = false;
1249
1250 if (rt712->hw_init)
1251 return 0;
1252
1253 regcache_cache_only(map: rt712->regmap, enable: false);
1254 regcache_cache_only(map: rt712->mbq_regmap, enable: false);
1255 if (rt712->first_hw_init) {
1256 regcache_cache_bypass(map: rt712->regmap, enable: true);
1257 regcache_cache_bypass(map: rt712->mbq_regmap, enable: true);
1258 } else {
1259 /*
1260 * PM runtime status is marked as 'active' only when a Slave reports as Attached
1261 */
1262
1263 /* update count of parent 'active' children */
1264 pm_runtime_set_active(dev: &slave->dev);
1265 }
1266
1267 pm_runtime_get_noresume(dev: &slave->dev);
1268
1269 rt712_sdca_index_read(rt712, RT712_VENDOR_REG, RT712_JD_PRODUCT_NUM, value: &val);
1270 rt712->hw_id = (val & 0xf000) >> 12;
1271
1272 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_ANALOG_BIAS_CTL3, value: 0xaa81);
1273 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_LDO2_3_CTL1, value: 0xa1e0);
1274 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_HP_DETECT_RLDET_CTL1, value: 0x0000);
1275 rt712_sdca_index_write(rt712, RT712_VENDOR_IMS_DRE, RT712_HP_DETECT_RLDET_CTL2, value: 0x0000);
1276 rt712_sdca_index_write(rt712, RT712_VENDOR_ANALOG_CTL, RT712_MISC_POWER_CTL7, value: 0x0000);
1277 regmap_write(map: rt712->regmap, RT712_RC_CAL, val: 0x23);
1278
1279 /* calibration */
1280 rt712_sdca_index_read(rt712, RT712_VENDOR_REG, RT712_SW_CONFIG1, value: &hibernation_flag);
1281 if (!hibernation_flag) {
1282 ret = rt712_sdca_calibration(rt712);
1283 if (ret < 0)
1284 dev_err(dev, "%s, calibration failed!\n", __func__);
1285 }
1286
1287 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
1288 RT712_MIXER_CTL1, mask: 0x3000, val: 0x0000);
1289 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL,
1290 RT712_ADC0A_08_PDE_FLOAT_CTL, value: 0x1112);
1291 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL,
1292 RT712_MIC2_LINE2_PDE_FLOAT_CTL, value: 0x3412);
1293 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL,
1294 RT712_DAC03_HP_PDE_FLOAT_CTL, value: 0x4040);
1295
1296 rt712_sdca_index_update_bits(rt712, RT712_VENDOR_HDA_CTL,
1297 RT712_HDA_LEGACY_GPIO_WAKE_EN_CTL, mask: 0x0001, val: 0x0000);
1298 regmap_write(map: rt712->regmap, reg: 0x2f50, val: 0x00);
1299 regmap_write(map: rt712->regmap, reg: 0x2f54, val: 0x00);
1300 regmap_write(map: rt712->regmap,
1301 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT712_SDCA_ENT_IT09, RT712_SDCA_CTL_VENDOR_DEF, 0), val: 0x01);
1302
1303 /* add SPK settings */
1304 if (rt712->hw_id != RT712_DEV_ID_713) {
1305 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_AMP_PDE_FLOAT_CTL, value: 0x2323);
1306 rt712_sdca_index_write(rt712, RT712_VENDOR_HDA_CTL, RT712_EAPD_CTL, value: 0x0002);
1307 regmap_write(map: rt712->regmap,
1308 SDW_SDCA_CTL(FUNC_NUM_AMP, RT712_SDCA_ENT_OT23, RT712_SDCA_CTL_VENDOR_DEF, 0), val: 0x04);
1309 }
1310
1311 /*
1312 * if set_jack callback occurred early than io_init,
1313 * we set up the jack detection function now
1314 */
1315 if (rt712->hs_jack)
1316 rt712_sdca_jack_init(rt712);
1317
1318 if (!hibernation_flag)
1319 rt712_sdca_index_write(rt712, RT712_VENDOR_REG, RT712_SW_CONFIG1, value: 0x0001);
1320
1321 if (rt712->first_hw_init) {
1322 regcache_cache_bypass(map: rt712->regmap, enable: false);
1323 regcache_mark_dirty(map: rt712->regmap);
1324 regcache_cache_bypass(map: rt712->mbq_regmap, enable: false);
1325 regcache_mark_dirty(map: rt712->mbq_regmap);
1326 } else
1327 rt712->first_hw_init = true;
1328
1329 /* Mark Slave initialization complete */
1330 rt712->hw_init = true;
1331
1332 pm_runtime_mark_last_busy(dev: &slave->dev);
1333 pm_runtime_put_autosuspend(dev: &slave->dev);
1334
1335 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
1336 return 0;
1337}
1338
1339MODULE_DESCRIPTION("ASoC RT712 SDCA SDW driver");
1340MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
1341MODULE_LICENSE("GPL");
1342

source code of linux/sound/soc/codecs/rt712-sdca.c