aw88399.c

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