1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // rt711-sdca.c -- rt711 SDCA ALSA SoC audio driver
4 //
5 // Copyright(c) 2021 Realtek Semiconductor Corp.
6 //
7 //
8
9 #include <linux/module.h>
10 #include <linux/moduleparam.h>
11 #include <linux/kernel.h>
12 #include <linux/init.h>
13 #include <linux/delay.h>
14 #include <linux/pm_runtime.h>
15 #include <linux/soundwire/sdw_registers.h>
16 #include <linux/slab.h>
17 #include <linux/bitops.h>
18 #include <sound/core.h>
19 #include <sound/pcm.h>
20 #include <sound/pcm_params.h>
21 #include <sound/sdw.h>
22 #include <sound/soc-dapm.h>
23 #include <sound/initval.h>
24 #include <sound/tlv.h>
25 #include <sound/jack.h>
26
27 #include "rt711-sdca.h"
28
rt711_sdca_index_write(struct rt711_sdca_priv * rt711,unsigned int nid,unsigned int reg,unsigned int value)29 static int rt711_sdca_index_write(struct rt711_sdca_priv *rt711,
30 unsigned int nid, unsigned int reg, unsigned int value)
31 {
32 int ret;
33 struct regmap *regmap = rt711->mbq_regmap;
34 unsigned int addr = (nid << 20) | reg;
35
36 ret = regmap_write(regmap, addr, value);
37 if (ret < 0)
38 dev_err(&rt711->slave->dev,
39 "%s: Failed to set private value: %06x <= %04x ret=%d\n",
40 __func__, addr, value, ret);
41
42 return ret;
43 }
44
rt711_sdca_index_read(struct rt711_sdca_priv * rt711,unsigned int nid,unsigned int reg,unsigned int * value)45 static int rt711_sdca_index_read(struct rt711_sdca_priv *rt711,
46 unsigned int nid, unsigned int reg, unsigned int *value)
47 {
48 int ret;
49 struct regmap *regmap = rt711->mbq_regmap;
50 unsigned int addr = (nid << 20) | reg;
51
52 ret = regmap_read(regmap, addr, value);
53 if (ret < 0)
54 dev_err(&rt711->slave->dev,
55 "%s: Failed to get private value: %06x => %04x ret=%d\n",
56 __func__, addr, *value, ret);
57
58 return ret;
59 }
60
rt711_sdca_index_update_bits(struct rt711_sdca_priv * rt711,unsigned int nid,unsigned int reg,unsigned int mask,unsigned int val)61 static int rt711_sdca_index_update_bits(struct rt711_sdca_priv *rt711,
62 unsigned int nid, unsigned int reg, unsigned int mask, unsigned int val)
63 {
64 unsigned int tmp;
65 int ret;
66
67 ret = rt711_sdca_index_read(rt711, nid, reg, &tmp);
68 if (ret < 0)
69 return ret;
70
71 set_mask_bits(&tmp, mask, val);
72 return rt711_sdca_index_write(rt711, nid, reg, tmp);
73 }
74
rt711_sdca_reset(struct rt711_sdca_priv * rt711)75 static void rt711_sdca_reset(struct rt711_sdca_priv *rt711)
76 {
77 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
78 RT711_PARA_VERB_CTL, RT711_HIDDEN_REG_SW_RESET,
79 RT711_HIDDEN_REG_SW_RESET);
80 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
81 RT711_HDA_LEGACY_RESET_CTL, 0x1, 0x1);
82 }
83
rt711_sdca_ge_force_jack_type(struct rt711_sdca_priv * rt711,unsigned int det_mode)84 static void rt711_sdca_ge_force_jack_type(struct rt711_sdca_priv *rt711, unsigned int det_mode)
85 {
86 switch (det_mode) {
87 case 0x00:
88 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, RT711_COMBO_JACK_AUTO_CTL1, 0x8400, 0x0000);
89 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, RT711_PUSH_BTN_INT_CTL0, 0x10, 0x00);
90 break;
91 case 0x03:
92 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, RT711_COMBO_JACK_AUTO_CTL1, 0x8400, 0x8000);
93 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, RT711_PUSH_BTN_INT_CTL0, 0x17, 0x13);
94 break;
95 case 0x05:
96 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG, RT711_COMBO_JACK_AUTO_CTL1, 0x8400, 0x8400);
97 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL, RT711_PUSH_BTN_INT_CTL0, 0x17, 0x15);
98 break;
99 }
100 }
101
rt711_sdca_calibration(struct rt711_sdca_priv * rt711)102 static int rt711_sdca_calibration(struct rt711_sdca_priv *rt711)
103 {
104 unsigned int val, loop_rc = 0, loop_dc = 0;
105 struct device *dev;
106 struct regmap *regmap = rt711->regmap;
107 int chk_cnt = 100;
108 int ret = 0;
109
110 mutex_lock(&rt711->calibrate_mutex);
111 dev = regmap_get_device(regmap);
112
113 regmap_read(rt711->regmap, RT711_RC_CAL_STATUS, &val);
114 /* RC calibration */
115 if (!(val & 0x40))
116 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_ANALOG_CTL,
117 RT711_MISC_POWER_CTL0, 0x0010, 0x0010);
118
119 for (loop_rc = 0; loop_rc < chk_cnt && !(val & 0x40); loop_rc++) {
120 usleep_range(10000, 11000);
121 ret = regmap_read(rt711->regmap, RT711_RC_CAL_STATUS, &val);
122 if (ret < 0)
123 goto _cali_fail_;
124 }
125 if (loop_rc == chk_cnt)
126 dev_err(dev, "%s, RC calibration time-out!\n", __func__);
127
128 /* HP calibration by manual mode setting */
129 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
130 RT711_FSM_CTL, 0x2000, 0x2000);
131
132 /* Calibration manual mode */
133 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
134 RT711_FSM_CTL, 0xf, RT711_CALI_CTL);
135
136 /* reset HP calibration */
137 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
138 RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_FORCE_CALI_RST, 0x00);
139 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
140 RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_FORCE_CALI_RST,
141 RT711_DAC_DC_FORCE_CALI_RST);
142
143 /* cal_clk_en_reg */
144 if (rt711->hw_ver == RT711_VER_VD0)
145 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
146 RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_CALI_CLK_EN,
147 RT711_DAC_DC_CALI_CLK_EN);
148
149 /* trigger */
150 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_CALI,
151 RT711_DAC_DC_CALI_CTL1, RT711_DAC_DC_CALI_TRIGGER,
152 RT711_DAC_DC_CALI_TRIGGER);
153
154 /* wait for calibration process */
155 rt711_sdca_index_read(rt711, RT711_VENDOR_CALI,
156 RT711_DAC_DC_CALI_CTL1, &val);
157
158 for (loop_dc = 0; loop_dc < chk_cnt &&
159 (val & RT711_DAC_DC_CALI_TRIGGER); loop_dc++) {
160 usleep_range(10000, 11000);
161 ret = rt711_sdca_index_read(rt711, RT711_VENDOR_CALI,
162 RT711_DAC_DC_CALI_CTL1, &val);
163 if (ret < 0)
164 goto _cali_fail_;
165 }
166 if (loop_dc == chk_cnt)
167 dev_err(dev, "%s, calibration time-out!\n", __func__);
168
169 if (loop_dc == chk_cnt || loop_rc == chk_cnt)
170 ret = -ETIMEDOUT;
171
172 _cali_fail_:
173 /* enable impedance sense */
174 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
175 RT711_FSM_CTL, RT711_FSM_IMP_EN, RT711_FSM_IMP_EN);
176
177 /* release HP-JD and trigger FSM */
178 rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
179 RT711_DIGITAL_MISC_CTRL4, 0x201b);
180
181 mutex_unlock(&rt711->calibrate_mutex);
182 dev_dbg(dev, "%s calibration complete, ret=%d\n", __func__, ret);
183 return ret;
184 }
185
rt711_sdca_button_detect(struct rt711_sdca_priv * rt711)186 static unsigned int rt711_sdca_button_detect(struct rt711_sdca_priv *rt711)
187 {
188 unsigned int btn_type = 0, offset, idx, val, owner;
189 int ret;
190 unsigned char buf[3];
191
192 /* get current UMP message owner */
193 ret = regmap_read(rt711->regmap,
194 SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_CURRENT_OWNER, 0),
195 &owner);
196 if (ret < 0)
197 return 0;
198
199 /* if owner is device then there is no button event from device */
200 if (owner == 1)
201 return 0;
202
203 /* read UMP message offset */
204 ret = regmap_read(rt711->regmap,
205 SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0),
206 &offset);
207 if (ret < 0)
208 goto _end_btn_det_;
209
210 for (idx = 0; idx < sizeof(buf); idx++) {
211 ret = regmap_read(rt711->regmap,
212 RT711_BUF_ADDR_HID1 + offset + idx, &val);
213 if (ret < 0)
214 goto _end_btn_det_;
215 buf[idx] = val & 0xff;
216 }
217
218 if (buf[0] == 0x11) {
219 switch (buf[1] & 0xf0) {
220 case 0x10:
221 btn_type |= SND_JACK_BTN_2;
222 break;
223 case 0x20:
224 btn_type |= SND_JACK_BTN_3;
225 break;
226 case 0x40:
227 btn_type |= SND_JACK_BTN_0;
228 break;
229 case 0x80:
230 btn_type |= SND_JACK_BTN_1;
231 break;
232 }
233 switch (buf[2]) {
234 case 0x01:
235 case 0x10:
236 btn_type |= SND_JACK_BTN_2;
237 break;
238 case 0x02:
239 case 0x20:
240 btn_type |= SND_JACK_BTN_3;
241 break;
242 case 0x04:
243 case 0x40:
244 btn_type |= SND_JACK_BTN_0;
245 break;
246 case 0x08:
247 case 0x80:
248 btn_type |= SND_JACK_BTN_1;
249 break;
250 }
251 }
252
253 _end_btn_det_:
254 /* Host is owner, so set back to device */
255 if (owner == 0)
256 /* set owner to device */
257 regmap_write(rt711->regmap,
258 SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01,
259 RT711_SDCA_CTL_HIDTX_SET_OWNER_TO_DEVICE, 0), 0x01);
260
261 return btn_type;
262 }
263
rt711_sdca_headset_detect(struct rt711_sdca_priv * rt711)264 static int rt711_sdca_headset_detect(struct rt711_sdca_priv *rt711)
265 {
266 unsigned int det_mode;
267 int ret;
268
269 rt711_sdca_ge_force_jack_type(rt711, rt711->ge_mode_override);
270
271 /* get detected_mode */
272 ret = regmap_read(rt711->regmap,
273 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_DETECTED_MODE, 0),
274 &det_mode);
275 if (ret < 0)
276 goto io_error;
277
278 switch (det_mode) {
279 case 0x00:
280 rt711->jack_type = 0;
281 break;
282 case 0x03:
283 rt711->jack_type = SND_JACK_HEADPHONE;
284 break;
285 case 0x05:
286 rt711->jack_type = SND_JACK_HEADSET;
287 break;
288 }
289
290 /* write selected_mode */
291 if (det_mode) {
292 ret = regmap_write(rt711->regmap,
293 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_SELECTED_MODE, 0),
294 det_mode);
295 if (ret < 0)
296 goto io_error;
297 }
298
299 dev_dbg(&rt711->slave->dev,
300 "%s, detected_mode=0x%x\n", __func__, det_mode);
301
302 return 0;
303
304 io_error:
305 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
306 return ret;
307 }
308
rt711_sdca_jack_detect_handler(struct work_struct * work)309 static void rt711_sdca_jack_detect_handler(struct work_struct *work)
310 {
311 struct rt711_sdca_priv *rt711 =
312 container_of(work, struct rt711_sdca_priv, jack_detect_work.work);
313 int btn_type = 0, ret;
314
315 if (!rt711->hs_jack)
316 return;
317
318 if (!snd_soc_card_is_instantiated(rt711->component->card))
319 return;
320
321 /* SDW_SCP_SDCA_INT_SDCA_0 is used for jack detection */
322 if (rt711->scp_sdca_stat1 & SDW_SCP_SDCA_INT_SDCA_0) {
323 ret = rt711_sdca_headset_detect(rt711);
324 if (ret < 0)
325 return;
326 }
327
328 /* SDW_SCP_SDCA_INT_SDCA_8 is used for button detection */
329 if (rt711->scp_sdca_stat2 & SDW_SCP_SDCA_INT_SDCA_8)
330 btn_type = rt711_sdca_button_detect(rt711);
331
332 if (rt711->jack_type == 0)
333 btn_type = 0;
334
335 dev_dbg(&rt711->slave->dev,
336 "in %s, jack_type=0x%x\n", __func__, rt711->jack_type);
337 dev_dbg(&rt711->slave->dev,
338 "in %s, btn_type=0x%x\n", __func__, btn_type);
339 dev_dbg(&rt711->slave->dev,
340 "in %s, scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__,
341 rt711->scp_sdca_stat1, rt711->scp_sdca_stat2);
342
343 snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type,
344 SND_JACK_HEADSET |
345 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
346 SND_JACK_BTN_2 | SND_JACK_BTN_3);
347
348 if (btn_type) {
349 /* button released */
350 snd_soc_jack_report(rt711->hs_jack, rt711->jack_type,
351 SND_JACK_HEADSET |
352 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
353 SND_JACK_BTN_2 | SND_JACK_BTN_3);
354
355 mod_delayed_work(system_power_efficient_wq,
356 &rt711->jack_btn_check_work, msecs_to_jiffies(200));
357 }
358 }
359
rt711_sdca_btn_check_handler(struct work_struct * work)360 static void rt711_sdca_btn_check_handler(struct work_struct *work)
361 {
362 struct rt711_sdca_priv *rt711 =
363 container_of(work, struct rt711_sdca_priv, jack_btn_check_work.work);
364 int btn_type = 0, ret, idx;
365 unsigned int det_mode, offset, val;
366 unsigned char buf[3];
367
368 ret = regmap_read(rt711->regmap,
369 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49, RT711_SDCA_CTL_DETECTED_MODE, 0),
370 &det_mode);
371 if (ret < 0)
372 goto io_error;
373
374 /* pin attached */
375 if (det_mode) {
376 /* read UMP message offset */
377 ret = regmap_read(rt711->regmap,
378 SDW_SDCA_CTL(FUNC_NUM_HID, RT711_SDCA_ENT_HID01, RT711_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0),
379 &offset);
380 if (ret < 0)
381 goto io_error;
382
383 for (idx = 0; idx < sizeof(buf); idx++) {
384 ret = regmap_read(rt711->regmap,
385 RT711_BUF_ADDR_HID1 + offset + idx, &val);
386 if (ret < 0)
387 goto io_error;
388 buf[idx] = val & 0xff;
389 }
390
391 if (buf[0] == 0x11) {
392 switch (buf[1] & 0xf0) {
393 case 0x10:
394 btn_type |= SND_JACK_BTN_2;
395 break;
396 case 0x20:
397 btn_type |= SND_JACK_BTN_3;
398 break;
399 case 0x40:
400 btn_type |= SND_JACK_BTN_0;
401 break;
402 case 0x80:
403 btn_type |= SND_JACK_BTN_1;
404 break;
405 }
406 switch (buf[2]) {
407 case 0x01:
408 case 0x10:
409 btn_type |= SND_JACK_BTN_2;
410 break;
411 case 0x02:
412 case 0x20:
413 btn_type |= SND_JACK_BTN_3;
414 break;
415 case 0x04:
416 case 0x40:
417 btn_type |= SND_JACK_BTN_0;
418 break;
419 case 0x08:
420 case 0x80:
421 btn_type |= SND_JACK_BTN_1;
422 break;
423 }
424 }
425 } else
426 rt711->jack_type = 0;
427
428 dev_dbg(&rt711->slave->dev, "%s, btn_type=0x%x\n", __func__, btn_type);
429 snd_soc_jack_report(rt711->hs_jack, rt711->jack_type | btn_type,
430 SND_JACK_HEADSET |
431 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
432 SND_JACK_BTN_2 | SND_JACK_BTN_3);
433
434 if (btn_type) {
435 /* button released */
436 snd_soc_jack_report(rt711->hs_jack, rt711->jack_type,
437 SND_JACK_HEADSET |
438 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
439 SND_JACK_BTN_2 | SND_JACK_BTN_3);
440
441 mod_delayed_work(system_power_efficient_wq,
442 &rt711->jack_btn_check_work, msecs_to_jiffies(200));
443 }
444
445 return;
446
447 io_error:
448 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
449 }
450
rt711_sdca_jack_init(struct rt711_sdca_priv * rt711)451 static void rt711_sdca_jack_init(struct rt711_sdca_priv *rt711)
452 {
453 mutex_lock(&rt711->calibrate_mutex);
454
455 if (rt711->hs_jack) {
456 /* Enable HID1 event & set button RTC mode */
457 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
458 RT711_PUSH_BTN_INT_CTL6, 0x80f0, 0x8000);
459 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
460 RT711_PUSH_BTN_INT_CTL2, 0x11dd, 0x11dd);
461 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
462 RT711_PUSH_BTN_INT_CTL7, 0xffff);
463 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
464 RT711_PUSH_BTN_INT_CTL9, 0xf000, 0x0000);
465
466 /* GE_mode_change_event_en & Hid1_push_button_event_en */
467 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
468 RT711_GE_MODE_RELATED_CTL, 0x0c00, 0x0c00);
469
470 switch (rt711->jd_src) {
471 case RT711_JD1:
472 /* default settings was already for JD1 */
473 break;
474 case RT711_JD2:
475 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
476 RT711_JD_CTL1, RT711_JD2_DIGITAL_MODE_SEL,
477 RT711_JD2_DIGITAL_MODE_SEL);
478 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
479 RT711_JD_CTL2, RT711_JD2_2PORT_200K_DECODE_HP | RT711_HP_JD_SEL_JD2,
480 RT711_JD2_2PORT_200K_DECODE_HP | RT711_HP_JD_SEL_JD2);
481 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
482 RT711_CC_DET1,
483 RT711_HP_JD_FINAL_RESULT_CTL_JD12,
484 RT711_HP_JD_FINAL_RESULT_CTL_JD12);
485 break;
486 case RT711_JD2_100K:
487 rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
488 RT711_COMBO_JACK_AUTO_CTL3, 0xa47e);
489 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
490 RT711_JD_CTL1, RT711_JD2_DIGITAL_MODE_SEL,
491 RT711_JD2_DIGITAL_MODE_SEL);
492 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
493 RT711_JD_CTL2, RT711_JD2_2PORT_200K_DECODE_HP |
494 RT711_JD2_2PORT_100K_DECODE_MASK | RT711_HP_JD_SEL_JD2,
495 RT711_JD2_2PORT_100K_DECODE_HP | RT711_HP_JD_SEL_JD2);
496 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
497 RT711_CC_DET1,
498 RT711_HP_JD_FINAL_RESULT_CTL_JD12 | RT711_POW_CC1_AGPI,
499 RT711_HP_JD_FINAL_RESULT_CTL_JD12 | RT711_POW_CC1_AGPI_OFF);
500 break;
501 default:
502 dev_warn(rt711->component->dev, "Wrong JD source\n");
503 break;
504 }
505
506 /* set SCP_SDCA_IntMask1[0]=1 */
507 sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INTMASK1, SDW_SCP_SDCA_INTMASK_SDCA_0);
508 /* set SCP_SDCA_IntMask2[0]=1 */
509 sdw_write_no_pm(rt711->slave, SDW_SCP_SDCA_INTMASK2, SDW_SCP_SDCA_INTMASK_SDCA_8);
510 dev_dbg(&rt711->slave->dev, "in %s enable\n", __func__);
511 } else {
512 /* disable HID 1/2 event */
513 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
514 RT711_GE_MODE_RELATED_CTL, 0x0c00, 0x0000);
515
516 dev_dbg(&rt711->slave->dev, "in %s disable\n", __func__);
517 }
518
519 mutex_unlock(&rt711->calibrate_mutex);
520 }
521
rt711_sdca_set_jack_detect(struct snd_soc_component * component,struct snd_soc_jack * hs_jack,void * data)522 static int rt711_sdca_set_jack_detect(struct snd_soc_component *component,
523 struct snd_soc_jack *hs_jack, void *data)
524 {
525 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
526 int ret;
527
528 rt711->hs_jack = hs_jack;
529
530 /* we can only resume if the device was initialized at least once */
531 if (!rt711->first_hw_init)
532 return 0;
533
534 ret = pm_runtime_resume_and_get(component->dev);
535 if (ret < 0) {
536 if (ret != -EACCES) {
537 dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret);
538 return ret;
539 }
540
541 /* pm_runtime not enabled yet */
542 dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__);
543 return 0;
544 }
545
546 rt711_sdca_jack_init(rt711);
547
548 pm_runtime_put_autosuspend(component->dev);
549
550 return 0;
551 }
552
553 /* For SDCA control DAC/ADC Gain */
rt711_sdca_set_gain_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)554 static int rt711_sdca_set_gain_put(struct snd_kcontrol *kcontrol,
555 struct snd_ctl_elem_value *ucontrol)
556 {
557 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
558 struct soc_mixer_control *mc =
559 (struct soc_mixer_control *)kcontrol->private_value;
560 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
561 unsigned int read_l, read_r, gain_l_val, gain_r_val;
562 unsigned int i, adc_vol_flag = 0, changed = 0;
563 unsigned int lvalue, rvalue;
564
565 if (strstr(ucontrol->id.name, "FU1E Capture Volume") ||
566 strstr(ucontrol->id.name, "FU0F Capture Volume"))
567 adc_vol_flag = 1;
568
569 regmap_read(rt711->mbq_regmap, mc->reg, &lvalue);
570 regmap_read(rt711->mbq_regmap, mc->rreg, &rvalue);
571
572 /* control value to 2's complement value */
573 /* L Channel */
574 gain_l_val = ucontrol->value.integer.value[0];
575 if (gain_l_val > mc->max)
576 gain_l_val = mc->max;
577 read_l = gain_l_val;
578
579 if (mc->shift == 8) /* boost gain */
580 gain_l_val = (gain_l_val * 10) << mc->shift;
581 else { /* ADC/DAC gain */
582 if (adc_vol_flag && gain_l_val > mc->shift)
583 gain_l_val = (gain_l_val - mc->shift) * 75;
584 else
585 gain_l_val = (mc->shift - gain_l_val) * 75;
586 gain_l_val <<= 8;
587 gain_l_val /= 100;
588 if (!(adc_vol_flag && read_l > mc->shift)) {
589 gain_l_val = ~gain_l_val;
590 gain_l_val += 1;
591 }
592 gain_l_val &= 0xffff;
593 }
594
595 /* R Channel */
596 gain_r_val = ucontrol->value.integer.value[1];
597 if (gain_r_val > mc->max)
598 gain_r_val = mc->max;
599 read_r = gain_r_val;
600
601 if (mc->shift == 8) /* boost gain */
602 gain_r_val = (gain_r_val * 10) << mc->shift;
603 else { /* ADC/DAC gain */
604 if (adc_vol_flag && gain_r_val > mc->shift)
605 gain_r_val = (gain_r_val - mc->shift) * 75;
606 else
607 gain_r_val = (mc->shift - gain_r_val) * 75;
608 gain_r_val <<= 8;
609 gain_r_val /= 100;
610 if (!(adc_vol_flag && read_r > mc->shift)) {
611 gain_r_val = ~gain_r_val;
612 gain_r_val += 1;
613 }
614 gain_r_val &= 0xffff;
615 }
616
617 if (lvalue != gain_l_val || rvalue != gain_r_val)
618 changed = 1;
619 else
620 return 0;
621
622 for (i = 0; i < 3; i++) { /* retry 3 times at most */
623 /* Lch*/
624 regmap_write(rt711->mbq_regmap, mc->reg, gain_l_val);
625
626 /* Rch */
627 regmap_write(rt711->mbq_regmap, mc->rreg, gain_r_val);
628
629 regmap_read(rt711->mbq_regmap, mc->reg, &read_l);
630 regmap_read(rt711->mbq_regmap, mc->rreg, &read_r);
631 if (read_r == gain_r_val && read_l == gain_l_val)
632 break;
633 }
634
635 return i == 3 ? -EIO : changed;
636 }
637
rt711_sdca_set_gain_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)638 static int rt711_sdca_set_gain_get(struct snd_kcontrol *kcontrol,
639 struct snd_ctl_elem_value *ucontrol)
640 {
641 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
642 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
643 struct soc_mixer_control *mc =
644 (struct soc_mixer_control *)kcontrol->private_value;
645 unsigned int read_l, read_r, ctl_l = 0, ctl_r = 0;
646 unsigned int adc_vol_flag = 0, neg_flag = 0;
647
648 if (strstr(ucontrol->id.name, "FU1E Capture Volume") ||
649 strstr(ucontrol->id.name, "FU0F Capture Volume"))
650 adc_vol_flag = 1;
651
652 regmap_read(rt711->mbq_regmap, mc->reg, &read_l);
653 regmap_read(rt711->mbq_regmap, mc->rreg, &read_r);
654
655 /* 2's complement value to control value */
656 if (mc->shift == 8) /* boost gain */
657 ctl_l = (read_l >> mc->shift) / 10;
658 else { /* ADC/DAC gain */
659 ctl_l = read_l;
660 if (read_l & BIT(15)) {
661 ctl_l = 0xffff & ~(read_l - 1);
662 neg_flag = 1;
663 }
664 ctl_l *= 100;
665 ctl_l >>= 8;
666 if (adc_vol_flag) {
667 if (neg_flag)
668 ctl_l = mc->shift - (ctl_l / 75);
669 else
670 ctl_l = mc->shift + (ctl_l / 75);
671 } else
672 ctl_l = mc->max - (ctl_l / 75);
673 }
674
675 neg_flag = 0;
676 if (read_l != read_r) {
677 if (mc->shift == 8) /* boost gain */
678 ctl_r = (read_r >> mc->shift) / 10;
679 else { /* ADC/DAC gain */
680 ctl_r = read_r;
681 if (read_r & BIT(15)) {
682 ctl_r = 0xffff & ~(read_r - 1);
683 neg_flag = 1;
684 }
685 ctl_r *= 100;
686 ctl_r >>= 8;
687 if (adc_vol_flag) {
688 if (neg_flag)
689 ctl_r = mc->shift - (ctl_r / 75);
690 else
691 ctl_r = mc->shift + (ctl_r / 75);
692 } else
693 ctl_r = mc->max - (ctl_r / 75);
694 }
695 } else
696 ctl_r = ctl_l;
697
698 ucontrol->value.integer.value[0] = ctl_l;
699 ucontrol->value.integer.value[1] = ctl_r;
700
701 return 0;
702 }
703
rt711_sdca_set_fu0f_capture_ctl(struct rt711_sdca_priv * rt711)704 static int rt711_sdca_set_fu0f_capture_ctl(struct rt711_sdca_priv *rt711)
705 {
706 int err;
707 unsigned int ch_l, ch_r;
708
709 ch_l = (rt711->fu0f_dapm_mute || rt711->fu0f_mixer_l_mute) ? 0x01 : 0x00;
710 ch_r = (rt711->fu0f_dapm_mute || rt711->fu0f_mixer_r_mute) ? 0x01 : 0x00;
711
712 err = regmap_write(rt711->regmap,
713 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F,
714 RT711_SDCA_CTL_FU_MUTE, CH_L), ch_l);
715 if (err < 0)
716 return err;
717
718 err = regmap_write(rt711->regmap,
719 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F,
720 RT711_SDCA_CTL_FU_MUTE, CH_R), ch_r);
721 if (err < 0)
722 return err;
723
724 return 0;
725 }
726
rt711_sdca_set_fu1e_capture_ctl(struct rt711_sdca_priv * rt711)727 static int rt711_sdca_set_fu1e_capture_ctl(struct rt711_sdca_priv *rt711)
728 {
729 int err;
730 unsigned int ch_l, ch_r;
731
732 ch_l = (rt711->fu1e_dapm_mute || rt711->fu1e_mixer_l_mute) ? 0x01 : 0x00;
733 ch_r = (rt711->fu1e_dapm_mute || rt711->fu1e_mixer_r_mute) ? 0x01 : 0x00;
734
735 err = regmap_write(rt711->regmap,
736 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E,
737 RT711_SDCA_CTL_FU_MUTE, CH_L), ch_l);
738 if (err < 0)
739 return err;
740
741 err = regmap_write(rt711->regmap,
742 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E,
743 RT711_SDCA_CTL_FU_MUTE, CH_R), ch_r);
744 if (err < 0)
745 return err;
746
747 return 0;
748 }
749
rt711_sdca_fu1e_capture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)750 static int rt711_sdca_fu1e_capture_get(struct snd_kcontrol *kcontrol,
751 struct snd_ctl_elem_value *ucontrol)
752 {
753 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
754 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
755
756 ucontrol->value.integer.value[0] = !rt711->fu1e_mixer_l_mute;
757 ucontrol->value.integer.value[1] = !rt711->fu1e_mixer_r_mute;
758 return 0;
759 }
760
rt711_sdca_fu1e_capture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)761 static int rt711_sdca_fu1e_capture_put(struct snd_kcontrol *kcontrol,
762 struct snd_ctl_elem_value *ucontrol)
763 {
764 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
765 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
766 int err, changed = 0;
767
768 if (rt711->fu1e_mixer_l_mute != !ucontrol->value.integer.value[0] ||
769 rt711->fu1e_mixer_r_mute != !ucontrol->value.integer.value[1])
770 changed = 1;
771
772 rt711->fu1e_mixer_l_mute = !ucontrol->value.integer.value[0];
773 rt711->fu1e_mixer_r_mute = !ucontrol->value.integer.value[1];
774 err = rt711_sdca_set_fu1e_capture_ctl(rt711);
775 if (err < 0)
776 return err;
777
778 return changed;
779 }
780
rt711_sdca_fu0f_capture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)781 static int rt711_sdca_fu0f_capture_get(struct snd_kcontrol *kcontrol,
782 struct snd_ctl_elem_value *ucontrol)
783 {
784 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
785 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
786
787 ucontrol->value.integer.value[0] = !rt711->fu0f_mixer_l_mute;
788 ucontrol->value.integer.value[1] = !rt711->fu0f_mixer_r_mute;
789 return 0;
790 }
791
rt711_sdca_fu0f_capture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)792 static int rt711_sdca_fu0f_capture_put(struct snd_kcontrol *kcontrol,
793 struct snd_ctl_elem_value *ucontrol)
794 {
795 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
796 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
797 int err, changed = 0;
798
799 if (rt711->fu0f_mixer_l_mute != !ucontrol->value.integer.value[0] ||
800 rt711->fu0f_mixer_r_mute != !ucontrol->value.integer.value[1])
801 changed = 1;
802
803 rt711->fu0f_mixer_l_mute = !ucontrol->value.integer.value[0];
804 rt711->fu0f_mixer_r_mute = !ucontrol->value.integer.value[1];
805 err = rt711_sdca_set_fu0f_capture_ctl(rt711);
806 if (err < 0)
807 return err;
808
809 return changed;
810 }
811
rt711_sdca_ge_select_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)812 static int rt711_sdca_ge_select_get(struct snd_kcontrol *kcontrol,
813 struct snd_ctl_elem_value *ucontrol)
814 {
815 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
816 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
817 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
818 unsigned int val, item;
819
820 val = (rt711->ge_mode_override >> e->shift_l) & e->mask;
821 item = snd_soc_enum_val_to_item(e, val);
822 ucontrol->value.enumerated.item[0] = item;
823 return 0;
824 }
825
rt711_sdca_ge_select_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)826 static int rt711_sdca_ge_select_put(struct snd_kcontrol *kcontrol,
827 struct snd_ctl_elem_value *ucontrol)
828 {
829 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
830 unsigned int *item = ucontrol->value.enumerated.item;
831 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
832 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
833 unsigned int val, change = 0;
834
835 if (item[0] >= e->items)
836 return -EINVAL;
837
838 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
839 if (rt711->ge_mode_override != val) {
840 rt711->ge_mode_override = val;
841 change = 1;
842 }
843
844 return change;
845 }
846
847 static const char * const rt711_sdca_ge_select[] = {
848 "Auto",
849 "Headphone",
850 "Headset",
851 };
852
853 static int rt711_sdca_ge_select_values[] = {
854 0,
855 3,
856 5,
857 };
858
859 static SOC_VALUE_ENUM_SINGLE_DECL(rt711_sdca_ge_mode_enum, SND_SOC_NOPM,
860 0, 0x7, rt711_sdca_ge_select, rt711_sdca_ge_select_values);
861
862 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
863 static const DECLARE_TLV_DB_SCALE(in_vol_tlv, -1725, 75, 0);
864 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, 0, 1000, 0);
865
866 static const struct snd_kcontrol_new rt711_sdca_snd_controls[] = {
867 SOC_DOUBLE_R_EXT_TLV("FU05 Playback Volume",
868 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, RT711_SDCA_CTL_FU_VOLUME, CH_L),
869 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05, RT711_SDCA_CTL_FU_VOLUME, CH_R),
870 0x57, 0x57, 0,
871 rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, out_vol_tlv),
872 SOC_DOUBLE_EXT("FU1E Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0,
873 rt711_sdca_fu1e_capture_get, rt711_sdca_fu1e_capture_put),
874 SOC_DOUBLE_EXT("FU0F Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0,
875 rt711_sdca_fu0f_capture_get, rt711_sdca_fu0f_capture_put),
876 SOC_DOUBLE_R_EXT_TLV("FU1E Capture Volume",
877 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, RT711_SDCA_CTL_FU_VOLUME, CH_L),
878 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_USER_FU1E, RT711_SDCA_CTL_FU_VOLUME, CH_R),
879 0x17, 0x3f, 0,
880 rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, in_vol_tlv),
881 SOC_DOUBLE_R_EXT_TLV("FU0F Capture Volume",
882 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, RT711_SDCA_CTL_FU_VOLUME, CH_L),
883 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU0F, RT711_SDCA_CTL_FU_VOLUME, CH_R),
884 0x17, 0x3f, 0,
885 rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, in_vol_tlv),
886 SOC_DOUBLE_R_EXT_TLV("FU44 Gain Volume",
887 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PLATFORM_FU44, RT711_SDCA_CTL_FU_CH_GAIN, CH_L),
888 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PLATFORM_FU44, RT711_SDCA_CTL_FU_CH_GAIN, CH_R),
889 8, 3, 0,
890 rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, mic_vol_tlv),
891 SOC_DOUBLE_R_EXT_TLV("FU15 Gain Volume",
892 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PLATFORM_FU15, RT711_SDCA_CTL_FU_CH_GAIN, CH_L),
893 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PLATFORM_FU15, RT711_SDCA_CTL_FU_CH_GAIN, CH_R),
894 8, 3, 0,
895 rt711_sdca_set_gain_get, rt711_sdca_set_gain_put, mic_vol_tlv),
896 SOC_ENUM_EXT("GE49 Selected Mode", rt711_sdca_ge_mode_enum,
897 rt711_sdca_ge_select_get, rt711_sdca_ge_select_put),
898 };
899
rt711_sdca_mux_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)900 static int rt711_sdca_mux_get(struct snd_kcontrol *kcontrol,
901 struct snd_ctl_elem_value *ucontrol)
902 {
903 struct snd_soc_component *component =
904 snd_soc_dapm_kcontrol_component(kcontrol);
905 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
906 unsigned int val = 0, mask_sft;
907
908 if (strstr(ucontrol->id.name, "ADC 22 Mux"))
909 mask_sft = 10;
910 else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
911 mask_sft = 13;
912 else
913 return -EINVAL;
914
915 rt711_sdca_index_read(rt711, RT711_VENDOR_HDA_CTL,
916 RT711_HDA_LEGACY_MUX_CTL1, &val);
917
918 ucontrol->value.enumerated.item[0] = (val >> mask_sft) & 0x7;
919
920 return 0;
921 }
922
rt711_sdca_mux_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)923 static int rt711_sdca_mux_put(struct snd_kcontrol *kcontrol,
924 struct snd_ctl_elem_value *ucontrol)
925 {
926 struct snd_soc_component *component =
927 snd_soc_dapm_kcontrol_component(kcontrol);
928 struct snd_soc_dapm_context *dapm =
929 snd_soc_dapm_kcontrol_dapm(kcontrol);
930 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
931 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
932 unsigned int *item = ucontrol->value.enumerated.item;
933 unsigned int val, val2 = 0, change, mask_sft;
934
935 if (item[0] >= e->items)
936 return -EINVAL;
937
938 if (strstr(ucontrol->id.name, "ADC 22 Mux"))
939 mask_sft = 10;
940 else if (strstr(ucontrol->id.name, "ADC 23 Mux"))
941 mask_sft = 13;
942 else
943 return -EINVAL;
944
945 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
946
947 rt711_sdca_index_read(rt711, RT711_VENDOR_HDA_CTL,
948 RT711_HDA_LEGACY_MUX_CTL1, &val2);
949 val2 = (val2 >> mask_sft) & 0x7;
950
951 if (val == val2)
952 change = 0;
953 else
954 change = 1;
955
956 if (change)
957 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
958 RT711_HDA_LEGACY_MUX_CTL1, 0x7 << mask_sft,
959 val << mask_sft);
960
961 snd_soc_dapm_mux_update_power(dapm, kcontrol,
962 item[0], e, NULL);
963
964 return change;
965 }
966
967 static const char * const adc_mux_text[] = {
968 "MIC2",
969 "LINE1",
970 "LINE2",
971 "DMIC",
972 };
973
974 static SOC_ENUM_SINGLE_DECL(
975 rt711_adc22_enum, SND_SOC_NOPM, 0, adc_mux_text);
976
977 static SOC_ENUM_SINGLE_DECL(
978 rt711_adc23_enum, SND_SOC_NOPM, 0, adc_mux_text);
979
980 static const struct snd_kcontrol_new rt711_sdca_adc22_mux =
981 SOC_DAPM_ENUM_EXT("ADC 22 Mux", rt711_adc22_enum,
982 rt711_sdca_mux_get, rt711_sdca_mux_put);
983
984 static const struct snd_kcontrol_new rt711_sdca_adc23_mux =
985 SOC_DAPM_ENUM_EXT("ADC 23 Mux", rt711_adc23_enum,
986 rt711_sdca_mux_get, rt711_sdca_mux_put);
987
rt711_sdca_fu05_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)988 static int rt711_sdca_fu05_event(struct snd_soc_dapm_widget *w,
989 struct snd_kcontrol *kcontrol, int event)
990 {
991 struct snd_soc_component *component =
992 snd_soc_dapm_to_component(w->dapm);
993 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
994 unsigned char unmute = 0x0, mute = 0x1;
995
996 switch (event) {
997 case SND_SOC_DAPM_POST_PMU:
998 regmap_write(rt711->regmap,
999 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
1000 RT711_SDCA_CTL_FU_MUTE, CH_L),
1001 unmute);
1002 regmap_write(rt711->regmap,
1003 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
1004 RT711_SDCA_CTL_FU_MUTE, CH_R),
1005 unmute);
1006 break;
1007 case SND_SOC_DAPM_PRE_PMD:
1008 regmap_write(rt711->regmap,
1009 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
1010 RT711_SDCA_CTL_FU_MUTE, CH_L),
1011 mute);
1012 regmap_write(rt711->regmap,
1013 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_USER_FU05,
1014 RT711_SDCA_CTL_FU_MUTE, CH_R),
1015 mute);
1016 break;
1017 }
1018 return 0;
1019 }
1020
rt711_sdca_fu0f_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1021 static int rt711_sdca_fu0f_event(struct snd_soc_dapm_widget *w,
1022 struct snd_kcontrol *kcontrol, int event)
1023 {
1024 struct snd_soc_component *component =
1025 snd_soc_dapm_to_component(w->dapm);
1026 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1027
1028 switch (event) {
1029 case SND_SOC_DAPM_POST_PMU:
1030 rt711->fu0f_dapm_mute = false;
1031 rt711_sdca_set_fu0f_capture_ctl(rt711);
1032 break;
1033 case SND_SOC_DAPM_PRE_PMD:
1034 rt711->fu0f_dapm_mute = true;
1035 rt711_sdca_set_fu0f_capture_ctl(rt711);
1036 break;
1037 }
1038 return 0;
1039 }
1040
rt711_sdca_fu1e_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1041 static int rt711_sdca_fu1e_event(struct snd_soc_dapm_widget *w,
1042 struct snd_kcontrol *kcontrol, int event)
1043 {
1044 struct snd_soc_component *component =
1045 snd_soc_dapm_to_component(w->dapm);
1046 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1047
1048 switch (event) {
1049 case SND_SOC_DAPM_POST_PMU:
1050 rt711->fu1e_dapm_mute = false;
1051 rt711_sdca_set_fu1e_capture_ctl(rt711);
1052 break;
1053 case SND_SOC_DAPM_PRE_PMD:
1054 rt711->fu1e_dapm_mute = true;
1055 rt711_sdca_set_fu1e_capture_ctl(rt711);
1056 break;
1057 }
1058 return 0;
1059 }
1060
rt711_sdca_pde28_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1061 static int rt711_sdca_pde28_event(struct snd_soc_dapm_widget *w,
1062 struct snd_kcontrol *kcontrol, int event)
1063 {
1064 struct snd_soc_component *component =
1065 snd_soc_dapm_to_component(w->dapm);
1066 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1067 unsigned char ps0 = 0x0, ps3 = 0x3;
1068
1069 switch (event) {
1070 case SND_SOC_DAPM_POST_PMU:
1071 regmap_write(rt711->regmap,
1072 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE28,
1073 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1074 ps0);
1075 break;
1076 case SND_SOC_DAPM_PRE_PMD:
1077 regmap_write(rt711->regmap,
1078 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE28,
1079 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1080 ps3);
1081 break;
1082 }
1083 return 0;
1084 }
1085
rt711_sdca_pde29_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1086 static int rt711_sdca_pde29_event(struct snd_soc_dapm_widget *w,
1087 struct snd_kcontrol *kcontrol, int event)
1088 {
1089 struct snd_soc_component *component =
1090 snd_soc_dapm_to_component(w->dapm);
1091 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1092 unsigned char ps0 = 0x0, ps3 = 0x3;
1093
1094 switch (event) {
1095 case SND_SOC_DAPM_POST_PMU:
1096 regmap_write(rt711->regmap,
1097 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE29,
1098 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1099 ps0);
1100 break;
1101 case SND_SOC_DAPM_PRE_PMD:
1102 regmap_write(rt711->regmap,
1103 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDE29,
1104 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1105 ps3);
1106 break;
1107 }
1108 return 0;
1109 }
1110
rt711_sdca_pde2a_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1111 static int rt711_sdca_pde2a_event(struct snd_soc_dapm_widget *w,
1112 struct snd_kcontrol *kcontrol, int event)
1113 {
1114 struct snd_soc_component *component =
1115 snd_soc_dapm_to_component(w->dapm);
1116 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1117 unsigned char ps0 = 0x0, ps3 = 0x3;
1118
1119 switch (event) {
1120 case SND_SOC_DAPM_POST_PMU:
1121 regmap_write(rt711->regmap,
1122 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PDE2A,
1123 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1124 ps0);
1125 break;
1126 case SND_SOC_DAPM_PRE_PMD:
1127 regmap_write(rt711->regmap,
1128 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_PDE2A,
1129 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1130 ps3);
1131 break;
1132 }
1133 return 0;
1134 }
1135
rt711_sdca_line1_power_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1136 static int rt711_sdca_line1_power_event(struct snd_soc_dapm_widget *w,
1137 struct snd_kcontrol *kcontrol, int event)
1138 {
1139 struct snd_soc_component *component =
1140 snd_soc_dapm_to_component(w->dapm);
1141 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1142 static unsigned int sel_mode = 0xffff;
1143
1144 switch (event) {
1145 case SND_SOC_DAPM_POST_PMU:
1146 regmap_read(rt711->regmap,
1147 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49,
1148 RT711_SDCA_CTL_SELECTED_MODE, 0),
1149 &sel_mode);
1150 regmap_write(rt711->regmap,
1151 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE1,
1152 RT711_SDCA_CTL_VENDOR_DEF, 0),
1153 0x1);
1154 regmap_write(rt711->regmap,
1155 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49,
1156 RT711_SDCA_CTL_SELECTED_MODE, 0),
1157 0x7);
1158 break;
1159 case SND_SOC_DAPM_PRE_PMD:
1160 regmap_write(rt711->regmap,
1161 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE1,
1162 RT711_SDCA_CTL_VENDOR_DEF, 0),
1163 0x0);
1164 if (sel_mode != 0xffff)
1165 regmap_write(rt711->regmap,
1166 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_GE49,
1167 RT711_SDCA_CTL_SELECTED_MODE, 0),
1168 sel_mode);
1169 break;
1170 }
1171
1172 return 0;
1173 }
1174
rt711_sdca_line2_power_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1175 static int rt711_sdca_line2_power_event(struct snd_soc_dapm_widget *w,
1176 struct snd_kcontrol *kcontrol, int event)
1177 {
1178 struct snd_soc_component *component =
1179 snd_soc_dapm_to_component(w->dapm);
1180 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1181 unsigned char ps0 = 0x0, ps3 = 0x3;
1182
1183 switch (event) {
1184 case SND_SOC_DAPM_POST_PMU:
1185 regmap_write(rt711->regmap,
1186 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDELINE2,
1187 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1188 ps0);
1189 regmap_write(rt711->regmap,
1190 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE2,
1191 RT711_SDCA_CTL_VENDOR_DEF, 0),
1192 0x1);
1193 break;
1194 case SND_SOC_DAPM_PRE_PMD:
1195 regmap_write(rt711->regmap,
1196 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_LINE2,
1197 RT711_SDCA_CTL_VENDOR_DEF, 0),
1198 0x0);
1199 regmap_write(rt711->regmap,
1200 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_PDELINE2,
1201 RT711_SDCA_CTL_REQ_POWER_STATE, 0),
1202 ps3);
1203 break;
1204 }
1205
1206 return 0;
1207 }
1208
1209 static const struct snd_soc_dapm_widget rt711_sdca_dapm_widgets[] = {
1210 SND_SOC_DAPM_OUTPUT("HP"),
1211 SND_SOC_DAPM_INPUT("MIC2"),
1212 SND_SOC_DAPM_INPUT("DMIC1"),
1213 SND_SOC_DAPM_INPUT("DMIC2"),
1214 SND_SOC_DAPM_INPUT("LINE1"),
1215 SND_SOC_DAPM_INPUT("LINE2"),
1216
1217 SND_SOC_DAPM_PGA_E("LINE1 Power", SND_SOC_NOPM,
1218 0, 0, NULL, 0, rt711_sdca_line1_power_event,
1219 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1220 SND_SOC_DAPM_PGA_E("LINE2 Power", SND_SOC_NOPM,
1221 0, 0, NULL, 0, rt711_sdca_line2_power_event,
1222 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1223
1224 SND_SOC_DAPM_SUPPLY("PDE 28", SND_SOC_NOPM, 0, 0,
1225 rt711_sdca_pde28_event,
1226 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1227 SND_SOC_DAPM_SUPPLY("PDE 29", SND_SOC_NOPM, 0, 0,
1228 rt711_sdca_pde29_event,
1229 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1230 SND_SOC_DAPM_SUPPLY("PDE 2A", SND_SOC_NOPM, 0, 0,
1231 rt711_sdca_pde2a_event,
1232 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1233
1234 SND_SOC_DAPM_DAC_E("FU 05", NULL, SND_SOC_NOPM, 0, 0,
1235 rt711_sdca_fu05_event,
1236 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1237 SND_SOC_DAPM_ADC_E("FU 0F", NULL, SND_SOC_NOPM, 0, 0,
1238 rt711_sdca_fu0f_event,
1239 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1240 SND_SOC_DAPM_ADC_E("FU 1E", NULL, SND_SOC_NOPM, 0, 0,
1241 rt711_sdca_fu1e_event,
1242 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1243 SND_SOC_DAPM_MUX("ADC 22 Mux", SND_SOC_NOPM, 0, 0,
1244 &rt711_sdca_adc22_mux),
1245 SND_SOC_DAPM_MUX("ADC 23 Mux", SND_SOC_NOPM, 0, 0,
1246 &rt711_sdca_adc23_mux),
1247
1248 SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Playback", 0, SND_SOC_NOPM, 0, 0),
1249 SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Capture", 0, SND_SOC_NOPM, 0, 0),
1250 SND_SOC_DAPM_AIF_OUT("DP4TX", "DP4 Capture", 0, SND_SOC_NOPM, 0, 0),
1251 };
1252
1253 static const struct snd_soc_dapm_route rt711_sdca_audio_map[] = {
1254 {"FU 05", NULL, "DP3RX"},
1255 {"DP2TX", NULL, "FU 0F"},
1256 {"DP4TX", NULL, "FU 1E"},
1257
1258 {"LINE1 Power", NULL, "LINE1"},
1259 {"LINE2 Power", NULL, "LINE2"},
1260 {"HP", NULL, "PDE 28"},
1261 {"FU 0F", NULL, "PDE 29"},
1262 {"FU 1E", NULL, "PDE 2A"},
1263
1264 {"FU 0F", NULL, "ADC 22 Mux"},
1265 {"FU 1E", NULL, "ADC 23 Mux"},
1266 {"ADC 22 Mux", "DMIC", "DMIC1"},
1267 {"ADC 22 Mux", "LINE1", "LINE1 Power"},
1268 {"ADC 22 Mux", "LINE2", "LINE2 Power"},
1269 {"ADC 22 Mux", "MIC2", "MIC2"},
1270 {"ADC 23 Mux", "DMIC", "DMIC2"},
1271 {"ADC 23 Mux", "LINE1", "LINE1 Power"},
1272 {"ADC 23 Mux", "LINE2", "LINE2 Power"},
1273 {"ADC 23 Mux", "MIC2", "MIC2"},
1274
1275 {"HP", NULL, "FU 05"},
1276 };
1277
rt711_sdca_parse_dt(struct rt711_sdca_priv * rt711,struct device * dev)1278 static int rt711_sdca_parse_dt(struct rt711_sdca_priv *rt711, struct device *dev)
1279 {
1280 device_property_read_u32(dev, "realtek,jd-src", &rt711->jd_src);
1281
1282 return 0;
1283 }
1284
rt711_sdca_probe(struct snd_soc_component * component)1285 static int rt711_sdca_probe(struct snd_soc_component *component)
1286 {
1287 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1288 int ret;
1289
1290 rt711_sdca_parse_dt(rt711, &rt711->slave->dev);
1291 rt711->component = component;
1292
1293 if (!rt711->first_hw_init)
1294 return 0;
1295
1296 ret = pm_runtime_resume(component->dev);
1297 if (ret < 0 && ret != -EACCES)
1298 return ret;
1299
1300 return 0;
1301 }
1302
1303 static const struct snd_soc_component_driver soc_sdca_dev_rt711 = {
1304 .probe = rt711_sdca_probe,
1305 .controls = rt711_sdca_snd_controls,
1306 .num_controls = ARRAY_SIZE(rt711_sdca_snd_controls),
1307 .dapm_widgets = rt711_sdca_dapm_widgets,
1308 .num_dapm_widgets = ARRAY_SIZE(rt711_sdca_dapm_widgets),
1309 .dapm_routes = rt711_sdca_audio_map,
1310 .num_dapm_routes = ARRAY_SIZE(rt711_sdca_audio_map),
1311 .set_jack = rt711_sdca_set_jack_detect,
1312 .endianness = 1,
1313 };
1314
rt711_sdca_set_sdw_stream(struct snd_soc_dai * dai,void * sdw_stream,int direction)1315 static int rt711_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
1316 int direction)
1317 {
1318 snd_soc_dai_dma_data_set(dai, direction, sdw_stream);
1319
1320 return 0;
1321 }
1322
rt711_sdca_shutdown(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)1323 static void rt711_sdca_shutdown(struct snd_pcm_substream *substream,
1324 struct snd_soc_dai *dai)
1325 {
1326 snd_soc_dai_set_dma_data(dai, substream, NULL);
1327 }
1328
rt711_sdca_pcm_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)1329 static int rt711_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
1330 struct snd_pcm_hw_params *params,
1331 struct snd_soc_dai *dai)
1332 {
1333 struct snd_soc_component *component = dai->component;
1334 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1335 struct sdw_stream_config stream_config = {0};
1336 struct sdw_port_config port_config = {0};
1337 struct sdw_stream_runtime *sdw_stream;
1338 int retval;
1339 unsigned int sampling_rate;
1340
1341 dev_dbg(dai->dev, "%s %s", __func__, dai->name);
1342 sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
1343
1344 if (!sdw_stream)
1345 return -EINVAL;
1346
1347 if (!rt711->slave)
1348 return -EINVAL;
1349
1350 /* SoundWire specific configuration */
1351 snd_sdw_params_to_config(substream, params, &stream_config, &port_config);
1352
1353 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1354 port_config.num = 3;
1355 } else {
1356 if (dai->id == RT711_AIF1)
1357 port_config.num = 2;
1358 else if (dai->id == RT711_AIF2)
1359 port_config.num = 4;
1360 else
1361 return -EINVAL;
1362 }
1363
1364 retval = sdw_stream_add_slave(rt711->slave, &stream_config,
1365 &port_config, 1, sdw_stream);
1366 if (retval) {
1367 dev_err(dai->dev, "%s: Unable to configure port\n", __func__);
1368 return retval;
1369 }
1370
1371 if (params_channels(params) > 16) {
1372 dev_err(component->dev, "%s: Unsupported channels %d\n",
1373 __func__, params_channels(params));
1374 return -EINVAL;
1375 }
1376
1377 /* sampling rate configuration */
1378 switch (params_rate(params)) {
1379 case 44100:
1380 sampling_rate = RT711_SDCA_RATE_44100HZ;
1381 break;
1382 case 48000:
1383 sampling_rate = RT711_SDCA_RATE_48000HZ;
1384 break;
1385 case 96000:
1386 sampling_rate = RT711_SDCA_RATE_96000HZ;
1387 break;
1388 case 192000:
1389 sampling_rate = RT711_SDCA_RATE_192000HZ;
1390 break;
1391 default:
1392 dev_err(component->dev, "%s: Rate %d is not supported\n",
1393 __func__, params_rate(params));
1394 return -EINVAL;
1395 }
1396
1397 /* set sampling frequency */
1398 regmap_write(rt711->regmap,
1399 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_CS01, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1400 sampling_rate);
1401 regmap_write(rt711->regmap,
1402 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_CS11, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1403 sampling_rate);
1404 regmap_write(rt711->regmap,
1405 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT711_SDCA_ENT_CS1F, RT711_SDCA_CTL_SAMPLE_FREQ_INDEX, 0),
1406 sampling_rate);
1407
1408 return 0;
1409 }
1410
rt711_sdca_pcm_hw_free(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)1411 static int rt711_sdca_pcm_hw_free(struct snd_pcm_substream *substream,
1412 struct snd_soc_dai *dai)
1413 {
1414 struct snd_soc_component *component = dai->component;
1415 struct rt711_sdca_priv *rt711 = snd_soc_component_get_drvdata(component);
1416 struct sdw_stream_runtime *sdw_stream =
1417 snd_soc_dai_get_dma_data(dai, substream);
1418
1419 if (!rt711->slave)
1420 return -EINVAL;
1421
1422 sdw_stream_remove_slave(rt711->slave, sdw_stream);
1423 return 0;
1424 }
1425
1426 #define RT711_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | SNDRV_PCM_RATE_96000 | \
1427 SNDRV_PCM_RATE_192000)
1428 #define RT711_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
1429 SNDRV_PCM_FMTBIT_S24_LE)
1430
1431 static const struct snd_soc_dai_ops rt711_sdca_ops = {
1432 .hw_params = rt711_sdca_pcm_hw_params,
1433 .hw_free = rt711_sdca_pcm_hw_free,
1434 .set_stream = rt711_sdca_set_sdw_stream,
1435 .shutdown = rt711_sdca_shutdown,
1436 };
1437
1438 static struct snd_soc_dai_driver rt711_sdca_dai[] = {
1439 {
1440 .name = "rt711-sdca-aif1",
1441 .id = RT711_AIF1,
1442 .playback = {
1443 .stream_name = "DP3 Playback",
1444 .channels_min = 1,
1445 .channels_max = 2,
1446 .rates = RT711_STEREO_RATES,
1447 .formats = RT711_FORMATS,
1448 },
1449 .capture = {
1450 .stream_name = "DP2 Capture",
1451 .channels_min = 1,
1452 .channels_max = 2,
1453 .rates = RT711_STEREO_RATES,
1454 .formats = RT711_FORMATS,
1455 },
1456 .ops = &rt711_sdca_ops,
1457 },
1458 {
1459 .name = "rt711-sdca-aif2",
1460 .id = RT711_AIF2,
1461 .capture = {
1462 .stream_name = "DP4 Capture",
1463 .channels_min = 1,
1464 .channels_max = 2,
1465 .rates = RT711_STEREO_RATES,
1466 .formats = RT711_FORMATS,
1467 },
1468 .ops = &rt711_sdca_ops,
1469 }
1470 };
1471
rt711_sdca_init(struct device * dev,struct regmap * regmap,struct regmap * mbq_regmap,struct sdw_slave * slave)1472 int rt711_sdca_init(struct device *dev, struct regmap *regmap,
1473 struct regmap *mbq_regmap, struct sdw_slave *slave)
1474 {
1475 struct rt711_sdca_priv *rt711;
1476 int ret;
1477
1478 rt711 = devm_kzalloc(dev, sizeof(*rt711), GFP_KERNEL);
1479 if (!rt711)
1480 return -ENOMEM;
1481
1482 dev_set_drvdata(dev, rt711);
1483 rt711->slave = slave;
1484 rt711->regmap = regmap;
1485 rt711->mbq_regmap = mbq_regmap;
1486
1487 regcache_cache_only(rt711->regmap, true);
1488 regcache_cache_only(rt711->mbq_regmap, true);
1489
1490 mutex_init(&rt711->calibrate_mutex);
1491 mutex_init(&rt711->disable_irq_lock);
1492
1493 INIT_DELAYED_WORK(&rt711->jack_detect_work, rt711_sdca_jack_detect_handler);
1494 INIT_DELAYED_WORK(&rt711->jack_btn_check_work, rt711_sdca_btn_check_handler);
1495
1496 /*
1497 * Mark hw_init to false
1498 * HW init will be performed when device reports present
1499 */
1500 rt711->hw_init = false;
1501 rt711->first_hw_init = false;
1502 rt711->fu0f_dapm_mute = true;
1503 rt711->fu1e_dapm_mute = true;
1504 rt711->fu0f_mixer_l_mute = rt711->fu0f_mixer_r_mute = true;
1505 rt711->fu1e_mixer_l_mute = rt711->fu1e_mixer_r_mute = true;
1506
1507 /* JD source uses JD2 in default */
1508 rt711->jd_src = RT711_JD2;
1509
1510 ret = devm_snd_soc_register_component(dev,
1511 &soc_sdca_dev_rt711,
1512 rt711_sdca_dai,
1513 ARRAY_SIZE(rt711_sdca_dai));
1514
1515 if (ret < 0)
1516 return ret;
1517
1518 /* set autosuspend parameters */
1519 pm_runtime_set_autosuspend_delay(dev, 3000);
1520 pm_runtime_use_autosuspend(dev);
1521
1522 /* make sure the device does not suspend immediately */
1523 pm_runtime_mark_last_busy(dev);
1524
1525 pm_runtime_enable(dev);
1526
1527 /* important note: the device is NOT tagged as 'active' and will remain
1528 * 'suspended' until the hardware is enumerated/initialized. This is required
1529 * to make sure the ASoC framework use of pm_runtime_get_sync() does not silently
1530 * fail with -EACCESS because of race conditions between card creation and enumeration
1531 */
1532
1533 dev_dbg(dev, "%s\n", __func__);
1534
1535 return 0;
1536 }
1537
rt711_sdca_vd0_io_init(struct rt711_sdca_priv * rt711)1538 static void rt711_sdca_vd0_io_init(struct rt711_sdca_priv *rt711)
1539 {
1540 rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1541 RT711_GPIO_TEST_MODE_CTL2, 0x0e00);
1542 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
1543 RT711_HDA_LEGACY_GPIO_CTL, 0x0008);
1544
1545 regmap_write(rt711->regmap, 0x2f5a, 0x01);
1546
1547 rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1548 RT711_ADC27_VOL_SET, 0x8728);
1549
1550 rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1551 RT711_COMBO_JACK_AUTO_CTL3, 0xa472);
1552
1553 regmap_write(rt711->regmap, 0x2f50, 0x02);
1554
1555 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_ANALOG_CTL,
1556 RT711_MISC_POWER_CTL4, 0x6000, 0x6000);
1557
1558 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
1559 RT711_COMBO_JACK_AUTO_CTL3, 0x000c, 0x000c);
1560
1561 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
1562 RT711_HDA_LEGACY_CONFIG_CTL, 0x0000);
1563
1564 rt711_sdca_index_write(rt711, RT711_VENDOR_VAD,
1565 RT711_VAD_SRAM_CTL1, 0x0050);
1566 }
1567
rt711_sdca_vd1_io_init(struct rt711_sdca_priv * rt711)1568 static void rt711_sdca_vd1_io_init(struct rt711_sdca_priv *rt711)
1569 {
1570 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
1571 RT711_HDA_LEGACY_UNSOLICITED_CTL, 0x0300, 0x0000);
1572
1573 rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1574 RT711_COMBO_JACK_AUTO_CTL3, 0xa43e);
1575
1576 regmap_write(rt711->regmap, 0x2f5a, 0x05);
1577
1578 rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1579 RT711_JD_CTRL6, 0x0500);
1580
1581 rt711_sdca_index_write(rt711, RT711_VENDOR_REG,
1582 RT711_DMIC_CTL1, 0x6173);
1583
1584 rt711_sdca_index_write(rt711, RT711_VENDOR_HDA_CTL,
1585 RT711_HDA_LEGACY_CONFIG_CTL, 0x0000);
1586
1587 rt711_sdca_index_write(rt711, RT711_VENDOR_VAD,
1588 RT711_VAD_SRAM_CTL1, 0x0050);
1589 }
1590
rt711_sdca_io_init(struct device * dev,struct sdw_slave * slave)1591 int rt711_sdca_io_init(struct device *dev, struct sdw_slave *slave)
1592 {
1593 struct rt711_sdca_priv *rt711 = dev_get_drvdata(dev);
1594 int ret = 0;
1595 unsigned int val;
1596
1597 rt711->disable_irq = false;
1598
1599 if (rt711->hw_init)
1600 return 0;
1601
1602 regcache_cache_only(rt711->regmap, false);
1603 regcache_cache_only(rt711->mbq_regmap, false);
1604
1605 if (rt711->first_hw_init) {
1606 regcache_cache_bypass(rt711->regmap, true);
1607 regcache_cache_bypass(rt711->mbq_regmap, true);
1608 } else {
1609 /*
1610 * PM runtime status is marked as 'active' only when a Slave reports as Attached
1611 */
1612
1613 /* update count of parent 'active' children */
1614 pm_runtime_set_active(&slave->dev);
1615 }
1616
1617 pm_runtime_get_noresume(&slave->dev);
1618
1619 rt711_sdca_reset(rt711);
1620
1621 rt711_sdca_index_read(rt711, RT711_VENDOR_REG, RT711_JD_PRODUCT_NUM, &val);
1622 rt711->hw_ver = val & 0xf;
1623
1624 if (rt711->hw_ver == RT711_VER_VD0)
1625 rt711_sdca_vd0_io_init(rt711);
1626 else
1627 rt711_sdca_vd1_io_init(rt711);
1628
1629 /* DP4 mux select from 08_filter_Out_pri */
1630 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_REG,
1631 RT711_FILTER_SRC_SEL, 0x1800, 0x0800);
1632
1633 /* ge_exclusive_inbox_en disable */
1634 rt711_sdca_index_update_bits(rt711, RT711_VENDOR_HDA_CTL,
1635 RT711_PUSH_BTN_INT_CTL0, 0x20, 0x00);
1636
1637 /* calibration */
1638 ret = rt711_sdca_calibration(rt711);
1639 if (ret < 0)
1640 dev_err(dev, "%s, calibration failed!\n", __func__);
1641
1642 /* HP output enable */
1643 regmap_write(rt711->regmap,
1644 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT711_SDCA_ENT_OT1, RT711_SDCA_CTL_VENDOR_DEF, 0), 0x4);
1645
1646 /*
1647 * if set_jack callback occurred early than io_init,
1648 * we set up the jack detection function now
1649 */
1650 if (rt711->hs_jack)
1651 rt711_sdca_jack_init(rt711);
1652
1653 if (rt711->first_hw_init) {
1654 regcache_cache_bypass(rt711->regmap, false);
1655 regcache_mark_dirty(rt711->regmap);
1656 regcache_cache_bypass(rt711->mbq_regmap, false);
1657 regcache_mark_dirty(rt711->mbq_regmap);
1658 } else
1659 rt711->first_hw_init = true;
1660
1661 /* Mark Slave initialization complete */
1662 rt711->hw_init = true;
1663
1664 pm_runtime_put_autosuspend(&slave->dev);
1665
1666 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
1667 return 0;
1668 }
1669
1670 MODULE_DESCRIPTION("ASoC RT711 SDCA SDW driver");
1671 MODULE_AUTHOR("Shuming Fan <shumingf@realtek.com>");
1672 MODULE_LICENSE("GPL");
1673