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

source code of linux/sound/soc/codecs/aw88399.c