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