1 // SPDX-License-Identifier: GPL-2.0-only
2 //
3 // aw88166.c -- ALSA SoC AW88166 codec support
4 //
5 // Copyright (c) 2025 AWINIC Technology CO., LTD
6 //
7 // Author: Weidong Wang <wangweidong.a@awinic.com>
8 //
9
10 #include <linux/crc32.h>
11 #include <linux/firmware.h>
12 #include <linux/gpio/consumer.h>
13 #include <linux/i2c.h>
14 #include <linux/minmax.h>
15 #include <linux/regmap.h>
16 #include <sound/soc.h>
17 #include "aw88166.h"
18 #include "aw88395/aw88395_device.h"
19
20 struct aw88166 {
21 struct aw_device *aw_pa;
22 struct mutex lock;
23 struct gpio_desc *reset_gpio;
24 struct delayed_work start_work;
25 struct regmap *regmap;
26 struct aw_container *aw_cfg;
27
28 unsigned int check_val;
29 unsigned int crc_init_val;
30 unsigned int vcalb_init_val;
31 unsigned int re_init_val;
32 unsigned int dither_st;
33 bool phase_sync;
34 };
35
36 static const struct regmap_config aw88166_remap_config = {
37 .val_bits = 16,
38 .reg_bits = 8,
39 .max_register = AW88166_REG_MAX,
40 .reg_format_endian = REGMAP_ENDIAN_LITTLE,
41 .val_format_endian = REGMAP_ENDIAN_BIG,
42 };
43
aw_dev_dsp_write_16bit(struct aw_device * aw_dev,unsigned short dsp_addr,unsigned int dsp_data)44 static int aw_dev_dsp_write_16bit(struct aw_device *aw_dev,
45 unsigned short dsp_addr, unsigned int dsp_data)
46 {
47 int ret;
48
49 ret = regmap_write(aw_dev->regmap, AW88166_DSPMADD_REG, dsp_addr);
50 if (ret) {
51 dev_err(aw_dev->dev, "%s write addr error, ret=%d", __func__, ret);
52 return ret;
53 }
54
55 ret = regmap_write(aw_dev->regmap, AW88166_DSPMDAT_REG, (u16)dsp_data);
56 if (ret) {
57 dev_err(aw_dev->dev, "%s write data error, ret=%d", __func__, ret);
58 return ret;
59 }
60
61 return 0;
62 }
63
aw_dev_dsp_read_16bit(struct aw_device * aw_dev,unsigned short dsp_addr,unsigned int * dsp_data)64 static int aw_dev_dsp_read_16bit(struct aw_device *aw_dev,
65 unsigned short dsp_addr, unsigned int *dsp_data)
66 {
67 unsigned int temp_data;
68 int ret;
69
70 ret = regmap_write(aw_dev->regmap, AW88166_DSPMADD_REG, dsp_addr);
71 if (ret) {
72 dev_err(aw_dev->dev, "%s write error, ret=%d", __func__, ret);
73 return ret;
74 }
75
76 ret = regmap_read(aw_dev->regmap, AW88166_DSPMDAT_REG, &temp_data);
77 if (ret) {
78 dev_err(aw_dev->dev, "%s read error, ret=%d", __func__, ret);
79 return ret;
80 }
81 *dsp_data = temp_data;
82
83 return 0;
84 }
85
aw_dev_dsp_read_32bit(struct aw_device * aw_dev,unsigned short dsp_addr,unsigned int * dsp_data)86 static int aw_dev_dsp_read_32bit(struct aw_device *aw_dev,
87 unsigned short dsp_addr, unsigned int *dsp_data)
88 {
89 unsigned int temp_data;
90 int ret;
91
92 ret = regmap_write(aw_dev->regmap, AW88166_DSPMADD_REG, dsp_addr);
93 if (ret) {
94 dev_err(aw_dev->dev, "%s write error, ret=%d", __func__, ret);
95 return ret;
96 }
97
98 ret = regmap_read(aw_dev->regmap, AW88166_DSPMDAT_REG, &temp_data);
99 if (ret) {
100 dev_err(aw_dev->dev, "%s read error, ret=%d", __func__, ret);
101 return ret;
102 }
103 *dsp_data = temp_data;
104
105 ret = regmap_read(aw_dev->regmap, AW88166_DSPMDAT_REG, &temp_data);
106 if (ret) {
107 dev_err(aw_dev->dev, "%s read error, ret=%d", __func__, ret);
108 return ret;
109 }
110 *dsp_data |= (temp_data << 16);
111
112 return 0;
113 }
114
aw_dev_dsp_read(struct aw_device * aw_dev,unsigned short dsp_addr,unsigned int * dsp_data,unsigned char data_type)115 static int aw_dev_dsp_read(struct aw_device *aw_dev,
116 unsigned short dsp_addr, unsigned int *dsp_data, unsigned char data_type)
117 {
118 u32 reg_value;
119 int ret;
120
121 mutex_lock(&aw_dev->dsp_lock);
122 switch (data_type) {
123 case AW88166_DSP_16_DATA:
124 ret = aw_dev_dsp_read_16bit(aw_dev, dsp_addr, dsp_data);
125 if (ret)
126 dev_err(aw_dev->dev, "read dsp_addr[0x%x] 16-bit failed", (u32)dsp_addr);
127 break;
128 case AW88166_DSP_32_DATA:
129 ret = aw_dev_dsp_read_32bit(aw_dev, dsp_addr, dsp_data);
130 if (ret)
131 dev_err(aw_dev->dev, "read dsp_addr[0x%x] 32-bit failed", (u32)dsp_addr);
132 break;
133 default:
134 dev_err(aw_dev->dev, "data type[%d] unsupported", data_type);
135 ret = -EINVAL;
136 break;
137 }
138
139 /* clear dsp chip select state */
140 if (regmap_read(aw_dev->regmap, AW88166_ID_REG, ®_value))
141 dev_err(aw_dev->dev, "%s fail to clear chip state. ret=%d\n", __func__, ret);
142 mutex_unlock(&aw_dev->dsp_lock);
143
144 return ret;
145 }
146
aw_dev_pwd(struct aw_device * aw_dev,bool pwd)147 static void aw_dev_pwd(struct aw_device *aw_dev, bool pwd)
148 {
149 int ret;
150
151 if (pwd)
152 ret = regmap_update_bits(aw_dev->regmap, AW88166_SYSCTRL_REG,
153 ~AW88166_PWDN_MASK, AW88166_PWDN_POWER_DOWN_VALUE);
154 else
155 ret = regmap_update_bits(aw_dev->regmap, AW88166_SYSCTRL_REG,
156 ~AW88166_PWDN_MASK, AW88166_PWDN_WORKING_VALUE);
157
158 if (ret)
159 dev_dbg(aw_dev->dev, "%s failed", __func__);
160 }
161
aw_dev_get_int_status(struct aw_device * aw_dev,unsigned short * int_status)162 static void aw_dev_get_int_status(struct aw_device *aw_dev, unsigned short *int_status)
163 {
164 unsigned int reg_val;
165 int ret;
166
167 ret = regmap_read(aw_dev->regmap, AW88166_SYSINT_REG, ®_val);
168 if (ret)
169 dev_err(aw_dev->dev, "read interrupt reg fail, ret=%d", ret);
170 else
171 *int_status = reg_val;
172
173 dev_dbg(aw_dev->dev, "read interrupt reg=0x%04x", *int_status);
174 }
175
aw_dev_clear_int_status(struct aw_device * aw_dev)176 static void aw_dev_clear_int_status(struct aw_device *aw_dev)
177 {
178 u16 int_status;
179
180 /* read int status and clear */
181 aw_dev_get_int_status(aw_dev, &int_status);
182 /* make sure int status is clear */
183 aw_dev_get_int_status(aw_dev, &int_status);
184 if (int_status)
185 dev_dbg(aw_dev->dev, "int status(%d) is not cleaned.\n", int_status);
186 }
187
aw_dev_get_iis_status(struct aw_device * aw_dev)188 static int aw_dev_get_iis_status(struct aw_device *aw_dev)
189 {
190 unsigned int reg_val;
191 int ret;
192
193 ret = regmap_read(aw_dev->regmap, AW88166_SYSST_REG, ®_val);
194 if (ret)
195 return ret;
196 if ((reg_val & AW88166_BIT_PLL_CHECK) != AW88166_BIT_PLL_CHECK) {
197 dev_err(aw_dev->dev, "check pll lock fail, reg_val:0x%04x", reg_val);
198 return -EINVAL;
199 }
200
201 return 0;
202 }
203
aw_dev_check_mode1_pll(struct aw_device * aw_dev)204 static int aw_dev_check_mode1_pll(struct aw_device *aw_dev)
205 {
206 int ret, i;
207
208 for (i = 0; i < AW88166_DEV_SYSST_CHECK_MAX; i++) {
209 ret = aw_dev_get_iis_status(aw_dev);
210 if (ret) {
211 dev_err(aw_dev->dev, "mode1 iis signal check error");
212 usleep_range(AW88166_2000_US, AW88166_2000_US + 10);
213 } else {
214 return 0;
215 }
216 }
217
218 return -EPERM;
219 }
220
aw_dev_check_mode2_pll(struct aw_device * aw_dev)221 static int aw_dev_check_mode2_pll(struct aw_device *aw_dev)
222 {
223 unsigned int reg_val;
224 int ret, i;
225
226 ret = regmap_read(aw_dev->regmap, AW88166_PLLCTRL2_REG, ®_val);
227 if (ret)
228 return ret;
229
230 reg_val &= (~AW88166_CCO_MUX_MASK);
231 if (reg_val == AW88166_CCO_MUX_DIVIDED_VALUE) {
232 dev_dbg(aw_dev->dev, "CCO_MUX is already divider");
233 return -EPERM;
234 }
235
236 /* change mode2 */
237 ret = regmap_update_bits(aw_dev->regmap, AW88166_PLLCTRL2_REG,
238 ~AW88166_CCO_MUX_MASK, AW88166_CCO_MUX_DIVIDED_VALUE);
239 if (ret)
240 return ret;
241
242 for (i = 0; i < AW88166_DEV_SYSST_CHECK_MAX; i++) {
243 ret = aw_dev_get_iis_status(aw_dev);
244 if (ret) {
245 dev_err(aw_dev->dev, "mode2 iis signal check error");
246 usleep_range(AW88166_2000_US, AW88166_2000_US + 10);
247 } else {
248 break;
249 }
250 }
251
252 /* change mode1 */
253 regmap_update_bits(aw_dev->regmap, AW88166_PLLCTRL2_REG,
254 ~AW88166_CCO_MUX_MASK, AW88166_CCO_MUX_BYPASS_VALUE);
255 if (ret == 0) {
256 usleep_range(AW88166_2000_US, AW88166_2000_US + 10);
257 for (i = 0; i < AW88166_DEV_SYSST_CHECK_MAX; i++) {
258 ret = aw_dev_get_iis_status(aw_dev);
259 if (ret) {
260 dev_err(aw_dev->dev, "mode2 switch to mode1, iis signal check error");
261 usleep_range(AW88166_2000_US, AW88166_2000_US + 10);
262 } else {
263 break;
264 }
265 }
266 }
267
268 return ret;
269 }
270
aw_dev_check_syspll(struct aw_device * aw_dev)271 static int aw_dev_check_syspll(struct aw_device *aw_dev)
272 {
273 int ret;
274
275 ret = aw_dev_check_mode1_pll(aw_dev);
276 if (ret) {
277 dev_dbg(aw_dev->dev, "mode1 check iis failed try switch to mode2 check");
278 ret = aw_dev_check_mode2_pll(aw_dev);
279 if (ret) {
280 dev_err(aw_dev->dev, "mode2 check iis failed");
281 return ret;
282 }
283 }
284
285 return 0;
286 }
287
aw_dev_check_sysst(struct aw_device * aw_dev)288 static int aw_dev_check_sysst(struct aw_device *aw_dev)
289 {
290 unsigned int check_val;
291 unsigned int reg_val;
292 int ret, i;
293
294 ret = regmap_read(aw_dev->regmap, AW88166_PWMCTRL3_REG, ®_val);
295 if (ret)
296 return ret;
297
298 if (reg_val & (~AW88166_NOISE_GATE_EN_MASK))
299 check_val = AW88166_BIT_SYSST_NOSWS_CHECK;
300 else
301 check_val = AW88166_BIT_SYSST_SWS_CHECK;
302
303 for (i = 0; i < AW88166_DEV_SYSST_CHECK_MAX; i++) {
304 ret = regmap_read(aw_dev->regmap, AW88166_SYSST_REG, ®_val);
305 if (ret)
306 return ret;
307
308 if ((reg_val & (~AW88166_BIT_SYSST_CHECK_MASK) & check_val) != check_val) {
309 dev_err(aw_dev->dev, "check sysst fail, cnt=%d, reg_val=0x%04x, check:0x%x",
310 i, reg_val, AW88166_BIT_SYSST_NOSWS_CHECK);
311 usleep_range(AW88166_2000_US, AW88166_2000_US + 10);
312 } else {
313 return 0;
314 }
315 }
316
317 return -EPERM;
318 }
319
aw_dev_amppd(struct aw_device * aw_dev,bool amppd)320 static void aw_dev_amppd(struct aw_device *aw_dev, bool amppd)
321 {
322 int ret;
323
324 if (amppd)
325 ret = regmap_update_bits(aw_dev->regmap, AW88166_SYSCTRL_REG,
326 ~AW88166_AMPPD_MASK, AW88166_AMPPD_POWER_DOWN_VALUE);
327 else
328 ret = regmap_update_bits(aw_dev->regmap, AW88166_SYSCTRL_REG,
329 ~AW88166_AMPPD_MASK, AW88166_AMPPD_WORKING_VALUE);
330
331 if (ret)
332 dev_dbg(aw_dev->dev, "%s failed", __func__);
333 }
334
aw_dev_dsp_enable(struct aw_device * aw_dev,bool is_enable)335 static void aw_dev_dsp_enable(struct aw_device *aw_dev, bool is_enable)
336 {
337 int ret;
338
339 if (is_enable)
340 ret = regmap_update_bits(aw_dev->regmap, AW88166_SYSCTRL_REG,
341 ~AW88166_DSPBY_MASK, AW88166_DSPBY_WORKING_VALUE);
342 else
343 ret = regmap_update_bits(aw_dev->regmap, AW88166_SYSCTRL_REG,
344 ~AW88166_DSPBY_MASK, AW88166_DSPBY_BYPASS_VALUE);
345
346 if (ret)
347 dev_dbg(aw_dev->dev, "%s failed\n", __func__);
348 }
349
aw88166_dev_get_icalk(struct aw88166 * aw88166,int16_t * icalk)350 static int aw88166_dev_get_icalk(struct aw88166 *aw88166, int16_t *icalk)
351 {
352 struct aw_device *aw_dev = aw88166->aw_pa;
353 unsigned int efrm_reg_val, efrl_reg_val;
354 uint16_t ef_isn_geslp, ef_isn_h5bits;
355 uint16_t icalk_val;
356 int ret;
357
358 ret = regmap_read(aw_dev->regmap, AW88166_EFRM2_REG, &efrm_reg_val);
359 if (ret)
360 return ret;
361
362 ef_isn_geslp = (efrm_reg_val & (~AW88166_EF_ISN_GESLP_MASK)) >>
363 AW88166_EF_ISN_GESLP_SHIFT;
364
365 ret = regmap_read(aw_dev->regmap, AW88166_EFRL_REG, &efrl_reg_val);
366 if (ret)
367 return ret;
368
369 ef_isn_h5bits = (efrl_reg_val & (~AW88166_EF_ISN_H5BITS_MASK)) >>
370 AW88166_EF_ISN_H5BITS_SHIFT;
371
372 if (aw88166->check_val == AW_EF_AND_CHECK)
373 icalk_val = ef_isn_geslp & (ef_isn_h5bits | AW88166_EF_ISN_H5BITS_SIGN_MASK);
374 else
375 icalk_val = ef_isn_geslp | (ef_isn_h5bits & (~AW88166_EF_ISN_H5BITS_SIGN_MASK));
376
377 if (icalk_val & (~AW88166_ICALK_SIGN_MASK))
378 icalk_val = icalk_val | AW88166_ICALK_NEG_MASK;
379 *icalk = (int16_t)icalk_val;
380
381 return 0;
382 }
383
aw88166_dev_get_vcalk(struct aw88166 * aw88166,int16_t * vcalk)384 static int aw88166_dev_get_vcalk(struct aw88166 *aw88166, int16_t *vcalk)
385 {
386 struct aw_device *aw_dev = aw88166->aw_pa;
387 unsigned int efrm_reg_val, efrl_reg_val;
388 uint16_t ef_vsn_geslp, ef_vsn_h3bits;
389 uint16_t vcalk_val;
390 int ret;
391
392 ret = regmap_read(aw_dev->regmap, AW88166_EFRM2_REG, &efrm_reg_val);
393 if (ret)
394 return ret;
395
396 ef_vsn_geslp = (efrm_reg_val & (~AW88166_EF_VSN_GESLP_MASK)) >>
397 AW88166_EF_VSN_GESLP_SHIFT;
398
399 ret = regmap_read(aw_dev->regmap, AW88166_EFRL_REG, &efrl_reg_val);
400 if (ret)
401 return ret;
402
403 ef_vsn_h3bits = (efrl_reg_val & (~AW88166_EF_VSN_H3BITS_MASK)) >>
404 AW88166_EF_VSN_H3BITS_SHIFT;
405
406 if (aw88166->check_val == AW_EF_AND_CHECK)
407 vcalk_val = ef_vsn_geslp & (ef_vsn_h3bits | AW88166_EF_VSN_H3BITS_SIGN_MASK);
408 else
409 vcalk_val = ef_vsn_geslp | (ef_vsn_h3bits & (~AW88166_EF_VSN_H3BITS_SIGN_MASK));
410
411 if (vcalk_val & (~AW88166_VCALK_SIGN_MASK))
412 vcalk_val = vcalk_val | AW88166_VCALK_NEG_MASK;
413 *vcalk = (int16_t)vcalk_val;
414
415 return 0;
416 }
417
aw88166_dev_set_vcalb(struct aw88166 * aw88166)418 static int aw88166_dev_set_vcalb(struct aw88166 *aw88166)
419 {
420 struct aw_device *aw_dev = aw88166->aw_pa;
421 int32_t ical_k, vcal_k, vcalb;
422 int16_t icalk, vcalk;
423 unsigned int reg_val;
424 int ret;
425
426 ret = aw88166_dev_get_icalk(aw88166, &icalk);
427 if (ret) {
428 dev_err(aw_dev->dev, "get icalk failed\n");
429 return ret;
430 }
431 ical_k = icalk * AW88166_ICABLK_FACTOR + AW88166_CABL_BASE_VALUE;
432
433 ret = aw88166_dev_get_vcalk(aw88166, &vcalk);
434 if (ret) {
435 dev_err(aw_dev->dev, "get vbcalk failed\n");
436 return ret;
437 }
438 vcal_k = vcalk * AW88166_VCABLK_FACTOR + AW88166_CABL_BASE_VALUE;
439
440 vcalb = AW88166_VCALB_ACCURACY * AW88166_VSCAL_FACTOR /
441 AW88166_ISCAL_FACTOR * ical_k / vcal_k * aw88166->vcalb_init_val;
442
443 vcalb = vcalb >> AW88166_VCALB_ADJ_FACTOR;
444 reg_val = (uint32_t)vcalb;
445
446 regmap_write(aw_dev->regmap, AW88166_DSPVCALB_REG, reg_val);
447
448 return 0;
449 }
450
aw_dev_init_vcalb_update(struct aw88166 * aw88166,int flag)451 static int aw_dev_init_vcalb_update(struct aw88166 *aw88166, int flag)
452 {
453 struct aw_device *aw_dev = aw88166->aw_pa;
454 int ret;
455
456 switch (flag) {
457 case AW88166_RECOVERY_SEC_DATA:
458 ret = regmap_write(aw_dev->regmap, AW88166_DSPVCALB_REG, aw88166->vcalb_init_val);
459 break;
460 case AW88166_RECORD_SEC_DATA:
461 ret = regmap_read(aw_dev->regmap, AW88166_DSPVCALB_REG, &aw88166->vcalb_init_val);
462 break;
463 default:
464 dev_err(aw_dev->dev, "unsupported type:%d\n", flag);
465 ret = -EINVAL;
466 break;
467 }
468
469 return ret;
470 }
471
aw_dev_init_re_update(struct aw88166 * aw88166,int flag)472 static int aw_dev_init_re_update(struct aw88166 *aw88166, int flag)
473 {
474 struct aw_device *aw_dev = aw88166->aw_pa;
475 unsigned int re_temp_h, re_temp_l;
476 int ret;
477
478 switch (flag) {
479 case AW88166_RECOVERY_SEC_DATA:
480 ret = regmap_write(aw_dev->regmap, AW88166_ACR1_REG, aw88166->re_init_val >> 16);
481 if (ret)
482 return ret;
483 ret = regmap_write(aw_dev->regmap, AW88166_ACR2_REG,
484 (uint16_t)aw88166->re_init_val);
485 if (ret)
486 return ret;
487 break;
488 case AW88166_RECORD_SEC_DATA:
489 ret = regmap_read(aw_dev->regmap, AW88166_ACR1_REG, &re_temp_h);
490 if (ret)
491 return ret;
492 ret = regmap_read(aw_dev->regmap, AW88166_ACR2_REG, &re_temp_l);
493 if (ret)
494 return ret;
495 aw88166->re_init_val = (re_temp_h << 16) + re_temp_l;
496 break;
497 default:
498 dev_err(aw_dev->dev, "unsupported type:%d\n", flag);
499 ret = -EINVAL;
500 break;
501 }
502
503 return ret;
504 }
505
aw_dev_backup_sec_record(struct aw88166 * aw88166)506 static void aw_dev_backup_sec_record(struct aw88166 *aw88166)
507 {
508 aw_dev_init_vcalb_update(aw88166, AW88166_RECORD_SEC_DATA);
509 aw_dev_init_re_update(aw88166, AW88166_RECOVERY_SEC_DATA);
510 }
511
aw_dev_backup_sec_recovery(struct aw88166 * aw88166)512 static void aw_dev_backup_sec_recovery(struct aw88166 *aw88166)
513 {
514 aw_dev_init_vcalb_update(aw88166, AW88166_RECOVERY_SEC_DATA);
515 aw_dev_init_re_update(aw88166, AW88166_RECOVERY_SEC_DATA);
516 }
517
aw_dev_update_cali_re(struct aw_cali_desc * cali_desc)518 static int aw_dev_update_cali_re(struct aw_cali_desc *cali_desc)
519 {
520 struct aw_device *aw_dev =
521 container_of(cali_desc, struct aw_device, cali_desc);
522 uint16_t re_lbits, re_hbits;
523 u32 cali_re;
524 int ret;
525
526 if ((aw_dev->cali_desc.cali_re >= AW88166_CALI_RE_MAX) ||
527 (aw_dev->cali_desc.cali_re <= AW88166_CALI_RE_MIN))
528 return -EINVAL;
529
530 cali_re = AW88166_SHOW_RE_TO_DSP_RE((aw_dev->cali_desc.cali_re +
531 aw_dev->cali_desc.ra), AW88166_DSP_RE_SHIFT);
532
533 re_hbits = (cali_re & (~AW88166_CALI_RE_HBITS_MASK)) >> AW88166_CALI_RE_HBITS_SHIFT;
534 re_lbits = (cali_re & (~AW88166_CALI_RE_LBITS_MASK)) >> AW88166_CALI_RE_LBITS_SHIFT;
535
536 ret = regmap_write(aw_dev->regmap, AW88166_ACR1_REG, re_hbits);
537 if (ret) {
538 dev_err(aw_dev->dev, "set cali re error");
539 return ret;
540 }
541
542 ret = regmap_write(aw_dev->regmap, AW88166_ACR2_REG, re_lbits);
543 if (ret)
544 dev_err(aw_dev->dev, "set cali re error");
545
546 return ret;
547 }
548
aw_dev_fw_crc_check(struct aw_device * aw_dev)549 static int aw_dev_fw_crc_check(struct aw_device *aw_dev)
550 {
551 uint16_t check_val, fw_len_val;
552 unsigned int reg_val;
553 int ret;
554
555 /* calculate fw_end_addr */
556 fw_len_val = ((aw_dev->dsp_fw_len / AW_FW_ADDR_LEN) - 1) + AW88166_CRC_FW_BASE_ADDR;
557
558 /* write fw_end_addr to crc_end_addr */
559 ret = regmap_update_bits(aw_dev->regmap, AW88166_CRCCTRL_REG,
560 ~AW88166_CRC_END_ADDR_MASK, fw_len_val);
561 if (ret)
562 return ret;
563 /* enable fw crc check */
564 ret = regmap_update_bits(aw_dev->regmap, AW88166_CRCCTRL_REG,
565 ~AW88166_CRC_CODE_EN_MASK, AW88166_CRC_CODE_EN_ENABLE_VALUE);
566
567 usleep_range(AW88166_2000_US, AW88166_2000_US + 10);
568
569 /* read crc check result */
570 regmap_read(aw_dev->regmap, AW88166_HAGCST_REG, ®_val);
571 if (ret)
572 return ret;
573
574 check_val = (reg_val & (~AW88166_CRC_CHECK_BITS_MASK)) >> AW88166_CRC_CHECK_START_BIT;
575
576 /* disable fw crc check */
577 ret = regmap_update_bits(aw_dev->regmap, AW88166_CRCCTRL_REG,
578 ~AW88166_CRC_CODE_EN_MASK, AW88166_CRC_CODE_EN_DISABLE_VALUE);
579 if (ret)
580 return ret;
581
582 if (check_val != AW88166_CRC_CHECK_PASS_VAL) {
583 dev_err(aw_dev->dev, "%s failed, check_val 0x%x != 0x%x\n",
584 __func__, check_val, AW88166_CRC_CHECK_PASS_VAL);
585 ret = -EINVAL;
586 }
587
588 return ret;
589 }
590
aw_dev_cfg_crc_check(struct aw_device * aw_dev)591 static int aw_dev_cfg_crc_check(struct aw_device *aw_dev)
592 {
593 uint16_t check_val, cfg_len_val;
594 unsigned int reg_val;
595 int ret;
596
597 /* calculate cfg end addr */
598 cfg_len_val = ((aw_dev->dsp_cfg_len / AW_FW_ADDR_LEN) - 1) + AW88166_CRC_CFG_BASE_ADDR;
599
600 /* write cfg_end_addr to crc_end_addr */
601 ret = regmap_update_bits(aw_dev->regmap, AW88166_CRCCTRL_REG,
602 ~AW88166_CRC_END_ADDR_MASK, cfg_len_val);
603 if (ret)
604 return ret;
605
606 /* enable cfg crc check */
607 ret = regmap_update_bits(aw_dev->regmap, AW88166_CRCCTRL_REG,
608 ~AW88166_CRC_CFG_EN_MASK, AW88166_CRC_CFG_EN_ENABLE_VALUE);
609 if (ret)
610 return ret;
611
612 usleep_range(AW88166_1000_US, AW88166_1000_US + 10);
613
614 /* read crc check result */
615 ret = regmap_read(aw_dev->regmap, AW88166_HAGCST_REG, ®_val);
616 if (ret)
617 return ret;
618
619 check_val = (reg_val & (~AW88166_CRC_CHECK_BITS_MASK)) >> AW88166_CRC_CHECK_START_BIT;
620
621 /* disable cfg crc check */
622 ret = regmap_update_bits(aw_dev->regmap, AW88166_CRCCTRL_REG,
623 ~AW88166_CRC_CFG_EN_MASK, AW88166_CRC_CFG_EN_DISABLE_VALUE);
624 if (ret)
625 return ret;
626
627 if (check_val != AW88166_CRC_CHECK_PASS_VAL) {
628 dev_err(aw_dev->dev, "crc_check failed, check val 0x%x != 0x%x\n",
629 check_val, AW88166_CRC_CHECK_PASS_VAL);
630 ret = -EINVAL;
631 }
632
633 return ret;
634 }
635
aw_dev_hw_crc_check(struct aw88166 * aw88166)636 static int aw_dev_hw_crc_check(struct aw88166 *aw88166)
637 {
638 struct aw_device *aw_dev = aw88166->aw_pa;
639 int ret;
640
641 ret = regmap_update_bits(aw_dev->regmap, AW88166_I2SCFG1_REG,
642 ~AW88166_RAM_CG_BYP_MASK, AW88166_RAM_CG_BYP_BYPASS_VALUE);
643 if (ret)
644 return ret;
645
646 ret = aw_dev_fw_crc_check(aw_dev);
647 if (ret) {
648 dev_err(aw_dev->dev, "fw_crc_check failed\n");
649 goto crc_check_failed;
650 }
651
652 ret = aw_dev_cfg_crc_check(aw_dev);
653 if (ret) {
654 dev_err(aw_dev->dev, "cfg_crc_check failed\n");
655 goto crc_check_failed;
656 }
657
658 ret = regmap_write(aw_dev->regmap, AW88166_CRCCTRL_REG, aw88166->crc_init_val);
659 if (ret)
660 return ret;
661
662 ret = regmap_update_bits(aw_dev->regmap, AW88166_I2SCFG1_REG,
663 ~AW88166_RAM_CG_BYP_MASK, AW88166_RAM_CG_BYP_WORK_VALUE);
664
665 return ret;
666
667 crc_check_failed:
668 regmap_update_bits(aw_dev->regmap, AW88166_I2SCFG1_REG,
669 ~AW88166_RAM_CG_BYP_MASK, AW88166_RAM_CG_BYP_WORK_VALUE);
670 return ret;
671 }
672
aw_dev_i2s_tx_enable(struct aw_device * aw_dev,bool flag)673 static void aw_dev_i2s_tx_enable(struct aw_device *aw_dev, bool flag)
674 {
675 int ret;
676
677 if (flag)
678 ret = regmap_update_bits(aw_dev->regmap, AW88166_I2SCTRL3_REG,
679 ~AW88166_I2STXEN_MASK, AW88166_I2STXEN_ENABLE_VALUE);
680 else
681 ret = regmap_update_bits(aw_dev->regmap, AW88166_I2SCTRL3_REG,
682 ~AW88166_I2STXEN_MASK, AW88166_I2STXEN_DISABLE_VALUE);
683
684 if (ret)
685 dev_dbg(aw_dev->dev, "%s failed", __func__);
686 }
687
aw_dev_get_dsp_status(struct aw_device * aw_dev)688 static int aw_dev_get_dsp_status(struct aw_device *aw_dev)
689 {
690 unsigned int reg_val;
691 int ret;
692
693 ret = regmap_read(aw_dev->regmap, AW88166_WDT_REG, ®_val);
694 if (ret)
695 return ret;
696 if (!(reg_val & (~AW88166_WDT_CNT_MASK)))
697 return -EPERM;
698
699 return 0;
700 }
701
aw_dev_dsp_check(struct aw_device * aw_dev)702 static int aw_dev_dsp_check(struct aw_device *aw_dev)
703 {
704 int ret, i;
705
706 switch (aw_dev->dsp_cfg) {
707 case AW88166_DEV_DSP_BYPASS:
708 dev_dbg(aw_dev->dev, "dsp bypass");
709 ret = 0;
710 break;
711 case AW88166_DEV_DSP_WORK:
712 aw_dev_dsp_enable(aw_dev, false);
713 aw_dev_dsp_enable(aw_dev, true);
714 usleep_range(AW88166_1000_US, AW88166_1000_US + 10);
715 for (i = 0; i < AW88166_DEV_DSP_CHECK_MAX; i++) {
716 ret = aw_dev_get_dsp_status(aw_dev);
717 if (ret) {
718 dev_err(aw_dev->dev, "dsp wdt status error=%d", ret);
719 usleep_range(AW88166_2000_US, AW88166_2000_US + 10);
720 }
721 }
722 break;
723 default:
724 dev_err(aw_dev->dev, "unknown dsp cfg=%d", aw_dev->dsp_cfg);
725 ret = -EINVAL;
726 break;
727 }
728
729 return ret;
730 }
731
aw_dev_set_volume(struct aw_device * aw_dev,unsigned int value)732 static int aw_dev_set_volume(struct aw_device *aw_dev, unsigned int value)
733 {
734 struct aw_volume_desc *vol_desc = &aw_dev->volume_desc;
735 unsigned int reg_value;
736 u16 real_value;
737 int ret;
738
739 real_value = min((value + vol_desc->init_volume), (unsigned int)AW88166_MUTE_VOL);
740
741 ret = regmap_read(aw_dev->regmap, AW88166_SYSCTRL2_REG, ®_value);
742 if (ret)
743 return ret;
744
745 dev_dbg(aw_dev->dev, "value 0x%x , reg:0x%x", value, real_value);
746
747 real_value = (real_value << AW88166_VOL_START_BIT) | (reg_value & AW88166_VOL_MASK);
748
749 ret = regmap_write(aw_dev->regmap, AW88166_SYSCTRL2_REG, real_value);
750
751 return ret;
752 }
753
aw_dev_fade_in(struct aw_device * aw_dev)754 static void aw_dev_fade_in(struct aw_device *aw_dev)
755 {
756 struct aw_volume_desc *desc = &aw_dev->volume_desc;
757 u16 fade_in_vol = desc->ctl_volume;
758 int fade_step = aw_dev->fade_step;
759 int i;
760
761 if (fade_step == 0 || aw_dev->fade_in_time == 0) {
762 aw_dev_set_volume(aw_dev, fade_in_vol);
763 return;
764 }
765
766 for (i = AW88166_MUTE_VOL; i >= fade_in_vol; i -= fade_step) {
767 aw_dev_set_volume(aw_dev, i);
768 usleep_range(aw_dev->fade_in_time, aw_dev->fade_in_time + 10);
769 }
770
771 if (i != fade_in_vol)
772 aw_dev_set_volume(aw_dev, fade_in_vol);
773 }
774
aw_dev_fade_out(struct aw_device * aw_dev)775 static void aw_dev_fade_out(struct aw_device *aw_dev)
776 {
777 struct aw_volume_desc *desc = &aw_dev->volume_desc;
778 int fade_step = aw_dev->fade_step;
779 int i;
780
781 if (fade_step == 0 || aw_dev->fade_out_time == 0) {
782 aw_dev_set_volume(aw_dev, AW88166_MUTE_VOL);
783 return;
784 }
785
786 for (i = desc->ctl_volume; i <= AW88166_MUTE_VOL; i += fade_step) {
787 aw_dev_set_volume(aw_dev, i);
788 usleep_range(aw_dev->fade_out_time, aw_dev->fade_out_time + 10);
789 }
790
791 if (i != AW88166_MUTE_VOL) {
792 aw_dev_set_volume(aw_dev, AW88166_MUTE_VOL);
793 usleep_range(aw_dev->fade_out_time, aw_dev->fade_out_time + 10);
794 }
795 }
796
aw88166_dev_mute(struct aw_device * aw_dev,bool is_mute)797 static void aw88166_dev_mute(struct aw_device *aw_dev, bool is_mute)
798 {
799 if (is_mute) {
800 aw_dev_fade_out(aw_dev);
801 regmap_update_bits(aw_dev->regmap, AW88166_SYSCTRL_REG,
802 ~AW88166_HMUTE_MASK, AW88166_HMUTE_ENABLE_VALUE);
803 } else {
804 regmap_update_bits(aw_dev->regmap, AW88166_SYSCTRL_REG,
805 ~AW88166_HMUTE_MASK, AW88166_HMUTE_DISABLE_VALUE);
806 aw_dev_fade_in(aw_dev);
807 }
808 }
809
aw88166_dev_set_dither(struct aw88166 * aw88166,bool dither)810 static void aw88166_dev_set_dither(struct aw88166 *aw88166, bool dither)
811 {
812 struct aw_device *aw_dev = aw88166->aw_pa;
813
814 if (dither)
815 regmap_update_bits(aw_dev->regmap, AW88166_DBGCTRL_REG,
816 ~AW88166_DITHER_EN_MASK, AW88166_DITHER_EN_ENABLE_VALUE);
817 else
818 regmap_update_bits(aw_dev->regmap, AW88166_DBGCTRL_REG,
819 ~AW88166_DITHER_EN_MASK, AW88166_DITHER_EN_DISABLE_VALUE);
820 }
821
aw88166_dev_start(struct aw88166 * aw88166)822 static int aw88166_dev_start(struct aw88166 *aw88166)
823 {
824 struct aw_device *aw_dev = aw88166->aw_pa;
825 int ret;
826
827 if (aw_dev->status == AW88166_DEV_PW_ON) {
828 dev_dbg(aw_dev->dev, "already power on");
829 return 0;
830 }
831
832 aw88166_dev_set_dither(aw88166, false);
833
834 /* power on */
835 aw_dev_pwd(aw_dev, false);
836 usleep_range(AW88166_2000_US, AW88166_2000_US + 10);
837
838 ret = aw_dev_check_syspll(aw_dev);
839 if (ret) {
840 dev_err(aw_dev->dev, "pll check failed cannot start\n");
841 goto pll_check_fail;
842 }
843
844 /* amppd on */
845 aw_dev_amppd(aw_dev, false);
846 usleep_range(AW88166_1000_US, AW88166_1000_US + 50);
847
848 /* check i2s status */
849 ret = aw_dev_check_sysst(aw_dev);
850 if (ret) {
851 dev_err(aw_dev->dev, "sysst check failed\n");
852 goto sysst_check_fail;
853 }
854
855 if (aw_dev->dsp_cfg == AW88166_DEV_DSP_WORK) {
856 aw_dev_backup_sec_recovery(aw88166);
857 ret = aw_dev_hw_crc_check(aw88166);
858 if (ret) {
859 dev_err(aw_dev->dev, "dsp crc check failed\n");
860 goto crc_check_fail;
861 }
862 aw_dev_dsp_enable(aw_dev, false);
863 aw88166_dev_set_vcalb(aw88166);
864 aw_dev_update_cali_re(&aw_dev->cali_desc);
865 ret = aw_dev_dsp_check(aw_dev);
866 if (ret) {
867 dev_err(aw_dev->dev, "dsp status check failed\n");
868 goto dsp_check_fail;
869 }
870 } else {
871 dev_dbg(aw_dev->dev, "start pa with dsp bypass");
872 }
873
874 /* enable tx feedback */
875 aw_dev_i2s_tx_enable(aw_dev, true);
876
877 if (aw88166->dither_st == AW88166_DITHER_EN_ENABLE_VALUE)
878 aw88166_dev_set_dither(aw88166, true);
879
880 /* close mute */
881 aw88166_dev_mute(aw_dev, false);
882 /* clear inturrupt */
883 aw_dev_clear_int_status(aw_dev);
884 aw_dev->status = AW88166_DEV_PW_ON;
885
886 return 0;
887
888 dsp_check_fail:
889 crc_check_fail:
890 aw_dev_dsp_enable(aw_dev, false);
891 sysst_check_fail:
892 aw_dev_clear_int_status(aw_dev);
893 aw_dev_amppd(aw_dev, true);
894 pll_check_fail:
895 aw_dev_pwd(aw_dev, true);
896 aw_dev->status = AW88166_DEV_PW_OFF;
897
898 return ret;
899 }
900
aw_dev_dsp_update_container(struct aw_device * aw_dev,unsigned char * data,unsigned int len,unsigned short base)901 static int aw_dev_dsp_update_container(struct aw_device *aw_dev,
902 unsigned char *data, unsigned int len, unsigned short base)
903 {
904 u32 tmp_len;
905 int i, ret;
906
907 mutex_lock(&aw_dev->dsp_lock);
908 ret = regmap_write(aw_dev->regmap, AW88166_DSPMADD_REG, base);
909 if (ret)
910 goto error_operation;
911
912 for (i = 0; i < len; i += AW88166_MAX_RAM_WRITE_BYTE_SIZE) {
913 tmp_len = min(len - i, AW88166_MAX_RAM_WRITE_BYTE_SIZE);
914 ret = regmap_raw_write(aw_dev->regmap, AW88166_DSPMDAT_REG,
915 &data[i], tmp_len);
916 if (ret)
917 goto error_operation;
918 }
919 mutex_unlock(&aw_dev->dsp_lock);
920
921 return 0;
922
923 error_operation:
924 mutex_unlock(&aw_dev->dsp_lock);
925 return ret;
926 }
927
aw_dev_get_ra(struct aw_cali_desc * cali_desc)928 static int aw_dev_get_ra(struct aw_cali_desc *cali_desc)
929 {
930 struct aw_device *aw_dev =
931 container_of(cali_desc, struct aw_device, cali_desc);
932 u32 dsp_ra;
933 int ret;
934
935 ret = aw_dev_dsp_read(aw_dev, AW88166_DSP_REG_CFG_ADPZ_RA,
936 &dsp_ra, AW88166_DSP_32_DATA);
937 if (ret) {
938 dev_err(aw_dev->dev, "read ra error\n");
939 return ret;
940 }
941
942 cali_desc->ra = AW88166_DSP_RE_TO_SHOW_RE(dsp_ra,
943 AW88166_DSP_RE_SHIFT);
944
945 return 0;
946 }
947
aw_dev_dsp_update_cfg(struct aw_device * aw_dev,unsigned char * data,unsigned int len)948 static int aw_dev_dsp_update_cfg(struct aw_device *aw_dev,
949 unsigned char *data, unsigned int len)
950 {
951 int ret;
952
953 dev_dbg(aw_dev->dev, "dsp config len:%d", len);
954
955 if (!len || !data) {
956 dev_err(aw_dev->dev, "dsp config data is null or len is 0\n");
957 return -EINVAL;
958 }
959
960 ret = aw_dev_dsp_update_container(aw_dev, data, len, AW88166_DSP_CFG_ADDR);
961 if (ret)
962 return ret;
963
964 aw_dev->dsp_cfg_len = len;
965
966 ret = aw_dev_get_ra(&aw_dev->cali_desc);
967
968 return ret;
969 }
970
aw_dev_dsp_update_fw(struct aw_device * aw_dev,unsigned char * data,unsigned int len)971 static int aw_dev_dsp_update_fw(struct aw_device *aw_dev,
972 unsigned char *data, unsigned int len)
973 {
974 int ret;
975
976 dev_dbg(aw_dev->dev, "dsp firmware len:%d", len);
977
978 if (!len || !data) {
979 dev_err(aw_dev->dev, "dsp firmware data is null or len is 0\n");
980 return -EINVAL;
981 }
982
983 aw_dev->dsp_fw_len = len;
984 ret = aw_dev_dsp_update_container(aw_dev, data, len, AW88166_DSP_FW_ADDR);
985
986 return ret;
987 }
988
aw_dev_check_sram(struct aw_device * aw_dev)989 static int aw_dev_check_sram(struct aw_device *aw_dev)
990 {
991 unsigned int reg_val;
992
993 mutex_lock(&aw_dev->dsp_lock);
994 /* read dsp_rom_check_reg */
995 aw_dev_dsp_read_16bit(aw_dev, AW88166_DSP_ROM_CHECK_ADDR, ®_val);
996 if (reg_val != AW88166_DSP_ROM_CHECK_DATA) {
997 dev_err(aw_dev->dev, "check dsp rom failed, read[0x%x] != check[0x%x]\n",
998 reg_val, AW88166_DSP_ROM_CHECK_DATA);
999 goto error;
1000 }
1001
1002 /* check dsp_cfg_base_addr */
1003 aw_dev_dsp_write_16bit(aw_dev, AW88166_DSP_CFG_ADDR, AW88166_DSP_ODD_NUM_BIT_TEST);
1004 aw_dev_dsp_read_16bit(aw_dev, AW88166_DSP_CFG_ADDR, ®_val);
1005 if (reg_val != AW88166_DSP_ODD_NUM_BIT_TEST) {
1006 dev_err(aw_dev->dev, "check dsp cfg failed, read[0x%x] != write[0x%x]\n",
1007 reg_val, AW88166_DSP_ODD_NUM_BIT_TEST);
1008 goto error;
1009 }
1010 mutex_unlock(&aw_dev->dsp_lock);
1011
1012 return 0;
1013 error:
1014 mutex_unlock(&aw_dev->dsp_lock);
1015 return -EPERM;
1016 }
1017
aw_dev_select_memclk(struct aw_device * aw_dev,unsigned char flag)1018 static void aw_dev_select_memclk(struct aw_device *aw_dev, unsigned char flag)
1019 {
1020 int ret;
1021
1022 switch (flag) {
1023 case AW88166_DEV_MEMCLK_PLL:
1024 ret = regmap_update_bits(aw_dev->regmap, AW88166_DBGCTRL_REG,
1025 ~AW88166_MEM_CLKSEL_MASK,
1026 AW88166_MEM_CLKSEL_DAPHCLK_VALUE);
1027 if (ret)
1028 dev_err(aw_dev->dev, "memclk select pll failed\n");
1029 break;
1030 case AW88166_DEV_MEMCLK_OSC:
1031 ret = regmap_update_bits(aw_dev->regmap, AW88166_DBGCTRL_REG,
1032 ~AW88166_MEM_CLKSEL_MASK,
1033 AW88166_MEM_CLKSEL_OSCCLK_VALUE);
1034 if (ret)
1035 dev_err(aw_dev->dev, "memclk select OSC failed\n");
1036 break;
1037 default:
1038 dev_err(aw_dev->dev, "unknown memclk config, flag=0x%x\n", flag);
1039 break;
1040 }
1041 }
1042
aw_dev_update_reg_container(struct aw88166 * aw88166,unsigned char * data,unsigned int len)1043 static int aw_dev_update_reg_container(struct aw88166 *aw88166,
1044 unsigned char *data, unsigned int len)
1045 {
1046 struct aw_device *aw_dev = aw88166->aw_pa;
1047 struct aw_volume_desc *vol_desc = &aw_dev->volume_desc;
1048 u16 read_vol, reg_val;
1049 int data_len, i, ret;
1050 int16_t *reg_data;
1051 u8 reg_addr;
1052
1053 reg_data = (int16_t *)data;
1054 data_len = len >> 1;
1055
1056 if (data_len & 0x1) {
1057 dev_err(aw_dev->dev, "data len:%d unsupported\n", data_len);
1058 return -EINVAL;
1059 }
1060
1061 for (i = 0; i < data_len; i += 2) {
1062 reg_addr = reg_data[i];
1063 reg_val = reg_data[i + 1];
1064
1065 if (reg_addr == AW88166_DSPVCALB_REG) {
1066 aw88166->vcalb_init_val = reg_val;
1067 continue;
1068 }
1069
1070 if (reg_addr == AW88166_SYSCTRL_REG) {
1071 if (reg_val & (~AW88166_DSPBY_MASK))
1072 aw_dev->dsp_cfg = AW88166_DEV_DSP_BYPASS;
1073 else
1074 aw_dev->dsp_cfg = AW88166_DEV_DSP_WORK;
1075
1076 reg_val &= (AW88166_HMUTE_MASK | AW88166_PWDN_MASK |
1077 AW88166_DSPBY_MASK);
1078 reg_val |= (AW88166_HMUTE_ENABLE_VALUE | AW88166_PWDN_POWER_DOWN_VALUE |
1079 AW88166_DSPBY_BYPASS_VALUE);
1080 }
1081
1082 if (reg_addr == AW88166_I2SCTRL3_REG) {
1083 reg_val &= AW88166_I2STXEN_MASK;
1084 reg_val |= AW88166_I2STXEN_DISABLE_VALUE;
1085 }
1086
1087 if (reg_addr == AW88166_SYSCTRL2_REG) {
1088 read_vol = (reg_val & (~AW88166_VOL_MASK)) >>
1089 AW88166_VOL_START_BIT;
1090 aw_dev->volume_desc.init_volume = read_vol;
1091 }
1092
1093 if (reg_addr == AW88166_DBGCTRL_REG) {
1094 if ((reg_val & (~AW88166_EF_DBMD_MASK)) == AW88166_EF_DBMD_OR_VALUE)
1095 aw88166->check_val = AW_EF_OR_CHECK;
1096 else
1097 aw88166->check_val = AW_EF_AND_CHECK;
1098
1099 aw88166->dither_st = reg_val & (~AW88166_DITHER_EN_MASK);
1100 }
1101
1102 if (reg_addr == AW88166_ACR1_REG) {
1103 aw88166->re_init_val |= (uint32_t)reg_val << 16;
1104 continue;
1105 }
1106
1107 if (reg_addr == AW88166_ACR2_REG) {
1108 aw88166->re_init_val |= (uint32_t)reg_val;
1109 continue;
1110 }
1111
1112 if (reg_addr == AW88166_CRCCTRL_REG)
1113 aw88166->crc_init_val = reg_val;
1114
1115 ret = regmap_write(aw_dev->regmap, reg_addr, reg_val);
1116 if (ret)
1117 return ret;
1118 }
1119
1120 aw_dev_pwd(aw_dev, false);
1121 usleep_range(AW88166_1000_US, AW88166_1000_US + 10);
1122
1123 if (aw_dev->prof_cur != aw_dev->prof_index)
1124 vol_desc->ctl_volume = 0;
1125 else
1126 aw_dev_set_volume(aw_dev, vol_desc->ctl_volume);
1127
1128 return 0;
1129 }
1130
aw_dev_reg_update(struct aw88166 * aw88166,unsigned char * data,unsigned int len)1131 static int aw_dev_reg_update(struct aw88166 *aw88166,
1132 unsigned char *data, unsigned int len)
1133 {
1134 int ret;
1135
1136 if (!len || !data) {
1137 dev_err(aw88166->aw_pa->dev, "reg data is null or len is 0\n");
1138 return -EINVAL;
1139 }
1140
1141 ret = aw_dev_update_reg_container(aw88166, data, len);
1142 if (ret)
1143 dev_err(aw88166->aw_pa->dev, "reg update failed\n");
1144
1145 return ret;
1146 }
1147
aw88166_dev_get_prof_name(struct aw_device * aw_dev,int index,char ** prof_name)1148 static int aw88166_dev_get_prof_name(struct aw_device *aw_dev, int index, char **prof_name)
1149 {
1150 struct aw_prof_info *prof_info = &aw_dev->prof_info;
1151 struct aw_prof_desc *prof_desc;
1152
1153 if ((index >= aw_dev->prof_info.count) || (index < 0)) {
1154 dev_err(aw_dev->dev, "index[%d] overflow count[%d]\n",
1155 index, aw_dev->prof_info.count);
1156 return -EINVAL;
1157 }
1158
1159 prof_desc = &aw_dev->prof_info.prof_desc[index];
1160
1161 *prof_name = prof_info->prof_name_list[prof_desc->id];
1162
1163 return 0;
1164 }
1165
aw88166_dev_get_prof_data(struct aw_device * aw_dev,int index,struct aw_prof_desc ** prof_desc)1166 static int aw88166_dev_get_prof_data(struct aw_device *aw_dev, int index,
1167 struct aw_prof_desc **prof_desc)
1168 {
1169 if ((index >= aw_dev->prof_info.count) || (index < 0)) {
1170 dev_err(aw_dev->dev, "%s: index[%d] overflow count[%d]\n",
1171 __func__, index, aw_dev->prof_info.count);
1172 return -EINVAL;
1173 }
1174
1175 *prof_desc = &aw_dev->prof_info.prof_desc[index];
1176
1177 return 0;
1178 }
1179
aw88166_dev_fw_update(struct aw88166 * aw88166,bool up_dsp_fw_en,bool force_up_en)1180 static int aw88166_dev_fw_update(struct aw88166 *aw88166, bool up_dsp_fw_en, bool force_up_en)
1181 {
1182 struct aw_device *aw_dev = aw88166->aw_pa;
1183 struct aw_prof_desc *prof_index_desc;
1184 struct aw_sec_data_desc *sec_desc;
1185 char *prof_name;
1186 int ret;
1187
1188 if ((aw_dev->prof_cur == aw_dev->prof_index) &&
1189 (force_up_en == AW88166_FORCE_UPDATE_OFF)) {
1190 dev_dbg(aw_dev->dev, "scene no change, not update");
1191 return 0;
1192 }
1193
1194 if (aw_dev->fw_status == AW88166_DEV_FW_FAILED) {
1195 dev_err(aw_dev->dev, "fw status[%d] error\n", aw_dev->fw_status);
1196 return -EPERM;
1197 }
1198
1199 ret = aw88166_dev_get_prof_name(aw_dev, aw_dev->prof_index, &prof_name);
1200 if (ret)
1201 return ret;
1202
1203 dev_dbg(aw_dev->dev, "start update %s", prof_name);
1204
1205 ret = aw88166_dev_get_prof_data(aw_dev, aw_dev->prof_index, &prof_index_desc);
1206 if (ret)
1207 return ret;
1208
1209 /* update reg */
1210 sec_desc = prof_index_desc->sec_desc;
1211 ret = aw_dev_reg_update(aw88166, sec_desc[AW88395_DATA_TYPE_REG].data,
1212 sec_desc[AW88395_DATA_TYPE_REG].len);
1213 if (ret) {
1214 dev_err(aw_dev->dev, "update reg failed\n");
1215 return ret;
1216 }
1217
1218 aw88166_dev_mute(aw_dev, true);
1219
1220 if (aw_dev->dsp_cfg == AW88166_DEV_DSP_WORK)
1221 aw_dev_dsp_enable(aw_dev, false);
1222
1223 aw_dev_select_memclk(aw_dev, AW88166_DEV_MEMCLK_OSC);
1224
1225 ret = aw_dev_check_sram(aw_dev);
1226 if (ret) {
1227 dev_err(aw_dev->dev, "check sram failed\n");
1228 goto error;
1229 }
1230
1231 aw_dev_backup_sec_recovery(aw88166);
1232
1233 if (up_dsp_fw_en) {
1234 dev_dbg(aw_dev->dev, "fw_ver: [%x]", prof_index_desc->fw_ver);
1235 ret = aw_dev_dsp_update_fw(aw_dev, sec_desc[AW88395_DATA_TYPE_DSP_FW].data,
1236 sec_desc[AW88395_DATA_TYPE_DSP_FW].len);
1237 if (ret) {
1238 dev_err(aw_dev->dev, "update dsp fw failed\n");
1239 goto error;
1240 }
1241 }
1242
1243 /* update dsp config */
1244 ret = aw_dev_dsp_update_cfg(aw_dev, sec_desc[AW88395_DATA_TYPE_DSP_CFG].data,
1245 sec_desc[AW88395_DATA_TYPE_DSP_CFG].len);
1246 if (ret) {
1247 dev_err(aw_dev->dev, "update dsp cfg failed\n");
1248 goto error;
1249 }
1250
1251 aw_dev_backup_sec_record(aw88166);
1252
1253 aw_dev_select_memclk(aw_dev, AW88166_DEV_MEMCLK_PLL);
1254
1255 aw_dev->prof_cur = aw_dev->prof_index;
1256
1257 return 0;
1258
1259 error:
1260 aw_dev_select_memclk(aw_dev, AW88166_DEV_MEMCLK_PLL);
1261 return ret;
1262 }
1263
aw88166_start_pa(struct aw88166 * aw88166)1264 static void aw88166_start_pa(struct aw88166 *aw88166)
1265 {
1266 int ret, i;
1267
1268 for (i = 0; i < AW88166_START_RETRIES; i++) {
1269 ret = aw88166_dev_start(aw88166);
1270 if (ret) {
1271 dev_err(aw88166->aw_pa->dev, "aw88166 device start failed. retry = %d", i);
1272 ret = aw88166_dev_fw_update(aw88166, AW88166_DSP_FW_UPDATE_ON, true);
1273 if (ret) {
1274 dev_err(aw88166->aw_pa->dev, "fw update failed");
1275 continue;
1276 }
1277 } else {
1278 dev_dbg(aw88166->aw_pa->dev, "start success\n");
1279 break;
1280 }
1281 }
1282 }
1283
aw88166_startup_work(struct work_struct * work)1284 static void aw88166_startup_work(struct work_struct *work)
1285 {
1286 struct aw88166 *aw88166 =
1287 container_of(work, struct aw88166, start_work.work);
1288
1289 mutex_lock(&aw88166->lock);
1290 aw88166_start_pa(aw88166);
1291 mutex_unlock(&aw88166->lock);
1292 }
1293
aw88166_start(struct aw88166 * aw88166,bool sync_start)1294 static void aw88166_start(struct aw88166 *aw88166, bool sync_start)
1295 {
1296 int ret;
1297
1298 if (aw88166->aw_pa->fw_status != AW88166_DEV_FW_OK)
1299 return;
1300
1301 if (aw88166->aw_pa->status == AW88166_DEV_PW_ON)
1302 return;
1303
1304 ret = aw88166_dev_fw_update(aw88166, AW88166_DSP_FW_UPDATE_OFF, aw88166->phase_sync);
1305 if (ret) {
1306 dev_err(aw88166->aw_pa->dev, "fw update failed\n");
1307 return;
1308 }
1309
1310 if (sync_start == AW88166_SYNC_START)
1311 aw88166_start_pa(aw88166);
1312 else
1313 queue_delayed_work(system_wq,
1314 &aw88166->start_work,
1315 AW88166_START_WORK_DELAY_MS);
1316 }
1317
aw_dev_check_sysint(struct aw_device * aw_dev)1318 static int aw_dev_check_sysint(struct aw_device *aw_dev)
1319 {
1320 u16 reg_val;
1321
1322 aw_dev_get_int_status(aw_dev, ®_val);
1323 if (reg_val & AW88166_BIT_SYSINT_CHECK) {
1324 dev_err(aw_dev->dev, "pa stop check fail:0x%04x\n", reg_val);
1325 return -EINVAL;
1326 }
1327
1328 return 0;
1329 }
1330
aw88166_stop(struct aw_device * aw_dev)1331 static int aw88166_stop(struct aw_device *aw_dev)
1332 {
1333 struct aw_sec_data_desc *dsp_cfg =
1334 &aw_dev->prof_info.prof_desc[aw_dev->prof_cur].sec_desc[AW88395_DATA_TYPE_DSP_CFG];
1335 struct aw_sec_data_desc *dsp_fw =
1336 &aw_dev->prof_info.prof_desc[aw_dev->prof_cur].sec_desc[AW88395_DATA_TYPE_DSP_FW];
1337 int int_st;
1338
1339 if (aw_dev->status == AW88166_DEV_PW_OFF) {
1340 dev_dbg(aw_dev->dev, "already power off");
1341 return 0;
1342 }
1343
1344 aw_dev->status = AW88166_DEV_PW_OFF;
1345
1346 aw88166_dev_mute(aw_dev, true);
1347 usleep_range(AW88166_4000_US, AW88166_4000_US + 100);
1348
1349 aw_dev_i2s_tx_enable(aw_dev, false);
1350 usleep_range(AW88166_1000_US, AW88166_1000_US + 100);
1351
1352 int_st = aw_dev_check_sysint(aw_dev);
1353
1354 aw_dev_dsp_enable(aw_dev, false);
1355
1356 aw_dev_amppd(aw_dev, true);
1357
1358 if (int_st) {
1359 aw_dev_select_memclk(aw_dev, AW88166_DEV_MEMCLK_OSC);
1360 aw_dev_dsp_update_fw(aw_dev, dsp_fw->data, dsp_fw->len);
1361 aw_dev_dsp_update_cfg(aw_dev, dsp_cfg->data, dsp_cfg->len);
1362 aw_dev_select_memclk(aw_dev, AW88166_DEV_MEMCLK_PLL);
1363 }
1364
1365 aw_dev_pwd(aw_dev, true);
1366
1367 return 0;
1368 }
1369
1370 static struct snd_soc_dai_driver aw88166_dai[] = {
1371 {
1372 .name = "aw88166-aif",
1373 .id = 1,
1374 .playback = {
1375 .stream_name = "Speaker_Playback",
1376 .channels_min = 1,
1377 .channels_max = 2,
1378 .rates = AW88166_RATES,
1379 .formats = AW88166_FORMATS,
1380 },
1381 .capture = {
1382 .stream_name = "Speaker_Capture",
1383 .channels_min = 1,
1384 .channels_max = 2,
1385 .rates = AW88166_RATES,
1386 .formats = AW88166_FORMATS,
1387 },
1388 },
1389 };
1390
aw88166_get_fade_in_time(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1391 static int aw88166_get_fade_in_time(struct snd_kcontrol *kcontrol,
1392 struct snd_ctl_elem_value *ucontrol)
1393 {
1394 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1395 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(component);
1396 struct aw_device *aw_dev = aw88166->aw_pa;
1397
1398 ucontrol->value.integer.value[0] = aw_dev->fade_in_time;
1399
1400 return 0;
1401 }
1402
aw88166_set_fade_in_time(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1403 static int aw88166_set_fade_in_time(struct snd_kcontrol *kcontrol,
1404 struct snd_ctl_elem_value *ucontrol)
1405 {
1406 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1407 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(component);
1408 struct soc_mixer_control *mc =
1409 (struct soc_mixer_control *)kcontrol->private_value;
1410 struct aw_device *aw_dev = aw88166->aw_pa;
1411 int time;
1412
1413 time = ucontrol->value.integer.value[0];
1414
1415 if (time < mc->min || time > mc->max)
1416 return -EINVAL;
1417
1418 if (time != aw_dev->fade_in_time) {
1419 aw_dev->fade_in_time = time;
1420 return 1;
1421 }
1422
1423 return 0;
1424 }
1425
aw88166_get_fade_out_time(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1426 static int aw88166_get_fade_out_time(struct snd_kcontrol *kcontrol,
1427 struct snd_ctl_elem_value *ucontrol)
1428 {
1429 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1430 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(component);
1431 struct aw_device *aw_dev = aw88166->aw_pa;
1432
1433 ucontrol->value.integer.value[0] = aw_dev->fade_out_time;
1434
1435 return 0;
1436 }
1437
aw88166_set_fade_out_time(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1438 static int aw88166_set_fade_out_time(struct snd_kcontrol *kcontrol,
1439 struct snd_ctl_elem_value *ucontrol)
1440 {
1441 struct snd_soc_component *component = snd_soc_kcontrol_component(kcontrol);
1442 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(component);
1443 struct soc_mixer_control *mc =
1444 (struct soc_mixer_control *)kcontrol->private_value;
1445 struct aw_device *aw_dev = aw88166->aw_pa;
1446 int time;
1447
1448 time = ucontrol->value.integer.value[0];
1449 if (time < mc->min || time > mc->max)
1450 return -EINVAL;
1451
1452 if (time != aw_dev->fade_out_time) {
1453 aw_dev->fade_out_time = time;
1454 return 1;
1455 }
1456
1457 return 0;
1458 }
1459
aw88166_dev_set_profile_index(struct aw_device * aw_dev,int index)1460 static int aw88166_dev_set_profile_index(struct aw_device *aw_dev, int index)
1461 {
1462 /* check the index whether is valid */
1463 if ((index >= aw_dev->prof_info.count) || (index < 0))
1464 return -EINVAL;
1465 /* check the index whether change */
1466 if (aw_dev->prof_index == index)
1467 return -EINVAL;
1468
1469 aw_dev->prof_index = index;
1470 dev_dbg(aw_dev->dev, "set prof[%s]",
1471 aw_dev->prof_info.prof_name_list[aw_dev->prof_info.prof_desc[index].id]);
1472
1473 return 0;
1474 }
1475
aw88166_profile_info(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_info * uinfo)1476 static int aw88166_profile_info(struct snd_kcontrol *kcontrol,
1477 struct snd_ctl_elem_info *uinfo)
1478 {
1479 struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
1480 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(codec);
1481 char *prof_name, *name;
1482 int count, ret;
1483
1484 uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
1485 uinfo->count = 1;
1486
1487 count = aw88166->aw_pa->prof_info.count;
1488 if (count <= 0) {
1489 uinfo->value.enumerated.items = 0;
1490 return 0;
1491 }
1492
1493 uinfo->value.enumerated.items = count;
1494
1495 if (uinfo->value.enumerated.item >= count)
1496 uinfo->value.enumerated.item = count - 1;
1497
1498 name = uinfo->value.enumerated.name;
1499 count = uinfo->value.enumerated.item;
1500
1501 ret = aw88166_dev_get_prof_name(aw88166->aw_pa, count, &prof_name);
1502 if (ret) {
1503 strscpy(uinfo->value.enumerated.name, "null",
1504 strlen("null") + 1);
1505 return 0;
1506 }
1507
1508 strscpy(name, prof_name, sizeof(uinfo->value.enumerated.name));
1509
1510 return 0;
1511 }
1512
aw88166_profile_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1513 static int aw88166_profile_get(struct snd_kcontrol *kcontrol,
1514 struct snd_ctl_elem_value *ucontrol)
1515 {
1516 struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
1517 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(codec);
1518
1519 ucontrol->value.integer.value[0] = aw88166->aw_pa->prof_index;
1520
1521 return 0;
1522 }
1523
aw88166_profile_set(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1524 static int aw88166_profile_set(struct snd_kcontrol *kcontrol,
1525 struct snd_ctl_elem_value *ucontrol)
1526 {
1527 struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
1528 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(codec);
1529 int ret;
1530
1531 mutex_lock(&aw88166->lock);
1532 ret = aw88166_dev_set_profile_index(aw88166->aw_pa, ucontrol->value.integer.value[0]);
1533 if (ret) {
1534 dev_dbg(codec->dev, "profile index does not change");
1535 mutex_unlock(&aw88166->lock);
1536 return 0;
1537 }
1538
1539 if (aw88166->aw_pa->status) {
1540 aw88166_stop(aw88166->aw_pa);
1541 aw88166_start(aw88166, AW88166_SYNC_START);
1542 }
1543
1544 mutex_unlock(&aw88166->lock);
1545
1546 return 1;
1547 }
1548
aw88166_volume_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1549 static int aw88166_volume_get(struct snd_kcontrol *kcontrol,
1550 struct snd_ctl_elem_value *ucontrol)
1551 {
1552 struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
1553 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(codec);
1554 struct aw_volume_desc *vol_desc = &aw88166->aw_pa->volume_desc;
1555
1556 ucontrol->value.integer.value[0] = vol_desc->ctl_volume;
1557
1558 return 0;
1559 }
1560
aw88166_volume_set(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1561 static int aw88166_volume_set(struct snd_kcontrol *kcontrol,
1562 struct snd_ctl_elem_value *ucontrol)
1563 {
1564 struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
1565 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(codec);
1566 struct aw_volume_desc *vol_desc = &aw88166->aw_pa->volume_desc;
1567 struct soc_mixer_control *mc =
1568 (struct soc_mixer_control *)kcontrol->private_value;
1569 int value;
1570
1571 value = ucontrol->value.integer.value[0];
1572 if (value < mc->min || value > mc->max)
1573 return -EINVAL;
1574
1575 if (vol_desc->ctl_volume != value) {
1576 vol_desc->ctl_volume = value;
1577 aw_dev_set_volume(aw88166->aw_pa, vol_desc->ctl_volume);
1578
1579 return 1;
1580 }
1581
1582 return 0;
1583 }
1584
aw88166_get_fade_step(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1585 static int aw88166_get_fade_step(struct snd_kcontrol *kcontrol,
1586 struct snd_ctl_elem_value *ucontrol)
1587 {
1588 struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
1589 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(codec);
1590
1591 ucontrol->value.integer.value[0] = aw88166->aw_pa->fade_step;
1592
1593 return 0;
1594 }
1595
aw88166_set_fade_step(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1596 static int aw88166_set_fade_step(struct snd_kcontrol *kcontrol,
1597 struct snd_ctl_elem_value *ucontrol)
1598 {
1599 struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
1600 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(codec);
1601 struct soc_mixer_control *mc =
1602 (struct soc_mixer_control *)kcontrol->private_value;
1603 int value;
1604
1605 value = ucontrol->value.integer.value[0];
1606 if (value < mc->min || value > mc->max)
1607 return -EINVAL;
1608
1609 if (aw88166->aw_pa->fade_step != value) {
1610 aw88166->aw_pa->fade_step = value;
1611 return 1;
1612 }
1613
1614 return 0;
1615 }
1616
aw88166_re_get(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1617 static int aw88166_re_get(struct snd_kcontrol *kcontrol,
1618 struct snd_ctl_elem_value *ucontrol)
1619 {
1620 struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
1621 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(codec);
1622 struct aw_device *aw_dev = aw88166->aw_pa;
1623
1624 ucontrol->value.integer.value[0] = aw_dev->cali_desc.cali_re;
1625
1626 return 0;
1627 }
1628
aw88166_re_set(struct snd_kcontrol * kcontrol,struct snd_ctl_elem_value * ucontrol)1629 static int aw88166_re_set(struct snd_kcontrol *kcontrol,
1630 struct snd_ctl_elem_value *ucontrol)
1631 {
1632 struct snd_soc_component *codec = snd_soc_kcontrol_component(kcontrol);
1633 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(codec);
1634 struct soc_mixer_control *mc =
1635 (struct soc_mixer_control *)kcontrol->private_value;
1636 struct aw_device *aw_dev = aw88166->aw_pa;
1637 int value;
1638
1639 value = ucontrol->value.integer.value[0];
1640 if (value < mc->min || value > mc->max)
1641 return -EINVAL;
1642
1643 if (aw_dev->cali_desc.cali_re != value) {
1644 aw_dev->cali_desc.cali_re = value;
1645 return 1;
1646 }
1647
1648 return 0;
1649 }
1650
aw88166_dev_init(struct aw88166 * aw88166,struct aw_container * aw_cfg)1651 static int aw88166_dev_init(struct aw88166 *aw88166, struct aw_container *aw_cfg)
1652 {
1653 struct aw_device *aw_dev = aw88166->aw_pa;
1654 int ret;
1655
1656 ret = aw88395_dev_cfg_load(aw_dev, aw_cfg);
1657 if (ret) {
1658 dev_err(aw_dev->dev, "aw_dev acf parse failed\n");
1659 return -EINVAL;
1660 }
1661 aw_dev->fade_in_time = AW88166_1000_US / 10;
1662 aw_dev->fade_out_time = AW88166_1000_US >> 1;
1663 aw_dev->prof_cur = aw_dev->prof_info.prof_desc[0].id;
1664 aw_dev->prof_index = aw_dev->prof_info.prof_desc[0].id;
1665
1666 ret = aw88166_dev_fw_update(aw88166, AW88166_FORCE_UPDATE_ON, AW88166_DSP_FW_UPDATE_ON);
1667 if (ret) {
1668 dev_err(aw_dev->dev, "fw update failed ret = %d\n", ret);
1669 return ret;
1670 }
1671
1672 aw88166_dev_mute(aw_dev, true);
1673
1674 /* close tx feedback */
1675 aw_dev_i2s_tx_enable(aw_dev, false);
1676 usleep_range(AW88166_1000_US, AW88166_1000_US + 100);
1677
1678 /* enable amppd */
1679 aw_dev_amppd(aw_dev, true);
1680
1681 /* close dsp */
1682 aw_dev_dsp_enable(aw_dev, false);
1683 /* set power down */
1684 aw_dev_pwd(aw_dev, true);
1685
1686 return 0;
1687 }
1688
aw88166_request_firmware_file(struct aw88166 * aw88166)1689 static int aw88166_request_firmware_file(struct aw88166 *aw88166)
1690 {
1691 const struct firmware *cont = NULL;
1692 int ret;
1693
1694 aw88166->aw_pa->fw_status = AW88166_DEV_FW_FAILED;
1695
1696 ret = request_firmware(&cont, AW88166_ACF_FILE, aw88166->aw_pa->dev);
1697 if (ret) {
1698 dev_err(aw88166->aw_pa->dev, "request [%s] failed!\n", AW88166_ACF_FILE);
1699 return ret;
1700 }
1701
1702 dev_dbg(aw88166->aw_pa->dev, "loaded %s - size: %zu\n",
1703 AW88166_ACF_FILE, cont ? cont->size : 0);
1704
1705 aw88166->aw_cfg = devm_kzalloc(aw88166->aw_pa->dev,
1706 struct_size(aw88166->aw_cfg, data, cont->size), GFP_KERNEL);
1707 if (!aw88166->aw_cfg) {
1708 release_firmware(cont);
1709 return -ENOMEM;
1710 }
1711 aw88166->aw_cfg->len = (int)cont->size;
1712 memcpy(aw88166->aw_cfg->data, cont->data, cont->size);
1713 release_firmware(cont);
1714
1715 ret = aw88395_dev_load_acf_check(aw88166->aw_pa, aw88166->aw_cfg);
1716 if (ret) {
1717 dev_err(aw88166->aw_pa->dev, "load [%s] failed!\n", AW88166_ACF_FILE);
1718 return ret;
1719 }
1720
1721 mutex_lock(&aw88166->lock);
1722 /* aw device init */
1723 ret = aw88166_dev_init(aw88166, aw88166->aw_cfg);
1724 if (ret)
1725 dev_err(aw88166->aw_pa->dev, "dev init failed\n");
1726 mutex_unlock(&aw88166->lock);
1727
1728 return ret;
1729 }
1730
1731 static const struct snd_kcontrol_new aw88166_controls[] = {
1732 SOC_SINGLE_EXT("PCM Playback Volume", AW88166_SYSCTRL2_REG,
1733 6, AW88166_MUTE_VOL, 0, aw88166_volume_get,
1734 aw88166_volume_set),
1735 SOC_SINGLE_EXT("Fade Step", 0, 0, AW88166_MUTE_VOL, 0,
1736 aw88166_get_fade_step, aw88166_set_fade_step),
1737 SOC_SINGLE_EXT("Volume Ramp Up Step", 0, 0, FADE_TIME_MAX, FADE_TIME_MIN,
1738 aw88166_get_fade_in_time, aw88166_set_fade_in_time),
1739 SOC_SINGLE_EXT("Volume Ramp Down Step", 0, 0, FADE_TIME_MAX, FADE_TIME_MIN,
1740 aw88166_get_fade_out_time, aw88166_set_fade_out_time),
1741 SOC_SINGLE_EXT("Calib", 0, 0, AW88166_CALI_RE_MAX, 0,
1742 aw88166_re_get, aw88166_re_set),
1743 AW88166_PROFILE_EXT("AW88166 Profile Set", aw88166_profile_info,
1744 aw88166_profile_get, aw88166_profile_set),
1745 };
1746
aw88166_playback_event(struct snd_soc_dapm_widget * w,struct snd_kcontrol * k,int event)1747 static int aw88166_playback_event(struct snd_soc_dapm_widget *w,
1748 struct snd_kcontrol *k, int event)
1749 {
1750 struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1751 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(component);
1752
1753 mutex_lock(&aw88166->lock);
1754 switch (event) {
1755 case SND_SOC_DAPM_PRE_PMU:
1756 aw88166_start(aw88166, AW88166_ASYNC_START);
1757 break;
1758 case SND_SOC_DAPM_POST_PMD:
1759 aw88166_stop(aw88166->aw_pa);
1760 break;
1761 default:
1762 break;
1763 }
1764 mutex_unlock(&aw88166->lock);
1765
1766 return 0;
1767 }
1768
1769 static const struct snd_soc_dapm_widget aw88166_dapm_widgets[] = {
1770 /* playback */
1771 SND_SOC_DAPM_AIF_IN_E("AIF_RX", "Speaker_Playback", 0, SND_SOC_NOPM, 0, 0,
1772 aw88166_playback_event,
1773 SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
1774 SND_SOC_DAPM_OUTPUT("DAC Output"),
1775
1776 /* capture */
1777 SND_SOC_DAPM_AIF_OUT("AIF_TX", "Speaker_Capture", 0, SND_SOC_NOPM, 0, 0),
1778 SND_SOC_DAPM_INPUT("ADC Input"),
1779 };
1780
1781 static const struct snd_soc_dapm_route aw88166_audio_map[] = {
1782 {"DAC Output", NULL, "AIF_RX"},
1783 {"AIF_TX", NULL, "ADC Input"},
1784 };
1785
aw88166_codec_probe(struct snd_soc_component * component)1786 static int aw88166_codec_probe(struct snd_soc_component *component)
1787 {
1788 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(component);
1789 int ret;
1790
1791 INIT_DELAYED_WORK(&aw88166->start_work, aw88166_startup_work);
1792
1793 ret = aw88166_request_firmware_file(aw88166);
1794 if (ret)
1795 dev_err(aw88166->aw_pa->dev, "%s failed\n", __func__);
1796
1797 return ret;
1798 }
1799
aw88166_codec_remove(struct snd_soc_component * aw_codec)1800 static void aw88166_codec_remove(struct snd_soc_component *aw_codec)
1801 {
1802 struct aw88166 *aw88166 = snd_soc_component_get_drvdata(aw_codec);
1803
1804 cancel_delayed_work_sync(&aw88166->start_work);
1805 }
1806
1807 static const struct snd_soc_component_driver soc_codec_dev_aw88166 = {
1808 .probe = aw88166_codec_probe,
1809 .remove = aw88166_codec_remove,
1810 .dapm_widgets = aw88166_dapm_widgets,
1811 .num_dapm_widgets = ARRAY_SIZE(aw88166_dapm_widgets),
1812 .dapm_routes = aw88166_audio_map,
1813 .num_dapm_routes = ARRAY_SIZE(aw88166_audio_map),
1814 .controls = aw88166_controls,
1815 .num_controls = ARRAY_SIZE(aw88166_controls),
1816 };
1817
aw88166_hw_reset(struct aw88166 * aw88166)1818 static void aw88166_hw_reset(struct aw88166 *aw88166)
1819 {
1820 if (aw88166->reset_gpio) {
1821 gpiod_set_value_cansleep(aw88166->reset_gpio, 1);
1822 usleep_range(AW88166_1000_US, AW88166_1000_US + 10);
1823 gpiod_set_value_cansleep(aw88166->reset_gpio, 0);
1824 usleep_range(AW88166_1000_US, AW88166_1000_US + 10);
1825 }
1826 }
1827
aw88166_parse_channel_dt(struct aw88166 * aw88166)1828 static void aw88166_parse_channel_dt(struct aw88166 *aw88166)
1829 {
1830 struct aw_device *aw_dev = aw88166->aw_pa;
1831 struct device_node *np = aw_dev->dev->of_node;
1832 u32 channel_value;
1833
1834 of_property_read_u32(np, "awinic,audio-channel", &channel_value);
1835 aw_dev->channel = channel_value;
1836 aw88166->phase_sync = of_property_read_bool(np, "awinic,sync-flag");
1837 }
1838
aw88166_init(struct aw88166 * aw88166,struct i2c_client * i2c,struct regmap * regmap)1839 static int aw88166_init(struct aw88166 *aw88166, struct i2c_client *i2c, struct regmap *regmap)
1840 {
1841 struct aw_device *aw_dev;
1842 unsigned int chip_id;
1843 int ret;
1844
1845 ret = regmap_read(regmap, AW88166_ID_REG, &chip_id);
1846 if (ret) {
1847 dev_err(&i2c->dev, "%s read chipid error. ret = %d\n", __func__, ret);
1848 return ret;
1849 }
1850
1851 aw_dev = devm_kzalloc(&i2c->dev, sizeof(*aw_dev), GFP_KERNEL);
1852 if (!aw_dev)
1853 return -ENOMEM;
1854 aw88166->aw_pa = aw_dev;
1855
1856 aw_dev->i2c = i2c;
1857 aw_dev->dev = &i2c->dev;
1858 aw_dev->regmap = regmap;
1859 mutex_init(&aw_dev->dsp_lock);
1860
1861 aw_dev->chip_id = chip_id;
1862 aw_dev->acf = NULL;
1863 aw_dev->prof_info.prof_desc = NULL;
1864 aw_dev->prof_info.count = 0;
1865 aw_dev->prof_info.prof_type = AW88395_DEV_NONE_TYPE_ID;
1866 aw_dev->channel = AW88166_DEV_DEFAULT_CH;
1867 aw_dev->fw_status = AW88166_DEV_FW_FAILED;
1868
1869 aw_dev->fade_step = AW88166_VOLUME_STEP_DB;
1870 aw_dev->volume_desc.ctl_volume = AW88166_VOL_DEFAULT_VALUE;
1871
1872 aw88166_parse_channel_dt(aw88166);
1873
1874 return 0;
1875 }
1876
aw88166_i2c_probe(struct i2c_client * i2c)1877 static int aw88166_i2c_probe(struct i2c_client *i2c)
1878 {
1879 struct aw88166 *aw88166;
1880 int ret;
1881
1882 if (!i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C))
1883 return dev_err_probe(&i2c->dev, -ENXIO, "check_functionality failed\n");
1884
1885 aw88166 = devm_kzalloc(&i2c->dev, sizeof(*aw88166), GFP_KERNEL);
1886 if (!aw88166)
1887 return -ENOMEM;
1888
1889 mutex_init(&aw88166->lock);
1890
1891 i2c_set_clientdata(i2c, aw88166);
1892
1893 aw88166->reset_gpio = devm_gpiod_get_optional(&i2c->dev, "reset", GPIOD_OUT_LOW);
1894 if (IS_ERR(aw88166->reset_gpio))
1895 return dev_err_probe(&i2c->dev, PTR_ERR(aw88166->reset_gpio),
1896 "reset gpio not defined\n");
1897 aw88166_hw_reset(aw88166);
1898
1899 aw88166->regmap = devm_regmap_init_i2c(i2c, &aw88166_remap_config);
1900 if (IS_ERR(aw88166->regmap))
1901 return dev_err_probe(&i2c->dev, PTR_ERR(aw88166->regmap),
1902 "failed to init regmap\n");
1903
1904 /* aw pa init */
1905 ret = aw88166_init(aw88166, i2c, aw88166->regmap);
1906 if (ret)
1907 return ret;
1908
1909 return devm_snd_soc_register_component(&i2c->dev,
1910 &soc_codec_dev_aw88166,
1911 aw88166_dai, ARRAY_SIZE(aw88166_dai));
1912 }
1913
1914 static const struct i2c_device_id aw88166_i2c_id[] = {
1915 { AW88166_I2C_NAME },
1916 { }
1917 };
1918 MODULE_DEVICE_TABLE(i2c, aw88166_i2c_id);
1919
1920 static struct i2c_driver aw88166_i2c_driver = {
1921 .driver = {
1922 .name = AW88166_I2C_NAME,
1923 },
1924 .probe = aw88166_i2c_probe,
1925 .id_table = aw88166_i2c_id,
1926 };
1927 module_i2c_driver(aw88166_i2c_driver);
1928
1929 MODULE_DESCRIPTION("ASoC AW88166 Smart PA Driver");
1930 MODULE_LICENSE("GPL v2");
1931