1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // rt721-sdca.c -- rt721 SDCA ALSA SoC audio driver
4 //
5 // Copyright(c) 2024 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 <sound/pcm.h>
19 #include <linux/pm_runtime.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
26 #include "rt721-sdca.h"
27 #include "rt-sdw-common.h"
28
rt721_sdca_jack_detect_handler(struct work_struct * work)29 static void rt721_sdca_jack_detect_handler(struct work_struct *work)
30 {
31 struct rt721_sdca_priv *rt721 =
32 container_of(work, struct rt721_sdca_priv, jack_detect_work.work);
33 int btn_type = 0;
34
35 if (!rt721->hs_jack)
36 return;
37
38 if (!rt721->component->card || !rt721->component->card->instantiated)
39 return;
40
41 /* SDW_SCP_SDCA_INT_SDCA_6 is used for jack detection */
42 if (rt721->scp_sdca_stat1 & SDW_SCP_SDCA_INT_SDCA_0) {
43 rt721->jack_type = rt_sdca_headset_detect(rt721->regmap,
44 RT721_SDCA_ENT_GE49);
45 if (rt721->jack_type < 0)
46 return;
47 }
48
49 /* SDW_SCP_SDCA_INT_SDCA_8 is used for button detection */
50 if (rt721->scp_sdca_stat2 & SDW_SCP_SDCA_INT_SDCA_8)
51 btn_type = rt_sdca_button_detect(rt721->regmap,
52 RT721_SDCA_ENT_HID01, RT721_BUF_ADDR_HID1,
53 RT721_SDCA_HID_ID);
54
55 if (rt721->jack_type == 0)
56 btn_type = 0;
57
58 dev_dbg(&rt721->slave->dev,
59 "in %s, jack_type=%d\n", __func__, rt721->jack_type);
60 dev_dbg(&rt721->slave->dev,
61 "in %s, btn_type=0x%x\n", __func__, btn_type);
62 dev_dbg(&rt721->slave->dev,
63 "in %s, scp_sdca_stat1=0x%x, scp_sdca_stat2=0x%x\n", __func__,
64 rt721->scp_sdca_stat1, rt721->scp_sdca_stat2);
65
66 snd_soc_jack_report(rt721->hs_jack, rt721->jack_type | btn_type,
67 SND_JACK_HEADSET |
68 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
69 SND_JACK_BTN_2 | SND_JACK_BTN_3);
70
71 if (btn_type) {
72 /* button released */
73 snd_soc_jack_report(rt721->hs_jack, rt721->jack_type,
74 SND_JACK_HEADSET |
75 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
76 SND_JACK_BTN_2 | SND_JACK_BTN_3);
77
78 mod_delayed_work(system_power_efficient_wq,
79 &rt721->jack_btn_check_work, msecs_to_jiffies(200));
80 }
81 }
82
rt721_sdca_btn_check_handler(struct work_struct * work)83 static void rt721_sdca_btn_check_handler(struct work_struct *work)
84 {
85 struct rt721_sdca_priv *rt721 =
86 container_of(work, struct rt721_sdca_priv, jack_btn_check_work.work);
87 int btn_type = 0, ret, idx;
88 unsigned int det_mode, offset, val;
89 unsigned char buf[3];
90
91 ret = regmap_read(rt721->regmap,
92 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_GE49,
93 RT721_SDCA_CTL_DETECTED_MODE, 0), &det_mode);
94 if (ret < 0)
95 goto io_error;
96
97 /* pin attached */
98 if (det_mode) {
99 /* read UMP message offset */
100 ret = regmap_read(rt721->regmap,
101 SDW_SDCA_CTL(FUNC_NUM_HID, RT721_SDCA_ENT_HID01,
102 RT721_SDCA_CTL_HIDTX_MESSAGE_OFFSET, 0), &offset);
103 if (ret < 0)
104 goto io_error;
105
106 for (idx = 0; idx < sizeof(buf); idx++) {
107 ret = regmap_read(rt721->regmap,
108 RT721_BUF_ADDR_HID1 + offset + idx, &val);
109 if (ret < 0)
110 goto io_error;
111 buf[idx] = val & 0xff;
112 }
113 /* Report ID for HID1 */
114 if (buf[0] == 0x11)
115 btn_type = rt_sdca_btn_type(&buf[1]);
116 } else
117 rt721->jack_type = 0;
118
119 dev_dbg(&rt721->slave->dev, "%s, btn_type=0x%x\n", __func__, btn_type);
120 snd_soc_jack_report(rt721->hs_jack, rt721->jack_type | btn_type,
121 SND_JACK_HEADSET |
122 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
123 SND_JACK_BTN_2 | SND_JACK_BTN_3);
124
125 if (btn_type) {
126 /* button released */
127 snd_soc_jack_report(rt721->hs_jack, rt721->jack_type,
128 SND_JACK_HEADSET |
129 SND_JACK_BTN_0 | SND_JACK_BTN_1 |
130 SND_JACK_BTN_2 | SND_JACK_BTN_3);
131
132 mod_delayed_work(system_power_efficient_wq,
133 &rt721->jack_btn_check_work, msecs_to_jiffies(200));
134 }
135
136 return;
137
138 io_error:
139 pr_err_ratelimited("IO error in %s, ret %d\n", __func__, ret);
140 }
141
rt721_sdca_dmic_preset(struct rt721_sdca_priv * rt721)142 static void rt721_sdca_dmic_preset(struct rt721_sdca_priv *rt721)
143 {
144 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
145 RT721_MISC_POWER_CTL31, 0x8000);
146 rt_sdca_index_write(rt721->mbq_regmap, RT721_ANA_POW_PART,
147 RT721_VREF1_HV_CTRL1, 0xe000);
148 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
149 RT721_MISC_POWER_CTL31, 0x8007);
150 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
151 RT721_ENT_FLOAT_CTL9, 0x2a2a);
152 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
153 RT721_ENT_FLOAT_CTL10, 0x2a00);
154 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
155 RT721_ENT_FLOAT_CTL6, 0x2a2a);
156 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
157 RT721_ENT_FLOAT_CTL5, 0x2626);
158 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
159 RT721_ENT_FLOAT_CTL8, 0x1e00);
160 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
161 RT721_ENT_FLOAT_CTL7, 0x1515);
162 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
163 RT721_CH_FLOAT_CTL3, 0x0304);
164 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
165 RT721_CH_FLOAT_CTL4, 0x0304);
166 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
167 RT721_HDA_LEGACY_CTL1, 0x0000);
168 regmap_write(rt721->regmap,
169 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_IT26,
170 RT721_SDCA_CTL_VENDOR_DEF, 0), 0x01);
171 regmap_write(rt721->mbq_regmap, 0x5910009, 0x2e01);
172 rt_sdca_index_write(rt721->mbq_regmap, RT721_RC_CALIB_CTRL,
173 RT721_RC_CALIB_CTRL0, 0x0b00);
174 rt_sdca_index_write(rt721->mbq_regmap, RT721_RC_CALIB_CTRL,
175 RT721_RC_CALIB_CTRL0, 0x0b40);
176 regmap_write(rt721->regmap, 0x2f5c, 0x25);
177 }
178
rt721_sdca_amp_preset(struct rt721_sdca_priv * rt721)179 static void rt721_sdca_amp_preset(struct rt721_sdca_priv *rt721)
180 {
181 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
182 RT721_MISC_POWER_CTL31, 0x8000);
183 rt_sdca_index_write(rt721->mbq_regmap, RT721_ANA_POW_PART,
184 RT721_VREF1_HV_CTRL1, 0xe000);
185 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
186 RT721_MISC_POWER_CTL31, 0x8007);
187 regmap_write(rt721->mbq_regmap, 0x5810000, 0x6420);
188 regmap_write(rt721->mbq_regmap, 0x5810000, 0x6421);
189 regmap_write(rt721->mbq_regmap, 0x5810000, 0xe421);
190 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
191 RT721_CH_FLOAT_CTL6, 0x5561);
192 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_REG,
193 RT721_GPIO_PAD_CTRL5, 0x8003);
194 regmap_write(rt721->regmap,
195 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_OT23,
196 RT721_SDCA_CTL_VENDOR_DEF, 0), 0x04);
197 regmap_write(rt721->regmap,
198 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_PDE23,
199 RT721_SDCA_CTL_FU_MUTE, CH_01), 0x00);
200 regmap_write(rt721->regmap,
201 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_PDE23,
202 RT721_SDCA_CTL_FU_MUTE, CH_02), 0x00);
203 regmap_write(rt721->regmap,
204 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_FU55,
205 RT721_SDCA_CTL_FU_MUTE, CH_01), 0x00);
206 regmap_write(rt721->regmap,
207 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_FU55,
208 RT721_SDCA_CTL_FU_MUTE, CH_02), 0x00);
209 }
210
rt721_sdca_jack_preset(struct rt721_sdca_priv * rt721)211 static void rt721_sdca_jack_preset(struct rt721_sdca_priv *rt721)
212 {
213 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
214 RT721_MISC_POWER_CTL31, 0x8000);
215 rt_sdca_index_write(rt721->mbq_regmap, RT721_ANA_POW_PART,
216 RT721_VREF1_HV_CTRL1, 0xe000);
217 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
218 RT721_MISC_POWER_CTL31, 0x8007);
219 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
220 RT721_GE_REL_CTRL1, 0x8011);
221 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
222 RT721_UMP_HID_CTRL3, 0xcf00);
223 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
224 RT721_UMP_HID_CTRL4, 0x000f);
225 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
226 RT721_UMP_HID_CTRL1, 0x1100);
227 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
228 RT721_UMP_HID_CTRL5, 0x0c12);
229 rt_sdca_index_write(rt721->mbq_regmap, RT721_JD_CTRL,
230 RT721_JD_1PIN_GAT_CTRL2, 0xc002);
231 rt_sdca_index_write(rt721->mbq_regmap, RT721_RC_CALIB_CTRL,
232 RT721_RC_CALIB_CTRL0, 0x0b00);
233 rt_sdca_index_write(rt721->mbq_regmap, RT721_RC_CALIB_CTRL,
234 RT721_RC_CALIB_CTRL0, 0x0b40);
235 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
236 RT721_UAJ_TOP_TCON14, 0x3333);
237 regmap_write(rt721->mbq_regmap, 0x5810035, 0x0036);
238 regmap_write(rt721->mbq_regmap, 0x5810030, 0xee00);
239 rt_sdca_index_write(rt721->mbq_regmap, RT721_CAP_PORT_CTRL,
240 RT721_HP_AMP_2CH_CAL1, 0x0140);
241 regmap_write(rt721->mbq_regmap, 0x5810000, 0x0021);
242 regmap_write(rt721->mbq_regmap, 0x5810000, 0x8021);
243 rt_sdca_index_write(rt721->mbq_regmap, RT721_CAP_PORT_CTRL,
244 RT721_HP_AMP_2CH_CAL18, 0x5522);
245 regmap_write(rt721->mbq_regmap, 0x5b10007, 0x2000);
246 regmap_write(rt721->mbq_regmap, 0x5B10017, 0x1b0f);
247 rt_sdca_index_write(rt721->mbq_regmap, RT721_CBJ_CTRL,
248 RT721_CBJ_A0_GAT_CTRL1, 0x2a02);
249 rt_sdca_index_write(rt721->mbq_regmap, RT721_CAP_PORT_CTRL,
250 RT721_HP_AMP_2CH_CAL4, 0xa105);
251 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
252 RT721_UAJ_TOP_TCON14, 0x3b33);
253 regmap_write(rt721->mbq_regmap, 0x310400, 0x3023);
254 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
255 RT721_UAJ_TOP_TCON14, 0x3f33);
256 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
257 RT721_UAJ_TOP_TCON13, 0x6048);
258 regmap_write(rt721->mbq_regmap, 0x310401, 0x3000);
259 regmap_write(rt721->mbq_regmap, 0x310402, 0x1b00);
260 regmap_write(rt721->mbq_regmap, 0x310300, 0x000f);
261 regmap_write(rt721->mbq_regmap, 0x310301, 0x3000);
262 regmap_write(rt721->mbq_regmap, 0x310302, 0x1b00);
263 rt_sdca_index_write(rt721->mbq_regmap, RT721_VENDOR_ANA_CTL,
264 RT721_UAJ_TOP_TCON17, 0x0008);
265 rt_sdca_index_write(rt721->mbq_regmap, RT721_DAC_CTRL,
266 RT721_DAC_2CH_CTRL3, 0x55ff);
267 rt_sdca_index_write(rt721->mbq_regmap, RT721_DAC_CTRL,
268 RT721_DAC_2CH_CTRL4, 0xcc00);
269 rt_sdca_index_write(rt721->mbq_regmap, RT721_ANA_POW_PART,
270 RT721_MBIAS_LV_CTRL2, 0x6677);
271 rt_sdca_index_write(rt721->mbq_regmap, RT721_ANA_POW_PART,
272 RT721_VREF2_LV_CTRL1, 0x7600);
273 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
274 RT721_ENT_FLOAT_CTL2, 0x1234);
275 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
276 RT721_ENT_FLOAT_CTL3, 0x3512);
277 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
278 RT721_ENT_FLOAT_CTL1, 0x4040);
279 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
280 RT721_ENT_FLOAT_CTL4, 0x1201);
281 rt_sdca_index_write(rt721->mbq_regmap, RT721_BOOST_CTRL,
282 RT721_BST_4CH_TOP_GATING_CTRL1, 0x002a);
283 regmap_write(rt721->regmap, 0x2f58, 0x07);
284
285 regmap_write(rt721->regmap, 0x2f51, 0x00);
286 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
287 RT721_MISC_CTL, 0x0004);
288 }
289
rt721_sdca_jack_init(struct rt721_sdca_priv * rt721)290 static void rt721_sdca_jack_init(struct rt721_sdca_priv *rt721)
291 {
292 mutex_lock(&rt721->calibrate_mutex);
293 if (rt721->hs_jack) {
294 sdw_write_no_pm(rt721->slave, SDW_SCP_SDCA_INTMASK1,
295 SDW_SCP_SDCA_INTMASK_SDCA_0);
296 sdw_write_no_pm(rt721->slave, SDW_SCP_SDCA_INTMASK2,
297 SDW_SCP_SDCA_INTMASK_SDCA_8);
298 dev_dbg(&rt721->slave->dev, "in %s enable\n", __func__);
299 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
300 RT721_HDA_LEGACY_UAJ_CTL, 0x036E);
301 regmap_write(rt721->regmap,
302 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_XU03,
303 RT721_SDCA_CTL_SELECTED_MODE, 0), 0);
304 regmap_write(rt721->regmap,
305 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_XU0D,
306 RT721_SDCA_CTL_SELECTED_MODE, 0), 0);
307 rt_sdca_index_write(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
308 RT721_XU_REL_CTRL, 0x0000);
309 rt_sdca_index_update_bits(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
310 RT721_GE_REL_CTRL1, 0x4000, 0x4000);
311 }
312 mutex_unlock(&rt721->calibrate_mutex);
313 }
314
rt721_sdca_set_jack_detect(struct snd_soc_component * component,struct snd_soc_jack * hs_jack,void * data)315 static int rt721_sdca_set_jack_detect(struct snd_soc_component *component,
316 struct snd_soc_jack *hs_jack, void *data)
317 {
318 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
319 int ret;
320
321 rt721->hs_jack = hs_jack;
322
323 ret = pm_runtime_resume_and_get(component->dev);
324 if (ret < 0) {
325 if (ret != -EACCES) {
326 dev_err(component->dev, "%s: failed to resume %d\n", __func__, ret);
327 return ret;
328 }
329 /* pm_runtime not enabled yet */
330 dev_dbg(component->dev, "%s: skipping jack init for now\n", __func__);
331 return 0;
332 }
333
334 rt721_sdca_jack_init(rt721);
335
336 pm_runtime_put_autosuspend(component->dev);
337
338 return 0;
339 }
340
341 /* For SDCA control DAC/ADC Gain */
rt721_sdca_set_gain_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)342 static int rt721_sdca_set_gain_put(struct snd_kcontrol *kcontrol,
343 struct snd_ctl_elem_value *ucontrol)
344 {
345 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
346 struct soc_mixer_control *mc =
347 (struct soc_mixer_control *)kcontrol->private_value;
348 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
349 unsigned int read_l, read_r, gain_l_val, gain_r_val;
350 unsigned int adc_vol_flag = 0, changed = 0;
351 unsigned int lvalue, rvalue;
352 const unsigned int interval_offset = 0xc0;
353 const unsigned int tendA = 0x200;
354 const unsigned int tendB = 0xa00;
355
356 if (strstr(ucontrol->id.name, "FU1E Capture Volume") ||
357 strstr(ucontrol->id.name, "FU0F Capture Volume"))
358 adc_vol_flag = 1;
359
360 regmap_read(rt721->mbq_regmap, mc->reg, &lvalue);
361 regmap_read(rt721->mbq_regmap, mc->rreg, &rvalue);
362
363 /* L Channel */
364 gain_l_val = ucontrol->value.integer.value[0];
365 if (gain_l_val > mc->max)
366 gain_l_val = mc->max;
367
368 if (mc->shift == 8) {
369 /* boost gain */
370 gain_l_val = gain_l_val * tendB;
371 } else if (mc->shift == 1) {
372 /* FU33 boost gain */
373 if (gain_l_val == 0)
374 gain_l_val = 0x8000;
375 else
376 gain_l_val = (gain_l_val - 1) * tendA;
377 } else {
378 /* ADC/DAC gain */
379 if (adc_vol_flag)
380 gain_l_val = 0x1e00 - ((mc->max - gain_l_val) * interval_offset);
381 else
382 gain_l_val = 0 - ((mc->max - gain_l_val) * interval_offset);
383 gain_l_val &= 0xffff;
384 }
385
386 /* R Channel */
387 gain_r_val = ucontrol->value.integer.value[1];
388 if (gain_r_val > mc->max)
389 gain_r_val = mc->max;
390
391 if (mc->shift == 8) {
392 /* boost gain */
393 gain_r_val = gain_r_val * tendB;
394 } else if (mc->shift == 1) {
395 /* FU33 boost gain */
396 if (gain_r_val == 0)
397 gain_r_val = 0x8000;
398 else
399 gain_r_val = (gain_r_val - 1) * tendA;
400 } else {
401 /* ADC/DAC gain */
402 if (adc_vol_flag)
403 gain_r_val = 0x1e00 - ((mc->max - gain_r_val) * interval_offset);
404 else
405 gain_r_val = 0 - ((mc->max - gain_r_val) * interval_offset);
406 gain_r_val &= 0xffff;
407 }
408
409 if (lvalue != gain_l_val || rvalue != gain_r_val)
410 changed = 1;
411 else
412 return 0;
413
414 /* Lch*/
415 regmap_write(rt721->mbq_regmap, mc->reg, gain_l_val);
416
417 /* Rch */
418 regmap_write(rt721->mbq_regmap, mc->rreg, gain_r_val);
419
420 regmap_read(rt721->mbq_regmap, mc->reg, &read_l);
421 regmap_read(rt721->mbq_regmap, mc->rreg, &read_r);
422 if (read_r == gain_r_val && read_l == gain_l_val)
423 return changed;
424
425 return -EIO;
426 }
427
rt721_sdca_set_gain_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)428 static int rt721_sdca_set_gain_get(struct snd_kcontrol *kcontrol,
429 struct snd_ctl_elem_value *ucontrol)
430 {
431 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
432 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
433 struct soc_mixer_control *mc =
434 (struct soc_mixer_control *)kcontrol->private_value;
435 unsigned int read_l, read_r, ctl_l = 0, ctl_r = 0;
436 unsigned int adc_vol_flag = 0;
437 const unsigned int interval_offset = 0xc0;
438 const unsigned int tendA = 0x200;
439 const unsigned int tendB = 0xa00;
440
441 if (strstr(ucontrol->id.name, "FU1E Capture Volume") ||
442 strstr(ucontrol->id.name, "FU0F Capture Volume"))
443 adc_vol_flag = 1;
444
445 regmap_read(rt721->mbq_regmap, mc->reg, &read_l);
446 regmap_read(rt721->mbq_regmap, mc->rreg, &read_r);
447
448 if (mc->shift == 8) {
449 /* boost gain */
450 ctl_l = read_l / tendB;
451 } else if (mc->shift == 1) {
452 /* FU33 boost gain */
453 if (read_l == 0x8000 || read_l == 0xfe00)
454 ctl_l = 0;
455 else
456 ctl_l = read_l / tendA + 1;
457 } else {
458 if (adc_vol_flag)
459 ctl_l = mc->max - (((0x1e00 - read_l) & 0xffff) / interval_offset);
460 else
461 ctl_l = mc->max - (((0 - read_l) & 0xffff) / interval_offset);
462 }
463
464 if (read_l != read_r) {
465 if (mc->shift == 8) {
466 /* boost gain */
467 ctl_r = read_r / tendB;
468 } else if (mc->shift == 1) {
469 /* FU33 boost gain */
470 if (read_r == 0x8000 || read_r == 0xfe00)
471 ctl_r = 0;
472 else
473 ctl_r = read_r / tendA + 1;
474 } else { /* ADC/DAC gain */
475 if (adc_vol_flag)
476 ctl_r = mc->max - (((0x1e00 - read_r) & 0xffff) / interval_offset);
477 else
478 ctl_r = mc->max - (((0 - read_r) & 0xffff) / interval_offset);
479 }
480 } else {
481 ctl_r = ctl_l;
482 }
483
484 ucontrol->value.integer.value[0] = ctl_l;
485 ucontrol->value.integer.value[1] = ctl_r;
486
487 return 0;
488 }
489
rt721_sdca_set_fu1e_capture_ctl(struct rt721_sdca_priv * rt721)490 static int rt721_sdca_set_fu1e_capture_ctl(struct rt721_sdca_priv *rt721)
491 {
492 int err, i;
493 unsigned int ch_mute;
494
495 for (i = 0; i < ARRAY_SIZE(rt721->fu1e_mixer_mute); i++) {
496 ch_mute = rt721->fu1e_dapm_mute || rt721->fu1e_mixer_mute[i];
497 err = regmap_write(rt721->regmap,
498 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_USER_FU1E,
499 RT721_SDCA_CTL_FU_MUTE, CH_01) + i, ch_mute);
500 if (err < 0)
501 return err;
502 }
503
504 return 0;
505 }
506
rt721_sdca_fu1e_capture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)507 static int rt721_sdca_fu1e_capture_get(struct snd_kcontrol *kcontrol,
508 struct snd_ctl_elem_value *ucontrol)
509 {
510 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
511 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
512 struct rt721_sdca_dmic_kctrl_priv *p =
513 (struct rt721_sdca_dmic_kctrl_priv *)kcontrol->private_value;
514 unsigned int i;
515
516 for (i = 0; i < p->count; i++)
517 ucontrol->value.integer.value[i] = !rt721->fu1e_mixer_mute[i];
518
519 return 0;
520 }
521
rt721_sdca_fu1e_capture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)522 static int rt721_sdca_fu1e_capture_put(struct snd_kcontrol *kcontrol,
523 struct snd_ctl_elem_value *ucontrol)
524 {
525 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
526 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
527 struct rt721_sdca_dmic_kctrl_priv *p =
528 (struct rt721_sdca_dmic_kctrl_priv *)kcontrol->private_value;
529 int err, changed = 0, i;
530
531 for (i = 0; i < p->count; i++) {
532 if (rt721->fu1e_mixer_mute[i] != !ucontrol->value.integer.value[i])
533 changed = 1;
534 rt721->fu1e_mixer_mute[i] = !ucontrol->value.integer.value[i];
535 }
536
537 err = rt721_sdca_set_fu1e_capture_ctl(rt721);
538 if (err < 0)
539 return err;
540
541 return changed;
542 }
543
rt721_sdca_set_fu0f_capture_ctl(struct rt721_sdca_priv * rt721)544 static int rt721_sdca_set_fu0f_capture_ctl(struct rt721_sdca_priv *rt721)
545 {
546 int err;
547 unsigned int ch_l, ch_r;
548
549 ch_l = (rt721->fu0f_dapm_mute || rt721->fu0f_mixer_l_mute) ? 0x01 : 0x00;
550 ch_r = (rt721->fu0f_dapm_mute || rt721->fu0f_mixer_r_mute) ? 0x01 : 0x00;
551
552 err = regmap_write(rt721->regmap,
553 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU0F,
554 RT721_SDCA_CTL_FU_MUTE, CH_L), ch_l);
555 if (err < 0)
556 return err;
557
558 err = regmap_write(rt721->regmap,
559 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU0F,
560 RT721_SDCA_CTL_FU_MUTE, CH_R), ch_r);
561 if (err < 0)
562 return err;
563
564 return 0;
565 }
566
rt721_sdca_fu0f_capture_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)567 static int rt721_sdca_fu0f_capture_get(struct snd_kcontrol *kcontrol,
568 struct snd_ctl_elem_value *ucontrol)
569 {
570 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
571 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
572
573 ucontrol->value.integer.value[0] = !rt721->fu0f_mixer_l_mute;
574 ucontrol->value.integer.value[1] = !rt721->fu0f_mixer_r_mute;
575 return 0;
576 }
577
rt721_sdca_fu0f_capture_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)578 static int rt721_sdca_fu0f_capture_put(struct snd_kcontrol *kcontrol,
579 struct snd_ctl_elem_value *ucontrol)
580 {
581 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
582 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
583 int err, changed = 0;
584
585 if (rt721->fu0f_mixer_l_mute != !ucontrol->value.integer.value[0] ||
586 rt721->fu0f_mixer_r_mute != !ucontrol->value.integer.value[1])
587 changed = 1;
588
589 rt721->fu0f_mixer_l_mute = !ucontrol->value.integer.value[0];
590 rt721->fu0f_mixer_r_mute = !ucontrol->value.integer.value[1];
591 err = rt721_sdca_set_fu0f_capture_ctl(rt721);
592 if (err < 0)
593 return err;
594
595 return changed;
596 }
597
rt721_sdca_fu_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)598 static int rt721_sdca_fu_info(struct snd_kcontrol *kcontrol,
599 struct snd_ctl_elem_info *uinfo)
600 {
601 struct rt721_sdca_dmic_kctrl_priv *p =
602 (struct rt721_sdca_dmic_kctrl_priv *)kcontrol->private_value;
603
604 if (p->max == 1)
605 uinfo->type = SNDRV_CTL_ELEM_TYPE_BOOLEAN;
606 else
607 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
608 uinfo->count = p->count;
609 uinfo->value.integer.min = 0;
610 uinfo->value.integer.max = p->max;
611 return 0;
612 }
613
rt721_sdca_dmic_set_gain_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)614 static int rt721_sdca_dmic_set_gain_get(struct snd_kcontrol *kcontrol,
615 struct snd_ctl_elem_value *ucontrol)
616 {
617 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
618 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
619 struct rt721_sdca_dmic_kctrl_priv *p =
620 (struct rt721_sdca_dmic_kctrl_priv *)kcontrol->private_value;
621 unsigned int boost_step = 0x0a00;
622 unsigned int vol_max = 0x1e00;
623 unsigned int regvalue, ctl, i;
624 unsigned int adc_vol_flag = 0;
625 const unsigned int interval_offset = 0xc0;
626
627 if (strstr(ucontrol->id.name, "FU1E Capture Volume"))
628 adc_vol_flag = 1;
629
630 /* check all channels */
631 for (i = 0; i < p->count; i++) {
632 regmap_read(rt721->mbq_regmap, p->reg_base + i, ®value);
633
634 if (!adc_vol_flag) /* boost gain */
635 ctl = regvalue / boost_step;
636 else /* ADC gain */
637 ctl = p->max - (((vol_max - regvalue) & 0xffff) / interval_offset);
638
639 ucontrol->value.integer.value[i] = ctl;
640 }
641
642 return 0;
643 }
644
rt721_sdca_dmic_set_gain_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)645 static int rt721_sdca_dmic_set_gain_put(struct snd_kcontrol *kcontrol,
646 struct snd_ctl_elem_value *ucontrol)
647 {
648 struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
649 struct rt721_sdca_dmic_kctrl_priv *p =
650 (struct rt721_sdca_dmic_kctrl_priv *)kcontrol->private_value;
651 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
652 unsigned int boost_step = 0x0a00;
653 unsigned int vol_max = 0x1e00;
654 unsigned int gain_val[4];
655 unsigned int i, adc_vol_flag = 0, changed = 0;
656 unsigned int regvalue[4];
657 const unsigned int interval_offset = 0xc0;
658 int err;
659
660 if (strstr(ucontrol->id.name, "FU1E Capture Volume"))
661 adc_vol_flag = 1;
662
663 /* check all channels */
664 for (i = 0; i < p->count; i++) {
665 regmap_read(rt721->mbq_regmap, p->reg_base + i, ®value[i]);
666
667 gain_val[i] = ucontrol->value.integer.value[i];
668 if (gain_val[i] > p->max)
669 gain_val[i] = p->max;
670
671 if (!adc_vol_flag) /* boost gain */
672 gain_val[i] = gain_val[i] * boost_step;
673 else { /* ADC gain */
674 gain_val[i] = vol_max - ((p->max - gain_val[i]) * interval_offset);
675 gain_val[i] &= 0xffff;
676 }
677
678 if (regvalue[i] != gain_val[i])
679 changed = 1;
680 }
681
682 if (!changed)
683 return 0;
684
685 for (i = 0; i < p->count; i++) {
686 err = regmap_write(rt721->mbq_regmap, p->reg_base + i, gain_val[i]);
687 if (err < 0)
688 dev_err(&rt721->slave->dev, "%#08x can't be set\n", p->reg_base + i);
689 }
690
691 return changed;
692 }
693
694 static const DECLARE_TLV_DB_SCALE(out_vol_tlv, -6525, 75, 0);
695 static const DECLARE_TLV_DB_SCALE(mic_vol_tlv, -1725, 75, 0);
696 static const DECLARE_TLV_DB_SCALE(boost_vol_tlv, 0, 1000, 0);
697 static const DECLARE_TLV_DB_SCALE(mic2_boost_vol_tlv, -200, 200, 0);
698
699 static const struct snd_kcontrol_new rt721_sdca_controls[] = {
700 /* Headphone playback settings */
701 SOC_DOUBLE_R_EXT_TLV("FU05 Playback Volume",
702 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU05,
703 RT721_SDCA_CTL_FU_VOLUME, CH_L),
704 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU05,
705 RT721_SDCA_CTL_FU_VOLUME, CH_R), 0, 0x57, 0,
706 rt721_sdca_set_gain_get, rt721_sdca_set_gain_put, out_vol_tlv),
707 /* Headset mic capture settings */
708 SOC_DOUBLE_EXT("FU0F Capture Switch", SND_SOC_NOPM, 0, 1, 1, 0,
709 rt721_sdca_fu0f_capture_get, rt721_sdca_fu0f_capture_put),
710 SOC_DOUBLE_R_EXT_TLV("FU0F Capture Volume",
711 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU0F,
712 RT721_SDCA_CTL_FU_VOLUME, CH_L),
713 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU0F,
714 RT721_SDCA_CTL_FU_VOLUME, CH_R), 0, 0x3f, 0,
715 rt721_sdca_set_gain_get, rt721_sdca_set_gain_put, mic_vol_tlv),
716 SOC_DOUBLE_R_EXT_TLV("FU33 Boost Volume",
717 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_PLATFORM_FU44,
718 RT721_SDCA_CTL_FU_CH_GAIN, CH_L),
719 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_PLATFORM_FU44,
720 RT721_SDCA_CTL_FU_CH_GAIN, CH_R), 1, 0x15, 0,
721 rt721_sdca_set_gain_get, rt721_sdca_set_gain_put, mic2_boost_vol_tlv),
722 /* AMP playback settings */
723 SOC_DOUBLE_R_EXT_TLV("FU06 Playback Volume",
724 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_USER_FU06,
725 RT721_SDCA_CTL_FU_VOLUME, CH_L),
726 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_USER_FU06,
727 RT721_SDCA_CTL_FU_VOLUME, CH_R), 0, 0x57, 0,
728 rt721_sdca_set_gain_get, rt721_sdca_set_gain_put, out_vol_tlv),
729 /* DMIC capture settings */
730 RT_SDCA_FU_CTRL("FU1E Capture Switch",
731 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_USER_FU1E,
732 RT721_SDCA_CTL_FU_MUTE, CH_01), 1, 1, 4, rt721_sdca_fu_info,
733 rt721_sdca_fu1e_capture_get, rt721_sdca_fu1e_capture_put),
734 RT_SDCA_EXT_TLV("FU1E Capture Volume",
735 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_USER_FU1E,
736 RT721_SDCA_CTL_FU_VOLUME, CH_01),
737 rt721_sdca_dmic_set_gain_get, rt721_sdca_dmic_set_gain_put,
738 4, 0x3f, mic_vol_tlv, rt721_sdca_fu_info),
739 RT_SDCA_EXT_TLV("FU15 Boost Volume",
740 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_FU15,
741 RT721_SDCA_CTL_FU_CH_GAIN, CH_01),
742 rt721_sdca_dmic_set_gain_get, rt721_sdca_dmic_set_gain_put,
743 4, 3, boost_vol_tlv, rt721_sdca_fu_info),
744 };
745
rt721_sdca_adc_mux_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)746 static int rt721_sdca_adc_mux_get(struct snd_kcontrol *kcontrol,
747 struct snd_ctl_elem_value *ucontrol)
748 {
749 struct snd_soc_component *component =
750 snd_soc_dapm_kcontrol_component(kcontrol);
751 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
752 unsigned int val = 0, mask_sft, mask;
753
754 if (strstr(ucontrol->id.name, "ADC 09 Mux")) {
755 mask_sft = 12;
756 mask = 0x7;
757 } else if (strstr(ucontrol->id.name, "ADC 08 R Mux")) {
758 mask_sft = 10;
759 mask = 0x3;
760 } else if (strstr(ucontrol->id.name, "ADC 08 L Mux")) {
761 mask_sft = 8;
762 mask = 0x3;
763 } else if (strstr(ucontrol->id.name, "ADC 10 R Mux")) {
764 mask_sft = 6;
765 mask = 0x3;
766 } else if (strstr(ucontrol->id.name, "ADC 10 L Mux")) {
767 mask_sft = 4;
768 mask = 0x3;
769 } else if (strstr(ucontrol->id.name, "ADC 07 R Mux")) {
770 mask_sft = 2;
771 mask = 0x3;
772 } else if (strstr(ucontrol->id.name, "ADC 07 L Mux")) {
773 mask_sft = 0;
774 mask = 0x3;
775 } else
776 return -EINVAL;
777
778 rt_sdca_index_read(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
779 RT721_HDA_LEGACY_MUX_CTL0, &val);
780
781 ucontrol->value.enumerated.item[0] = (val >> mask_sft) & mask;
782
783 return 0;
784 }
785
rt721_sdca_adc_mux_put(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)786 static int rt721_sdca_adc_mux_put(struct snd_kcontrol *kcontrol,
787 struct snd_ctl_elem_value *ucontrol)
788 {
789 struct snd_soc_component *component =
790 snd_soc_dapm_kcontrol_component(kcontrol);
791 struct snd_soc_dapm_context *dapm =
792 snd_soc_dapm_kcontrol_dapm(kcontrol);
793 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
794 struct soc_enum *e = (struct soc_enum *)kcontrol->private_value;
795 unsigned int *item = ucontrol->value.enumerated.item;
796 unsigned int val, val2 = 0, change, mask_sft, mask;
797 unsigned int check;
798
799 if (item[0] >= e->items)
800 return -EINVAL;
801
802 if (strstr(ucontrol->id.name, "ADC 09 Mux")) {
803 mask_sft = 12;
804 mask = 0x7;
805 } else if (strstr(ucontrol->id.name, "ADC 08 R Mux")) {
806 mask_sft = 10;
807 mask = 0x3;
808 } else if (strstr(ucontrol->id.name, "ADC 08 L Mux")) {
809 mask_sft = 8;
810 mask = 0x3;
811 } else if (strstr(ucontrol->id.name, "ADC 10 R Mux")) {
812 mask_sft = 6;
813 mask = 0x3;
814 } else if (strstr(ucontrol->id.name, "ADC 10 L Mux")) {
815 mask_sft = 4;
816 mask = 0x3;
817 } else if (strstr(ucontrol->id.name, "ADC 07 R Mux")) {
818 mask_sft = 2;
819 mask = 0x3;
820 } else if (strstr(ucontrol->id.name, "ADC 07 L Mux")) {
821 mask_sft = 0;
822 mask = 0x3;
823 } else
824 return -EINVAL;
825
826 val = snd_soc_enum_item_to_val(e, item[0]) << e->shift_l;
827 rt_sdca_index_read(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
828 RT721_HDA_LEGACY_MUX_CTL0, &val2);
829
830 if (strstr(ucontrol->id.name, "ADC 09 Mux"))
831 val2 = (val2 >> mask_sft) & 0x7;
832 else
833 val2 = (val2 >> mask_sft) & 0x3;
834
835 if (val == val2)
836 change = 0;
837 else
838 change = 1;
839
840 if (change) {
841 rt_sdca_index_read(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
842 RT721_HDA_LEGACY_MUX_CTL0, &check);
843 rt_sdca_index_update_bits(rt721->mbq_regmap, RT721_HDA_SDCA_FLOAT,
844 RT721_HDA_LEGACY_MUX_CTL0, mask << mask_sft,
845 val << mask_sft);
846 }
847
848 snd_soc_dapm_mux_update_power(dapm, kcontrol,
849 item[0], e, NULL);
850
851 return change;
852 }
853
854 static const char * const adc09_mux_text[] = {
855 "MIC2",
856 "LINE1",
857 "LINE2",
858 };
859 static const char * const adc07_10_mux_text[] = {
860 "DMIC1 RE",
861 "DMIC1 FE",
862 "DMIC2 RE",
863 "DMIC2 FE",
864 };
865
866 static SOC_ENUM_SINGLE_DECL(
867 rt721_adc09_enum, SND_SOC_NOPM, 0, adc09_mux_text);
868 static SOC_ENUM_SINGLE_DECL(
869 rt721_dmic_enum, SND_SOC_NOPM, 0, adc07_10_mux_text);
870
871 static const struct snd_kcontrol_new rt721_sdca_adc09_mux =
872 SOC_DAPM_ENUM_EXT("ADC 09 Mux", rt721_adc09_enum,
873 rt721_sdca_adc_mux_get, rt721_sdca_adc_mux_put);
874 static const struct snd_kcontrol_new rt721_sdca_adc08_r_mux =
875 SOC_DAPM_ENUM_EXT("ADC 08 R Mux", rt721_dmic_enum,
876 rt721_sdca_adc_mux_get, rt721_sdca_adc_mux_put);
877 static const struct snd_kcontrol_new rt721_sdca_adc08_l_mux =
878 SOC_DAPM_ENUM_EXT("ADC 08 L Mux", rt721_dmic_enum,
879 rt721_sdca_adc_mux_get, rt721_sdca_adc_mux_put);
880 static const struct snd_kcontrol_new rt721_sdca_adc10_r_mux =
881 SOC_DAPM_ENUM_EXT("ADC 10 R Mux", rt721_dmic_enum,
882 rt721_sdca_adc_mux_get, rt721_sdca_adc_mux_put);
883 static const struct snd_kcontrol_new rt721_sdca_adc10_l_mux =
884 SOC_DAPM_ENUM_EXT("ADC 10 L Mux", rt721_dmic_enum,
885 rt721_sdca_adc_mux_get, rt721_sdca_adc_mux_put);
886 static const struct snd_kcontrol_new rt721_sdca_adc07_r_mux =
887 SOC_DAPM_ENUM_EXT("ADC 07 R Mux", rt721_dmic_enum,
888 rt721_sdca_adc_mux_get, rt721_sdca_adc_mux_put);
889 static const struct snd_kcontrol_new rt721_sdca_adc07_l_mux =
890 SOC_DAPM_ENUM_EXT("ADC 07 L Mux", rt721_dmic_enum,
891 rt721_sdca_adc_mux_get, rt721_sdca_adc_mux_put);
892
893
rt721_sdca_fu42_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)894 static int rt721_sdca_fu42_event(struct snd_soc_dapm_widget *w,
895 struct snd_kcontrol *kcontrol, int event)
896 {
897 struct snd_soc_component *component =
898 snd_soc_dapm_to_component(w->dapm);
899 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
900 unsigned char unmute = 0x0, mute = 0x1;
901
902 switch (event) {
903 case SND_SOC_DAPM_POST_PMU:
904 msleep(100);
905 regmap_write(rt721->regmap,
906 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU05,
907 RT721_SDCA_CTL_FU_MUTE, CH_L), unmute);
908 regmap_write(rt721->regmap,
909 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU05,
910 RT721_SDCA_CTL_FU_MUTE, CH_R), unmute);
911 break;
912 case SND_SOC_DAPM_PRE_PMD:
913 regmap_write(rt721->regmap,
914 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU05,
915 RT721_SDCA_CTL_FU_MUTE, CH_L), mute);
916 regmap_write(rt721->regmap,
917 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_USER_FU05,
918 RT721_SDCA_CTL_FU_MUTE, CH_R), mute);
919 break;
920 }
921 return 0;
922 }
923
rt721_sdca_fu21_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)924 static int rt721_sdca_fu21_event(struct snd_soc_dapm_widget *w,
925 struct snd_kcontrol *kcontrol, int event)
926 {
927 struct snd_soc_component *component =
928 snd_soc_dapm_to_component(w->dapm);
929 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
930 unsigned char unmute = 0x0, mute = 0x1;
931
932 switch (event) {
933 case SND_SOC_DAPM_POST_PMU:
934 regmap_write(rt721->regmap,
935 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_USER_FU06,
936 RT721_SDCA_CTL_FU_MUTE, CH_L), unmute);
937 regmap_write(rt721->regmap,
938 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_USER_FU06,
939 RT721_SDCA_CTL_FU_MUTE, CH_R), unmute);
940 break;
941 case SND_SOC_DAPM_PRE_PMD:
942 regmap_write(rt721->regmap,
943 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_USER_FU06,
944 RT721_SDCA_CTL_FU_MUTE, CH_L), mute);
945 regmap_write(rt721->regmap,
946 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_USER_FU06,
947 RT721_SDCA_CTL_FU_MUTE, CH_R), mute);
948 break;
949 }
950 return 0;
951 }
952
rt721_sdca_fu23_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)953 static int rt721_sdca_fu23_event(struct snd_soc_dapm_widget *w,
954 struct snd_kcontrol *kcontrol, int event)
955 {
956 struct snd_soc_component *component =
957 snd_soc_dapm_to_component(w->dapm);
958 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
959 unsigned char unmute = 0x0, mute = 0x1;
960
961 switch (event) {
962 case SND_SOC_DAPM_POST_PMU:
963 regmap_write(rt721->regmap,
964 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_PDE23,
965 RT721_SDCA_CTL_FU_MUTE, CH_L), unmute);
966 regmap_write(rt721->regmap,
967 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_PDE23,
968 RT721_SDCA_CTL_FU_MUTE, CH_R), unmute);
969 break;
970 case SND_SOC_DAPM_PRE_PMD:
971 regmap_write(rt721->regmap,
972 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_PDE23,
973 RT721_SDCA_CTL_FU_MUTE, CH_L), mute);
974 regmap_write(rt721->regmap,
975 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_PDE23,
976 RT721_SDCA_CTL_FU_MUTE, CH_R), mute);
977 break;
978 }
979 return 0;
980 }
981
rt721_sdca_fu113_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)982 static int rt721_sdca_fu113_event(struct snd_soc_dapm_widget *w,
983 struct snd_kcontrol *kcontrol, int event)
984 {
985 struct snd_soc_component *component =
986 snd_soc_dapm_to_component(w->dapm);
987 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
988
989 switch (event) {
990 case SND_SOC_DAPM_POST_PMU:
991 rt721->fu1e_dapm_mute = false;
992 rt721_sdca_set_fu1e_capture_ctl(rt721);
993 break;
994 case SND_SOC_DAPM_PRE_PMD:
995 rt721->fu1e_dapm_mute = true;
996 rt721_sdca_set_fu1e_capture_ctl(rt721);
997 break;
998 }
999 return 0;
1000 }
1001
rt721_sdca_fu36_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1002 static int rt721_sdca_fu36_event(struct snd_soc_dapm_widget *w,
1003 struct snd_kcontrol *kcontrol, int event)
1004 {
1005 struct snd_soc_component *component =
1006 snd_soc_dapm_to_component(w->dapm);
1007 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
1008
1009 switch (event) {
1010 case SND_SOC_DAPM_POST_PMU:
1011 rt721->fu0f_dapm_mute = false;
1012 rt721_sdca_set_fu0f_capture_ctl(rt721);
1013 break;
1014 case SND_SOC_DAPM_PRE_PMD:
1015 rt721->fu0f_dapm_mute = true;
1016 rt721_sdca_set_fu0f_capture_ctl(rt721);
1017 break;
1018 }
1019 return 0;
1020 }
1021
rt721_sdca_pde47_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1022 static int rt721_sdca_pde47_event(struct snd_soc_dapm_widget *w,
1023 struct snd_kcontrol *kcontrol, int event)
1024 {
1025 struct snd_soc_component *component =
1026 snd_soc_dapm_to_component(w->dapm);
1027 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
1028 unsigned char ps0 = 0x0, ps3 = 0x3;
1029
1030 switch (event) {
1031 case SND_SOC_DAPM_POST_PMU:
1032 regmap_write(rt721->regmap,
1033 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_PDE40,
1034 RT721_SDCA_CTL_REQ_POWER_STATE, 0), ps0);
1035 break;
1036 case SND_SOC_DAPM_PRE_PMD:
1037 regmap_write(rt721->regmap,
1038 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_PDE40,
1039 RT721_SDCA_CTL_REQ_POWER_STATE, 0), ps3);
1040 break;
1041 }
1042 return 0;
1043 }
1044
rt721_sdca_pde41_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1045 static int rt721_sdca_pde41_event(struct snd_soc_dapm_widget *w,
1046 struct snd_kcontrol *kcontrol, int event)
1047 {
1048 struct snd_soc_component *component =
1049 snd_soc_dapm_to_component(w->dapm);
1050 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
1051 unsigned char ps0 = 0x0, ps3 = 0x3;
1052
1053 switch (event) {
1054 case SND_SOC_DAPM_POST_PMU:
1055 regmap_write(rt721->regmap,
1056 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_PDE41,
1057 RT721_SDCA_CTL_REQ_POWER_STATE, 0), ps0);
1058 break;
1059 case SND_SOC_DAPM_PRE_PMD:
1060 regmap_write(rt721->regmap,
1061 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_PDE41,
1062 RT721_SDCA_CTL_REQ_POWER_STATE, 0), ps3);
1063 break;
1064 }
1065 return 0;
1066 }
1067
rt721_sdca_pde11_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1068 static int rt721_sdca_pde11_event(struct snd_soc_dapm_widget *w,
1069 struct snd_kcontrol *kcontrol, int event)
1070 {
1071 struct snd_soc_component *component =
1072 snd_soc_dapm_to_component(w->dapm);
1073 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
1074 unsigned char ps0 = 0x0, ps3 = 0x3;
1075
1076 switch (event) {
1077 case SND_SOC_DAPM_POST_PMU:
1078 regmap_write(rt721->regmap,
1079 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_PDE2A,
1080 RT721_SDCA_CTL_REQ_POWER_STATE, 0), ps0);
1081 break;
1082 case SND_SOC_DAPM_PRE_PMD:
1083 regmap_write(rt721->regmap,
1084 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_PDE2A,
1085 RT721_SDCA_CTL_REQ_POWER_STATE, 0), ps3);
1086 break;
1087 }
1088 return 0;
1089 }
1090
rt721_sdca_pde34_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * kcontrol,int event)1091 static int rt721_sdca_pde34_event(struct snd_soc_dapm_widget *w,
1092 struct snd_kcontrol *kcontrol, int event)
1093 {
1094 struct snd_soc_component *component =
1095 snd_soc_dapm_to_component(w->dapm);
1096 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
1097 unsigned char ps0 = 0x0, ps3 = 0x3;
1098
1099 switch (event) {
1100 case SND_SOC_DAPM_POST_PMU:
1101 regmap_write(rt721->regmap,
1102 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_PDE12,
1103 RT721_SDCA_CTL_REQ_POWER_STATE, 0), ps0);
1104 break;
1105 case SND_SOC_DAPM_PRE_PMD:
1106 regmap_write(rt721->regmap,
1107 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_PDE12,
1108 RT721_SDCA_CTL_REQ_POWER_STATE, 0), ps3);
1109 break;
1110 }
1111 return 0;
1112 }
1113
1114 static const struct snd_soc_dapm_widget rt721_sdca_dapm_widgets[] = {
1115 SND_SOC_DAPM_OUTPUT("HP"),
1116 SND_SOC_DAPM_OUTPUT("SPK"),
1117 SND_SOC_DAPM_INPUT("MIC2"),
1118 SND_SOC_DAPM_INPUT("LINE1"),
1119 SND_SOC_DAPM_INPUT("LINE2"),
1120 SND_SOC_DAPM_INPUT("DMIC1_2"),
1121 SND_SOC_DAPM_INPUT("DMIC3_4"),
1122
1123 SND_SOC_DAPM_SUPPLY("PDE 41", SND_SOC_NOPM, 0, 0,
1124 rt721_sdca_pde41_event,
1125 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1126 SND_SOC_DAPM_SUPPLY("PDE 47", SND_SOC_NOPM, 0, 0,
1127 rt721_sdca_pde47_event,
1128 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1129 SND_SOC_DAPM_SUPPLY("PDE 11", SND_SOC_NOPM, 0, 0,
1130 rt721_sdca_pde11_event,
1131 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1132 SND_SOC_DAPM_SUPPLY("PDE 34", SND_SOC_NOPM, 0, 0,
1133 rt721_sdca_pde34_event,
1134 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1135
1136 SND_SOC_DAPM_DAC_E("FU 21", NULL, SND_SOC_NOPM, 0, 0,
1137 rt721_sdca_fu21_event,
1138 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1139 SND_SOC_DAPM_DAC_E("FU 23", NULL, SND_SOC_NOPM, 0, 0,
1140 rt721_sdca_fu23_event,
1141 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1142 SND_SOC_DAPM_DAC_E("FU 42", NULL, SND_SOC_NOPM, 0, 0,
1143 rt721_sdca_fu42_event,
1144 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1145 SND_SOC_DAPM_ADC_E("FU 36", NULL, SND_SOC_NOPM, 0, 0,
1146 rt721_sdca_fu36_event,
1147 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1148 SND_SOC_DAPM_ADC_E("FU 113", NULL, SND_SOC_NOPM, 0, 0,
1149 rt721_sdca_fu113_event,
1150 SND_SOC_DAPM_POST_PMU | SND_SOC_DAPM_PRE_PMD),
1151 SND_SOC_DAPM_MUX("ADC 09 Mux", SND_SOC_NOPM, 0, 0,
1152 &rt721_sdca_adc09_mux),
1153 SND_SOC_DAPM_MUX("ADC 08 R Mux", SND_SOC_NOPM, 0, 0,
1154 &rt721_sdca_adc08_r_mux),
1155 SND_SOC_DAPM_MUX("ADC 08 L Mux", SND_SOC_NOPM, 0, 0,
1156 &rt721_sdca_adc08_l_mux),
1157 SND_SOC_DAPM_MUX("ADC 10 R Mux", SND_SOC_NOPM, 0, 0,
1158 &rt721_sdca_adc10_r_mux),
1159 SND_SOC_DAPM_MUX("ADC 10 L Mux", SND_SOC_NOPM, 0, 0,
1160 &rt721_sdca_adc10_l_mux),
1161 SND_SOC_DAPM_MUX("ADC 07 R Mux", SND_SOC_NOPM, 0, 0,
1162 &rt721_sdca_adc07_r_mux),
1163 SND_SOC_DAPM_MUX("ADC 07 L Mux", SND_SOC_NOPM, 0, 0,
1164 &rt721_sdca_adc07_l_mux),
1165
1166 SND_SOC_DAPM_AIF_IN("DP1RX", "DP1 Headphone Playback", 0, SND_SOC_NOPM, 0, 0),
1167 SND_SOC_DAPM_AIF_OUT("DP2TX", "DP2 Headset Capture", 0, SND_SOC_NOPM, 0, 0),
1168 SND_SOC_DAPM_AIF_IN("DP3RX", "DP3 Speaker Playback", 0, SND_SOC_NOPM, 0, 0),
1169 SND_SOC_DAPM_AIF_OUT("DP6TX", "DP6 DMic Capture", 0, SND_SOC_NOPM, 0, 0),
1170 };
1171
1172 static const struct snd_soc_dapm_route rt721_sdca_audio_map[] = {
1173 {"FU 42", NULL, "DP1RX"},
1174 {"FU 21", NULL, "DP3RX"},
1175 {"FU 23", NULL, "DP3RX"},
1176
1177 {"ADC 09 Mux", "MIC2", "MIC2"},
1178 {"ADC 09 Mux", "LINE1", "LINE1"},
1179 {"ADC 09 Mux", "LINE2", "LINE2"},
1180 {"ADC 07 R Mux", "DMIC1 RE", "DMIC1_2"},
1181 {"ADC 07 R Mux", "DMIC1 FE", "DMIC1_2"},
1182 {"ADC 07 R Mux", "DMIC2 RE", "DMIC3_4"},
1183 {"ADC 07 R Mux", "DMIC2 FE", "DMIC3_4"},
1184 {"ADC 07 L Mux", "DMIC1 RE", "DMIC1_2"},
1185 {"ADC 07 L Mux", "DMIC1 FE", "DMIC1_2"},
1186 {"ADC 07 L Mux", "DMIC2 RE", "DMIC3_4"},
1187 {"ADC 07 L Mux", "DMIC2 FE", "DMIC3_4"},
1188 {"ADC 08 R Mux", "DMIC1 RE", "DMIC1_2"},
1189 {"ADC 08 R Mux", "DMIC1 FE", "DMIC1_2"},
1190 {"ADC 08 R Mux", "DMIC2 RE", "DMIC3_4"},
1191 {"ADC 08 R Mux", "DMIC2 FE", "DMIC3_4"},
1192 {"ADC 08 L Mux", "DMIC1 RE", "DMIC1_2"},
1193 {"ADC 08 L Mux", "DMIC1 FE", "DMIC1_2"},
1194 {"ADC 08 L Mux", "DMIC2 RE", "DMIC3_4"},
1195 {"ADC 08 L Mux", "DMIC2 FE", "DMIC3_4"},
1196 {"ADC 10 R Mux", "DMIC1 RE", "DMIC1_2"},
1197 {"ADC 10 R Mux", "DMIC1 FE", "DMIC1_2"},
1198 {"ADC 10 R Mux", "DMIC2 RE", "DMIC3_4"},
1199 {"ADC 10 R Mux", "DMIC2 FE", "DMIC3_4"},
1200 {"ADC 10 L Mux", "DMIC1 RE", "DMIC1_2"},
1201 {"ADC 10 L Mux", "DMIC1 FE", "DMIC1_2"},
1202 {"ADC 10 L Mux", "DMIC2 RE", "DMIC3_4"},
1203 {"ADC 10 L Mux", "DMIC2 FE", "DMIC3_4"},
1204 {"FU 36", NULL, "PDE 34"},
1205 {"FU 36", NULL, "ADC 09 Mux"},
1206 {"FU 113", NULL, "PDE 11"},
1207 {"FU 113", NULL, "ADC 07 R Mux"},
1208 {"FU 113", NULL, "ADC 07 L Mux"},
1209 {"FU 113", NULL, "ADC 10 R Mux"},
1210 {"FU 113", NULL, "ADC 10 L Mux"},
1211 {"DP2TX", NULL, "FU 36"},
1212 {"DP6TX", NULL, "FU 113"},
1213
1214 {"HP", NULL, "PDE 47"},
1215 {"HP", NULL, "FU 42"},
1216 {"SPK", NULL, "PDE 41"},
1217 {"SPK", NULL, "FU 21"},
1218 {"SPK", NULL, "FU 23"},
1219 };
1220
rt721_sdca_parse_dt(struct rt721_sdca_priv * rt721,struct device * dev)1221 static int rt721_sdca_parse_dt(struct rt721_sdca_priv *rt721, struct device *dev)
1222 {
1223 device_property_read_u32(dev, "realtek,jd-src", &rt721->jd_src);
1224
1225 return 0;
1226 }
1227
rt721_sdca_probe(struct snd_soc_component * component)1228 static int rt721_sdca_probe(struct snd_soc_component *component)
1229 {
1230 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
1231 int ret;
1232
1233 rt721_sdca_parse_dt(rt721, &rt721->slave->dev);
1234 rt721->component = component;
1235
1236 ret = pm_runtime_resume(component->dev);
1237 if (ret < 0 && ret != -EACCES)
1238 return ret;
1239
1240 return 0;
1241 }
1242
1243 static const struct snd_soc_component_driver soc_sdca_dev_rt721 = {
1244 .probe = rt721_sdca_probe,
1245 .controls = rt721_sdca_controls,
1246 .num_controls = ARRAY_SIZE(rt721_sdca_controls),
1247 .dapm_widgets = rt721_sdca_dapm_widgets,
1248 .num_dapm_widgets = ARRAY_SIZE(rt721_sdca_dapm_widgets),
1249 .dapm_routes = rt721_sdca_audio_map,
1250 .num_dapm_routes = ARRAY_SIZE(rt721_sdca_audio_map),
1251 .set_jack = rt721_sdca_set_jack_detect,
1252 .endianness = 1,
1253 };
1254
rt721_sdca_set_sdw_stream(struct snd_soc_dai * dai,void * sdw_stream,int direction)1255 static int rt721_sdca_set_sdw_stream(struct snd_soc_dai *dai, void *sdw_stream,
1256 int direction)
1257 {
1258 snd_soc_dai_dma_data_set(dai, direction, sdw_stream);
1259
1260 return 0;
1261 }
1262
rt721_sdca_shutdown(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)1263 static void rt721_sdca_shutdown(struct snd_pcm_substream *substream,
1264 struct snd_soc_dai *dai)
1265 {
1266 snd_soc_dai_set_dma_data(dai, substream, NULL);
1267 }
1268
rt721_sdca_pcm_hw_params(struct snd_pcm_substream * substream,struct snd_pcm_hw_params * params,struct snd_soc_dai * dai)1269 static int rt721_sdca_pcm_hw_params(struct snd_pcm_substream *substream,
1270 struct snd_pcm_hw_params *params,
1271 struct snd_soc_dai *dai)
1272 {
1273 struct snd_soc_component *component = dai->component;
1274 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
1275 struct sdw_stream_config stream_config;
1276 struct sdw_port_config port_config;
1277 enum sdw_data_direction direction;
1278 struct sdw_stream_runtime *sdw_stream;
1279 int retval, port, num_channels;
1280 unsigned int sampling_rate;
1281
1282 dev_dbg(dai->dev, "%s %s", __func__, dai->name);
1283 sdw_stream = snd_soc_dai_get_dma_data(dai, substream);
1284
1285 if (!sdw_stream)
1286 return -EINVAL;
1287
1288 if (!rt721->slave)
1289 return -EINVAL;
1290
1291 /*
1292 * RT721_AIF1 with port = 1 for headphone playback
1293 * RT721_AIF1 with port = 2 for headset-mic capture
1294 * RT721_AIF2 with port = 3 for speaker playback
1295 * RT721_AIF3 with port = 6 for digital-mic capture
1296 */
1297 if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
1298 direction = SDW_DATA_DIR_RX;
1299 if (dai->id == RT721_AIF1)
1300 port = 1;
1301 else if (dai->id == RT721_AIF2)
1302 port = 3;
1303 else
1304 return -EINVAL;
1305 } else {
1306 direction = SDW_DATA_DIR_TX;
1307 if (dai->id == RT721_AIF1)
1308 port = 2;
1309 else if (dai->id == RT721_AIF3)
1310 port = 6;
1311 else
1312 return -EINVAL;
1313 }
1314 stream_config.frame_rate = params_rate(params);
1315 stream_config.ch_count = params_channels(params);
1316 stream_config.bps = snd_pcm_format_width(params_format(params));
1317 stream_config.direction = direction;
1318
1319 num_channels = params_channels(params);
1320 port_config.ch_mask = GENMASK(num_channels - 1, 0);
1321 port_config.num = port;
1322
1323 retval = sdw_stream_add_slave(rt721->slave, &stream_config,
1324 &port_config, 1, sdw_stream);
1325 if (retval) {
1326 dev_err(dai->dev, "Unable to configure port\n");
1327 return retval;
1328 }
1329
1330 if (params_channels(params) > 16) {
1331 dev_err(component->dev, "Unsupported channels %d\n",
1332 params_channels(params));
1333 return -EINVAL;
1334 }
1335
1336 /* sampling rate configuration */
1337 switch (params_rate(params)) {
1338 case 8000:
1339 sampling_rate = RT721_SDCA_RATE_8000HZ;
1340 break;
1341 case 16000:
1342 sampling_rate = RT721_SDCA_RATE_16000HZ;
1343 break;
1344 case 24000:
1345 sampling_rate = RT721_SDCA_RATE_24000HZ;
1346 break;
1347 case 32000:
1348 sampling_rate = RT721_SDCA_RATE_32000HZ;
1349 break;
1350 case 44100:
1351 sampling_rate = RT721_SDCA_RATE_44100HZ;
1352 break;
1353 case 48000:
1354 sampling_rate = RT721_SDCA_RATE_48000HZ;
1355 break;
1356 case 96000:
1357 sampling_rate = RT721_SDCA_RATE_96000HZ;
1358 break;
1359 case 192000:
1360 sampling_rate = RT721_SDCA_RATE_192000HZ;
1361 break;
1362 case 384000:
1363 sampling_rate = RT721_SDCA_RATE_384000HZ;
1364 break;
1365 case 768000:
1366 sampling_rate = RT721_SDCA_RATE_768000HZ;
1367 break;
1368 default:
1369 dev_err(component->dev, "Rate %d is not supported\n",
1370 params_rate(params));
1371 return -EINVAL;
1372 }
1373
1374 /* set sampling frequency */
1375 if (dai->id == RT721_AIF1) {
1376 regmap_write(rt721->regmap,
1377 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_CS01,
1378 RT721_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), sampling_rate);
1379 regmap_write(rt721->regmap,
1380 SDW_SDCA_CTL(FUNC_NUM_JACK_CODEC, RT721_SDCA_ENT_CS11,
1381 RT721_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), sampling_rate);
1382 }
1383
1384 if (dai->id == RT721_AIF2)
1385 regmap_write(rt721->regmap,
1386 SDW_SDCA_CTL(FUNC_NUM_AMP, RT721_SDCA_ENT_CS31,
1387 RT721_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), sampling_rate);
1388
1389 if (dai->id == RT721_AIF3)
1390 regmap_write(rt721->regmap,
1391 SDW_SDCA_CTL(FUNC_NUM_MIC_ARRAY, RT721_SDCA_ENT_CS1F,
1392 RT721_SDCA_CTL_SAMPLE_FREQ_INDEX, 0), sampling_rate);
1393
1394 return 0;
1395 }
1396
rt721_sdca_pcm_hw_free(struct snd_pcm_substream * substream,struct snd_soc_dai * dai)1397 static int rt721_sdca_pcm_hw_free(struct snd_pcm_substream *substream,
1398 struct snd_soc_dai *dai)
1399 {
1400 struct snd_soc_component *component = dai->component;
1401 struct rt721_sdca_priv *rt721 = snd_soc_component_get_drvdata(component);
1402 struct sdw_stream_runtime *sdw_stream =
1403 snd_soc_dai_get_dma_data(dai, substream);
1404
1405 if (!rt721->slave)
1406 return -EINVAL;
1407
1408 sdw_stream_remove_slave(rt721->slave, sdw_stream);
1409 return 0;
1410 }
1411
1412 #define RT721_STEREO_RATES (SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | \
1413 SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_192000)
1414 #define RT721_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S20_3LE | \
1415 SNDRV_PCM_FMTBIT_S24_LE)
1416
1417 static const struct snd_soc_dai_ops rt721_sdca_ops = {
1418 .hw_params = rt721_sdca_pcm_hw_params,
1419 .hw_free = rt721_sdca_pcm_hw_free,
1420 .set_stream = rt721_sdca_set_sdw_stream,
1421 .shutdown = rt721_sdca_shutdown,
1422 };
1423
1424 static struct snd_soc_dai_driver rt721_sdca_dai[] = {
1425 {
1426 .name = "rt721-sdca-aif1",
1427 .id = RT721_AIF1,
1428 .playback = {
1429 .stream_name = "DP1 Headphone Playback",
1430 .channels_min = 1,
1431 .channels_max = 2,
1432 .rates = RT721_STEREO_RATES,
1433 .formats = RT721_FORMATS,
1434 },
1435 .capture = {
1436 .stream_name = "DP2 Headset Capture",
1437 .channels_min = 1,
1438 .channels_max = 2,
1439 .rates = RT721_STEREO_RATES,
1440 .formats = RT721_FORMATS,
1441 },
1442 .ops = &rt721_sdca_ops,
1443 },
1444 {
1445 .name = "rt721-sdca-aif2",
1446 .id = RT721_AIF2,
1447 .playback = {
1448 .stream_name = "DP3 Speaker Playback",
1449 .channels_min = 1,
1450 .channels_max = 2,
1451 .rates = RT721_STEREO_RATES,
1452 .formats = RT721_FORMATS,
1453 },
1454 .ops = &rt721_sdca_ops,
1455 },
1456 {
1457 .name = "rt721-sdca-aif3",
1458 .id = RT721_AIF3,
1459 .capture = {
1460 .stream_name = "DP6 DMic Capture",
1461 .channels_min = 1,
1462 .channels_max = 4,
1463 .rates = RT721_STEREO_RATES,
1464 .formats = RT721_FORMATS,
1465 },
1466 .ops = &rt721_sdca_ops,
1467 }
1468 };
1469
rt721_sdca_init(struct device * dev,struct regmap * regmap,struct regmap * mbq_regmap,struct sdw_slave * slave)1470 int rt721_sdca_init(struct device *dev, struct regmap *regmap,
1471 struct regmap *mbq_regmap, struct sdw_slave *slave)
1472 {
1473 struct rt721_sdca_priv *rt721;
1474
1475 rt721 = devm_kzalloc(dev, sizeof(*rt721), GFP_KERNEL);
1476 if (!rt721)
1477 return -ENOMEM;
1478
1479 dev_set_drvdata(dev, rt721);
1480 rt721->slave = slave;
1481 rt721->regmap = regmap;
1482 rt721->mbq_regmap = mbq_regmap;
1483
1484 regcache_cache_only(rt721->regmap, true);
1485 regcache_cache_only(rt721->mbq_regmap, true);
1486
1487 mutex_init(&rt721->calibrate_mutex);
1488 mutex_init(&rt721->disable_irq_lock);
1489
1490 INIT_DELAYED_WORK(&rt721->jack_detect_work, rt721_sdca_jack_detect_handler);
1491 INIT_DELAYED_WORK(&rt721->jack_btn_check_work, rt721_sdca_btn_check_handler);
1492
1493 /*
1494 * Mark hw_init to false
1495 * HW init will be performed when device reports present
1496 */
1497 rt721->hw_init = false;
1498 rt721->first_hw_init = false;
1499 rt721->fu1e_dapm_mute = true;
1500 rt721->fu0f_dapm_mute = true;
1501 rt721->fu0f_mixer_l_mute = rt721->fu0f_mixer_r_mute = true;
1502 rt721->fu1e_mixer_mute[0] = rt721->fu1e_mixer_mute[1] =
1503 rt721->fu1e_mixer_mute[2] = rt721->fu1e_mixer_mute[3] = true;
1504
1505 return devm_snd_soc_register_component(dev,
1506 &soc_sdca_dev_rt721, rt721_sdca_dai, ARRAY_SIZE(rt721_sdca_dai));
1507 }
1508
rt721_sdca_io_init(struct device * dev,struct sdw_slave * slave)1509 int rt721_sdca_io_init(struct device *dev, struct sdw_slave *slave)
1510 {
1511 struct rt721_sdca_priv *rt721 = dev_get_drvdata(dev);
1512
1513 rt721->disable_irq = false;
1514
1515 if (rt721->hw_init)
1516 return 0;
1517
1518 regcache_cache_only(rt721->regmap, false);
1519 regcache_cache_only(rt721->mbq_regmap, false);
1520 if (rt721->first_hw_init) {
1521 regcache_cache_bypass(rt721->regmap, true);
1522 regcache_cache_bypass(rt721->mbq_regmap, true);
1523 } else {
1524 /*
1525 * PM runtime is only enabled when a Slave reports as Attached
1526 */
1527
1528 /* set autosuspend parameters */
1529 pm_runtime_set_autosuspend_delay(&slave->dev, 3000);
1530 pm_runtime_use_autosuspend(&slave->dev);
1531
1532 /* update count of parent 'active' children */
1533 pm_runtime_set_active(&slave->dev);
1534
1535 /* make sure the device does not suspend immediately */
1536 pm_runtime_mark_last_busy(&slave->dev);
1537
1538 pm_runtime_enable(&slave->dev);
1539 }
1540
1541 pm_runtime_get_noresume(&slave->dev);
1542 rt721_sdca_dmic_preset(rt721);
1543 rt721_sdca_amp_preset(rt721);
1544 rt721_sdca_jack_preset(rt721);
1545 if (rt721->first_hw_init) {
1546 regcache_cache_bypass(rt721->regmap, false);
1547 regcache_mark_dirty(rt721->regmap);
1548 regcache_cache_bypass(rt721->mbq_regmap, false);
1549 regcache_mark_dirty(rt721->mbq_regmap);
1550 } else
1551 rt721->first_hw_init = true;
1552
1553 /* Mark Slave initialization complete */
1554 rt721->hw_init = true;
1555
1556 pm_runtime_put_autosuspend(&slave->dev);
1557
1558 dev_dbg(&slave->dev, "%s hw_init complete\n", __func__);
1559 return 0;
1560 }
1561
1562 MODULE_DESCRIPTION("ASoC RT721 SDCA SDW driver");
1563 MODULE_AUTHOR("Jack Yu <jack.yu@realtek.com>");
1564 MODULE_LICENSE("GPL");
1565