aw88081.c

   1// SPDX-License-Identifier: GPL-2.0-only
   2//
   3// aw88081.c  --  AW88081 ALSA SoC Audio driver
   4//
   5// Copyright (c) 2024 awinic Technology CO., LTD
   6//
   7// Author: Weidong Wang <wangweidong.a@awinic.com>
   8//
   9
  10#include <linux/firmware.h>
  11#include <linux/i2c.h>
  12#include <linux/regmap.h>
  13#include <sound/soc.h>
  14#include "aw88081.h"
  15#include "aw88395/aw88395_device.h"
  16
  17enum aw8808x_type {
  18	AW88081,
  19	AW88083,
  20};
  21
  22struct aw88081 {
  23	struct aw_device *aw_pa;
  24	struct mutex lock;
  25	struct delayed_work start_work;
  26	struct regmap *regmap;
  27	struct aw_container *aw_cfg;
  28	enum aw8808x_type devtype;
  29	bool phase_sync;
  30};
  31
  32static const struct regmap_config aw88081_regmap_config = {
  33	.val_bits = 16,
  34	.reg_bits = 8,
  35	.max_register = AW88081_REG_MAX,
  36	.reg_format_endian = REGMAP_ENDIAN_LITTLE,
  37	.val_format_endian = REGMAP_ENDIAN_BIG,
  38};
  39
  40static const struct regmap_config aw88083_regmap_config = {
  41	.val_bits = 16,
  42	.reg_bits = 8,
  43	.max_register = AW88083_REG_MAX,
  44	.reg_format_endian = REGMAP_ENDIAN_LITTLE,
  45	.val_format_endian = REGMAP_ENDIAN_BIG,
  46};
  47
  48static int aw88081_dev_get_iis_status(struct aw_device *aw_dev)
  49{
  50	unsigned int reg_val;
  51	int ret;
  52
  53	ret = regmap_read(aw_dev->regmap, AW88081_SYSST_REG, &reg_val);
  54	if (ret)
  55		return ret;
  56	if ((reg_val & AW88081_BIT_PLL_CHECK) != AW88081_BIT_PLL_CHECK) {
  57		dev_err(aw_dev->dev, "check pll lock fail,reg_val:0x%04x", reg_val);
  58		return -EINVAL;
  59	}
  60
  61	return 0;
  62}
  63
  64static int aw88081_dev_check_mode1_pll(struct aw_device *aw_dev)
  65{
  66	int ret, i;
  67
  68	for (i = 0; i < AW88081_DEV_SYSST_CHECK_MAX; i++) {
  69		ret = aw88081_dev_get_iis_status(aw_dev);
  70		if (ret) {
  71			dev_err(aw_dev->dev, "mode1 iis signal check error");
  72			usleep_range(AW88081_2000_US, AW88081_2000_US + 10);
  73		} else {
  74			return 0;
  75		}
  76	}
  77
  78	return -EPERM;
  79}
  80
  81static int aw88081_dev_check_mode2_pll(struct aw_device *aw_dev)
  82{
  83	unsigned int reg_val;
  84	int ret, i;
  85
  86	ret = regmap_read(aw_dev->regmap, AW88081_PLLCTRL1_REG, &reg_val);
  87	if (ret)
  88		return ret;
  89
  90	reg_val &= (~AW88081_CCO_MUX_MASK);
  91	if (reg_val == AW88081_CCO_MUX_DIVIDED_VALUE) {
  92		dev_dbg(aw_dev->dev, "CCO_MUX is already divider");
  93		return -EPERM;
  94	}
  95
  96	/* change mode2 */
  97	ret = regmap_update_bits(aw_dev->regmap, AW88081_PLLCTRL1_REG,
  98			~AW88081_CCO_MUX_MASK, AW88081_CCO_MUX_DIVIDED_VALUE);
  99	if (ret)
 100		return ret;
 101
 102	for (i = 0; i < AW88081_DEV_SYSST_CHECK_MAX; i++) {
 103		ret = aw88081_dev_get_iis_status(aw_dev);
 104		if (ret) {
 105			dev_err(aw_dev->dev, "mode2 iis check error");
 106			usleep_range(AW88081_2000_US, AW88081_2000_US + 10);
 107		} else {
 108			break;
 109		}
 110	}
 111
 112	/* change mode1 */
 113	ret = regmap_update_bits(aw_dev->regmap, AW88081_PLLCTRL1_REG,
 114			~AW88081_CCO_MUX_MASK, AW88081_CCO_MUX_BYPASS_VALUE);
 115	if (ret == 0) {
 116		usleep_range(AW88081_2000_US, AW88081_2000_US + 10);
 117		for (i = 0; i < AW88081_DEV_SYSST_CHECK_MAX; i++) {
 118			ret = aw88081_dev_check_mode1_pll(aw_dev);
 119			if (ret) {
 120				dev_err(aw_dev->dev, "mode2 switch to mode1, iis check error");
 121				usleep_range(AW88081_2000_US, AW88081_2000_US + 10);
 122			} else {
 123				break;
 124			}
 125		}
 126	}
 127
 128	return ret;
 129}
 130
 131static int aw88081_dev_check_syspll(struct aw_device *aw_dev)
 132{
 133	int ret;
 134
 135	ret = aw88081_dev_check_mode1_pll(aw_dev);
 136	if (ret) {
 137		dev_dbg(aw_dev->dev, "mode1 check iis failed try switch to mode2 check");
 138		ret = aw88081_dev_check_mode2_pll(aw_dev);
 139		if (ret) {
 140			dev_err(aw_dev->dev, "mode2 check iis failed");
 141			return ret;
 142		}
 143	}
 144
 145	return 0;
 146}
 147
 148static int aw88081_dev_check_sysst(struct aw_device *aw_dev)
 149{
 150	unsigned int check_val;
 151	unsigned int reg_val;
 152	unsigned int value;
 153	int ret, i;
 154
 155	ret = regmap_read(aw_dev->regmap, AW88081_PWMCTRL4_REG, &reg_val);
 156	if (ret)
 157		return ret;
 158
 159	if (reg_val & (~AW88081_NOISE_GATE_EN_MASK))
 160		check_val = AW88081_NO_SWS_SYSST_CHECK;
 161	else
 162		check_val = AW88081_SWS_SYSST_CHECK;
 163
 164	for (i = 0; i < AW88081_DEV_SYSST_CHECK_MAX; i++) {
 165		ret = regmap_read(aw_dev->regmap, AW88081_SYSST_REG, &reg_val);
 166		if (ret)
 167			return ret;
 168
 169		value = reg_val & (~AW88081_BIT_SYSST_CHECK_MASK) & check_val;
 170		if (value != check_val) {
 171			dev_err(aw_dev->dev, "check sysst fail, reg_val=0x%04x, check:0x%x",
 172				reg_val, check_val);
 173			usleep_range(AW88081_2000_US, AW88081_2000_US + 10);
 174		} else {
 175			return 0;
 176		}
 177	}
 178
 179	return -EPERM;
 180}
 181
 182static void aw88081_dev_i2s_tx_enable(struct aw_device *aw_dev, bool flag)
 183{
 184	if (flag)
 185		regmap_update_bits(aw_dev->regmap, AW88081_I2SCTRL3_REG,
 186			~AW88081_I2STXEN_MASK, AW88081_I2STXEN_ENABLE_VALUE);
 187	else
 188		regmap_update_bits(aw_dev->regmap, AW88081_I2SCTRL3_REG,
 189			~AW88081_I2STXEN_MASK, AW88081_I2STXEN_DISABLE_VALUE);
 190}
 191
 192static void aw88081_dev_pwd(struct aw_device *aw_dev, bool pwd)
 193{
 194	if (pwd)
 195		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 196				~AW88081_PWDN_MASK, AW88081_PWDN_POWER_DOWN_VALUE);
 197	else
 198		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 199				~AW88081_PWDN_MASK, AW88081_PWDN_WORKING_VALUE);
 200}
 201
 202static void aw88081_dev_amppd(struct aw_device *aw_dev, bool amppd)
 203{
 204	if (amppd)
 205		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 206				~AW88081_EN_PA_MASK, AW88081_EN_PA_POWER_DOWN_VALUE);
 207	else
 208		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 209				~AW88081_EN_PA_MASK, AW88081_EN_PA_WORKING_VALUE);
 210}
 211
 212static void aw88083_i2c_wen(struct aw88081 *aw88081, bool flag)
 213{
 214	struct aw_device *aw_dev = aw88081->aw_pa;
 215
 216	if (aw88081->devtype != AW88083)
 217		return;
 218
 219	if (flag)
 220		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 221				~AW88083_I2C_WEN_MASK, AW88083_I2C_WEN_ENABLE_VALUE);
 222	else
 223		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 224				~AW88083_I2C_WEN_MASK, AW88083_I2C_WEN_DISABLE_VALUE);
 225}
 226
 227static void aw88083_dev_amppd(struct aw_device *aw_dev, bool amppd)
 228{
 229	if (amppd)
 230		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 231				~AW88083_AMPPD_MASK, AW88083_AMPPD_POWER_DOWN_VALUE);
 232	else
 233		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 234				~AW88083_AMPPD_MASK, AW88083_AMPPD_WORKING_VALUE);
 235}
 236
 237static void aw88083_dev_pllpd(struct aw_device *aw_dev, bool pllpd)
 238{
 239	if (pllpd)
 240		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 241				~AW88083_PLL_PD_MASK, AW88083_PLL_PD_WORKING_VALUE);
 242	else
 243		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 244				~AW88083_PLL_PD_MASK, AW88083_PLL_PD_POWER_DOWN_VALUE);
 245}
 246
 247static void aw88081_dev_clear_int_status(struct aw_device *aw_dev)
 248{
 249	unsigned int int_status;
 250
 251	/* read int status and clear */
 252	regmap_read(aw_dev->regmap, AW88081_SYSINT_REG, &int_status);
 253	/* make sure int status is clear */
 254	regmap_read(aw_dev->regmap, AW88081_SYSINT_REG, &int_status);
 255
 256	dev_dbg(aw_dev->dev, "read interrupt reg = 0x%04x", int_status);
 257}
 258
 259static void aw88081_dev_set_volume(struct aw_device *aw_dev, unsigned int value)
 260{
 261	struct aw_volume_desc *vol_desc = &aw_dev->volume_desc;
 262	unsigned int volume;
 263
 264	volume = min((value + vol_desc->init_volume), (unsigned int)AW88081_MUTE_VOL);
 265
 266	regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL2_REG, ~AW88081_VOL_MASK, volume);
 267}
 268
 269static void aw88081_dev_fade_in(struct aw_device *aw_dev)
 270{
 271	struct aw_volume_desc *desc = &aw_dev->volume_desc;
 272	int fade_in_vol = desc->ctl_volume;
 273	int fade_step = aw_dev->fade_step;
 274	int i;
 275
 276	if (fade_step == 0 || aw_dev->fade_in_time == 0) {
 277		aw88081_dev_set_volume(aw_dev, fade_in_vol);
 278		return;
 279	}
 280
 281	for (i = AW88081_MUTE_VOL; i >= fade_in_vol; i -= fade_step) {
 282		aw88081_dev_set_volume(aw_dev, i);
 283		usleep_range(aw_dev->fade_in_time, aw_dev->fade_in_time + 10);
 284	}
 285
 286	if (i != fade_in_vol)
 287		aw88081_dev_set_volume(aw_dev, fade_in_vol);
 288}
 289
 290static void aw88081_dev_fade_out(struct aw_device *aw_dev)
 291{
 292	struct aw_volume_desc *desc = &aw_dev->volume_desc;
 293	int fade_step = aw_dev->fade_step;
 294	int i;
 295
 296	if (fade_step == 0 || aw_dev->fade_out_time == 0) {
 297		aw88081_dev_set_volume(aw_dev, AW88081_MUTE_VOL);
 298		return;
 299	}
 300
 301	for (i = desc->ctl_volume; i <= AW88081_MUTE_VOL; i += fade_step) {
 302		aw88081_dev_set_volume(aw_dev, i);
 303		usleep_range(aw_dev->fade_out_time, aw_dev->fade_out_time + 10);
 304	}
 305
 306	if (i != AW88081_MUTE_VOL)
 307		aw88081_dev_set_volume(aw_dev, AW88081_MUTE_VOL);
 308}
 309
 310static void aw88081_dev_mute(struct aw_device *aw_dev, bool is_mute)
 311{
 312	if (is_mute) {
 313		aw88081_dev_fade_out(aw_dev);
 314		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 315				~AW88081_HMUTE_MASK, AW88081_HMUTE_ENABLE_VALUE);
 316	} else {
 317		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 318				~AW88081_HMUTE_MASK, AW88081_HMUTE_DISABLE_VALUE);
 319		aw88081_dev_fade_in(aw_dev);
 320	}
 321}
 322
 323static void aw88081_dev_uls_hmute(struct aw_device *aw_dev, bool uls_hmute)
 324{
 325	if (uls_hmute)
 326		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 327				~AW88081_ULS_HMUTE_MASK,
 328				AW88081_ULS_HMUTE_ENABLE_VALUE);
 329	else
 330		regmap_update_bits(aw_dev->regmap, AW88081_SYSCTRL_REG,
 331				~AW88081_ULS_HMUTE_MASK,
 332				AW88081_ULS_HMUTE_DISABLE_VALUE);
 333}
 334
 335static int aw88081_dev_reg_value_check(struct aw_device *aw_dev,
 336					unsigned char reg_addr, unsigned short *reg_val)
 337{
 338	unsigned int read_vol;
 339
 340	if (reg_addr == AW88081_SYSCTRL_REG) {
 341		*reg_val &= ~(~AW88081_EN_PA_MASK |
 342			      ~AW88081_PWDN_MASK |
 343			      ~AW88081_HMUTE_MASK |
 344			      ~AW88081_ULS_HMUTE_MASK);
 345
 346		*reg_val |= AW88081_EN_PA_POWER_DOWN_VALUE |
 347			    AW88081_PWDN_POWER_DOWN_VALUE |
 348			    AW88081_HMUTE_ENABLE_VALUE |
 349			    AW88081_ULS_HMUTE_ENABLE_VALUE;
 350	}
 351
 352	if (reg_addr == AW88081_SYSCTRL2_REG) {
 353		read_vol = (*reg_val & (~AW88081_VOL_MASK)) >> AW88081_VOL_START_BIT;
 354		aw_dev->volume_desc.init_volume = read_vol;
 355	}
 356
 357	/* i2stxen */
 358	if (reg_addr == AW88081_I2SCTRL3_REG) {
 359		/* close tx */
 360		*reg_val &= AW88081_I2STXEN_MASK;
 361		*reg_val |= AW88081_I2STXEN_DISABLE_VALUE;
 362	}
 363
 364	return 0;
 365}
 366
 367static int aw88083_dev_reg_value_check(struct aw_device *aw_dev,
 368					unsigned char reg_addr, unsigned short *reg_val)
 369{
 370	unsigned int read_vol;
 371
 372	if (reg_addr == AW88081_SYSCTRL_REG) {
 373		*reg_val &= ~(~AW88083_AMPPD_MASK |
 374			      ~AW88081_PWDN_MASK |
 375			      ~AW88081_HMUTE_MASK |
 376			      ~AW88083_I2C_WEN_MASK);
 377
 378		*reg_val |= AW88083_AMPPD_POWER_DOWN_VALUE |
 379			    AW88081_PWDN_POWER_DOWN_VALUE |
 380			    AW88081_HMUTE_ENABLE_VALUE |
 381			    AW88083_I2C_WEN_ENABLE_VALUE;
 382	}
 383
 384	if (reg_addr == AW88081_SYSCTRL2_REG) {
 385		read_vol = (*reg_val & (~AW88081_VOL_MASK)) >> AW88081_VOL_START_BIT;
 386		aw_dev->volume_desc.init_volume = read_vol;
 387	}
 388
 389	return 0;
 390}
 391
 392static int aw88081_reg_value_check(struct aw88081 *aw88081,
 393					unsigned char reg_addr, unsigned short *reg_val)
 394{
 395	struct aw_device *aw_dev = aw88081->aw_pa;
 396	int ret;
 397
 398	switch (aw88081->devtype) {
 399	case AW88081:
 400		ret = aw88081_dev_reg_value_check(aw_dev, reg_addr, reg_val);
 401		break;
 402	case AW88083:
 403		ret = aw88083_dev_reg_value_check(aw_dev, reg_addr, reg_val);
 404		break;
 405	default:
 406		dev_err(aw_dev->dev, "unsupported device\n");
 407		ret = -EINVAL;
 408		break;
 409	}
 410
 411	return ret;
 412}
 413
 414static int aw88081_dev_reg_update(struct aw88081 *aw88081,
 415					unsigned char *data, unsigned int len)
 416{
 417	struct aw_device *aw_dev = aw88081->aw_pa;
 418	struct aw_volume_desc *vol_desc = &aw_dev->volume_desc;
 419	int data_len, i, ret;
 420	int16_t *reg_data;
 421	u16 reg_val;
 422	u8 reg_addr;
 423
 424	if (!len || !data) {
 425		dev_err(aw_dev->dev, "reg data is null or len is 0");
 426		return -EINVAL;
 427	}
 428
 429	reg_data = (int16_t *)data;
 430	data_len = len >> 1;
 431
 432	if (data_len & 0x1) {
 433		dev_err(aw_dev->dev, "data len:%d unsupported",	data_len);
 434		return -EINVAL;
 435	}
 436
 437	for (i = 0; i < data_len; i += 2) {
 438		reg_addr = reg_data[i];
 439		reg_val = reg_data[i + 1];
 440
 441		ret = aw88081_reg_value_check(aw88081, reg_addr, &reg_val);
 442		if (ret)
 443			return ret;
 444
 445		ret = regmap_write(aw_dev->regmap, reg_addr, reg_val);
 446		if (ret)
 447			return ret;
 448	}
 449
 450	if (aw_dev->prof_cur != aw_dev->prof_index)
 451		vol_desc->ctl_volume = 0;
 452
 453	/* keep min volume */
 454	aw88081_dev_set_volume(aw_dev, vol_desc->mute_volume);
 455
 456	return 0;
 457}
 458
 459static int aw88081_dev_get_prof_name(struct aw_device *aw_dev, int index, char **prof_name)
 460{
 461	struct aw_prof_info *prof_info = &aw_dev->prof_info;
 462	struct aw_prof_desc *prof_desc;
 463
 464	if ((index >= aw_dev->prof_info.count) || (index < 0)) {
 465		dev_err(aw_dev->dev, "index[%d] overflow count[%d]",
 466			index, aw_dev->prof_info.count);
 467		return -EINVAL;
 468	}
 469
 470	prof_desc = &aw_dev->prof_info.prof_desc[index];
 471
 472	*prof_name = prof_info->prof_name_list[prof_desc->id];
 473
 474	return 0;
 475}
 476
 477static int aw88081_dev_get_prof_data(struct aw_device *aw_dev, int index,
 478			struct aw_prof_desc **prof_desc)
 479{
 480	if ((index >= aw_dev->prof_info.count) || (index < 0)) {
 481		dev_err(aw_dev->dev, "%s: index[%d] overflow count[%d]\n",
 482				__func__, index, aw_dev->prof_info.count);
 483		return -EINVAL;
 484	}
 485
 486	*prof_desc = &aw_dev->prof_info.prof_desc[index];
 487
 488	return 0;
 489}
 490
 491static int aw88081_dev_fw_update(struct aw88081 *aw88081)
 492{
 493	struct aw_device *aw_dev = aw88081->aw_pa;
 494	struct aw_prof_desc *prof_index_desc;
 495	struct aw_sec_data_desc *sec_desc;
 496	char *prof_name;
 497	int ret;
 498
 499	ret = aw88081_dev_get_prof_name(aw_dev, aw_dev->prof_index, &prof_name);
 500	if (ret) {
 501		dev_err(aw_dev->dev, "get prof name failed");
 502		return -EINVAL;
 503	}
 504
 505	dev_dbg(aw_dev->dev, "start update %s", prof_name);
 506
 507	ret = aw88081_dev_get_prof_data(aw_dev, aw_dev->prof_index, &prof_index_desc);
 508	if (ret)
 509		return ret;
 510
 511	/* update reg */
 512	sec_desc = prof_index_desc->sec_desc;
 513	ret = aw88081_dev_reg_update(aw88081, sec_desc[AW88395_DATA_TYPE_REG].data,
 514					sec_desc[AW88395_DATA_TYPE_REG].len);
 515	if (ret) {
 516		dev_err(aw_dev->dev, "update reg failed");
 517		return ret;
 518	}
 519
 520	aw_dev->prof_cur = aw_dev->prof_index;
 521
 522	return 0;
 523}
 524
 525static int aw88081_dev_start(struct aw88081 *aw88081)
 526{
 527	struct aw_device *aw_dev = aw88081->aw_pa;
 528	int ret;
 529
 530	if (aw_dev->status == AW88081_DEV_PW_ON) {
 531		dev_dbg(aw_dev->dev, "already power on");
 532		return 0;
 533	}
 534
 535	/* power on */
 536	aw88081_dev_pwd(aw_dev, false);
 537	usleep_range(AW88081_2000_US, AW88081_2000_US + 10);
 538
 539	ret = aw88081_dev_check_syspll(aw_dev);
 540	if (ret) {
 541		dev_err(aw_dev->dev, "pll check failed cannot start");
 542		goto pll_check_fail;
 543	}
 544
 545	/* amppd on */
 546	aw88081_dev_amppd(aw_dev, false);
 547	usleep_range(AW88081_1000_US, AW88081_1000_US + 50);
 548
 549	/* check i2s status */
 550	ret = aw88081_dev_check_sysst(aw_dev);
 551	if (ret) {
 552		dev_err(aw_dev->dev, "sysst check failed");
 553		goto sysst_check_fail;
 554	}
 555
 556	/* enable tx feedback */
 557	aw88081_dev_i2s_tx_enable(aw_dev, true);
 558
 559	/* close uls mute */
 560	aw88081_dev_uls_hmute(aw_dev, false);
 561
 562	/* close mute */
 563	aw88081_dev_mute(aw_dev, false);
 564
 565	/* clear inturrupt */
 566	aw88081_dev_clear_int_status(aw_dev);
 567	aw_dev->status = AW88081_DEV_PW_ON;
 568
 569	return 0;
 570
 571sysst_check_fail:
 572	aw88081_dev_i2s_tx_enable(aw_dev, false);
 573	aw88081_dev_clear_int_status(aw_dev);
 574	aw88081_dev_amppd(aw_dev, true);
 575pll_check_fail:
 576	aw88081_dev_pwd(aw_dev, true);
 577	aw_dev->status = AW88081_DEV_PW_OFF;
 578
 579	return ret;
 580}
 581
 582static int aw88083_dev_start(struct aw88081 *aw88081)
 583{
 584	struct aw_device *aw_dev = aw88081->aw_pa;
 585
 586	if (aw_dev->status == AW88081_DEV_PW_ON) {
 587		dev_dbg(aw_dev->dev, "already power on");
 588		return 0;
 589	}
 590
 591	aw88083_i2c_wen(aw88081, true);
 592
 593	/* power on */
 594	aw88081_dev_pwd(aw_dev, false);
 595	usleep_range(AW88081_2000_US, AW88081_2000_US + 10);
 596
 597	aw88083_dev_pllpd(aw_dev, true);
 598	/* amppd on */
 599	aw88083_dev_amppd(aw_dev, false);
 600	usleep_range(AW88081_2000_US, AW88081_2000_US + 50);
 601
 602	/* close mute */
 603	aw88081_dev_mute(aw_dev, false);
 604
 605	aw88083_i2c_wen(aw88081, false);
 606
 607	aw_dev->status = AW88081_DEV_PW_ON;
 608
 609	return 0;
 610}
 611
 612static int aw88081_device_start(struct aw88081 *aw88081)
 613{
 614	int ret;
 615
 616	switch (aw88081->devtype) {
 617	case AW88081:
 618		ret = aw88081_dev_start(aw88081);
 619		break;
 620	case AW88083:
 621		ret = aw88083_dev_start(aw88081);
 622		break;
 623	default:
 624		ret = -EINVAL;
 625		dev_err(aw88081->aw_pa->dev, "unsupported device\n");
 626		break;
 627	}
 628
 629	return ret;
 630}
 631
 632static int aw88081_dev_stop(struct aw88081 *aw88081)
 633{
 634	struct aw_device *aw_dev = aw88081->aw_pa;
 635
 636	if (aw_dev->status == AW88081_DEV_PW_OFF) {
 637		dev_dbg(aw_dev->dev, "already power off");
 638		return 0;
 639	}
 640
 641	aw_dev->status = AW88081_DEV_PW_OFF;
 642
 643	/* clear inturrupt */
 644	aw88081_dev_clear_int_status(aw_dev);
 645
 646	aw88081_dev_uls_hmute(aw_dev, true);
 647	/* set mute */
 648	aw88081_dev_mute(aw_dev, true);
 649
 650	/* close tx feedback */
 651	aw88081_dev_i2s_tx_enable(aw_dev, false);
 652	usleep_range(AW88081_1000_US, AW88081_1000_US + 100);
 653
 654	/* enable amppd */
 655	aw88081_dev_amppd(aw_dev, true);
 656
 657	/* set power down */
 658	aw88081_dev_pwd(aw_dev, true);
 659
 660	return 0;
 661}
 662
 663static int aw88083_dev_stop(struct aw88081 *aw88081)
 664{
 665	struct aw_device *aw_dev = aw88081->aw_pa;
 666
 667	if (aw_dev->status == AW88081_DEV_PW_OFF) {
 668		dev_dbg(aw_dev->dev, "already power off");
 669		return 0;
 670	}
 671
 672	aw_dev->status = AW88081_DEV_PW_OFF;
 673
 674	aw88083_i2c_wen(aw88081, true);
 675	/* set mute */
 676	aw88081_dev_mute(aw_dev, true);
 677
 678	usleep_range(AW88081_2000_US, AW88081_2000_US + 100);
 679
 680	/* enable amppd */
 681	aw88083_dev_amppd(aw_dev, true);
 682
 683	aw88083_dev_pllpd(aw_dev, false);
 684
 685	/* set power down */
 686	aw88081_dev_pwd(aw_dev, true);
 687
 688	aw88083_i2c_wen(aw88081, false);
 689
 690	return 0;
 691}
 692
 693static int aw88081_stop(struct aw88081 *aw88081)
 694{
 695	int ret;
 696
 697	switch (aw88081->devtype) {
 698	case AW88081:
 699		ret = aw88081_dev_stop(aw88081);
 700		break;
 701	case AW88083:
 702		ret = aw88083_dev_stop(aw88081);
 703		break;
 704	default:
 705		dev_err(aw88081->aw_pa->dev, "unsupported device\n");
 706		ret = -EINVAL;
 707		break;
 708	}
 709
 710	return ret;
 711}
 712
 713static int aw88081_reg_update(struct aw88081 *aw88081, bool force)
 714{
 715	struct aw_device *aw_dev = aw88081->aw_pa;
 716	int ret;
 717
 718	if (force) {
 719		ret = regmap_write(aw_dev->regmap,
 720					AW88081_ID_REG, AW88081_SOFT_RESET_VALUE);
 721		if (ret)
 722			return ret;
 723
 724		ret = aw88081_dev_fw_update(aw88081);
 725		if (ret)
 726			return ret;
 727	} else {
 728		if (aw_dev->prof_cur != aw_dev->prof_index) {
 729			ret = aw88081_dev_fw_update(aw88081);
 730			if (ret)
 731				return ret;
 732		}
 733	}
 734
 735	aw_dev->prof_cur = aw_dev->prof_index;
 736
 737	return 0;
 738}
 739
 740static void aw88081_start_pa(struct aw88081 *aw88081)
 741{
 742	int ret, i;
 743
 744	for (i = 0; i < AW88081_START_RETRIES; i++) {
 745		ret = aw88081_reg_update(aw88081, aw88081->phase_sync);
 746		if (ret) {
 747			dev_err(aw88081->aw_pa->dev, "fw update failed, cnt:%d\n", i);
 748			continue;
 749		}
 750		ret = aw88081_device_start(aw88081);
 751		if (ret) {
 752			dev_err(aw88081->aw_pa->dev, "aw88081 device start failed. retry = %d", i);
 753			continue;
 754		} else {
 755			dev_dbg(aw88081->aw_pa->dev, "start success\n");
 756			break;
 757		}
 758	}
 759}
 760
 761static void aw88081_startup_work(struct work_struct *work)
 762{
 763	struct aw88081 *aw88081 =
 764		container_of(work, struct aw88081, start_work.work);
 765
 766	mutex_lock(&aw88081->lock);
 767	aw88081_start_pa(aw88081);
 768	mutex_unlock(&aw88081->lock);
 769}
 770
 771static void aw88081_start(struct aw88081 *aw88081, bool sync_start)
 772{
 773	if (aw88081->aw_pa->fw_status != AW88081_DEV_FW_OK)
 774		return;
 775
 776	if (aw88081->aw_pa->status == AW88081_DEV_PW_ON)
 777		return;
 778
 779	if (sync_start == AW88081_SYNC_START)
 780		aw88081_start_pa(aw88081);
 781	else
 782		queue_delayed_work(system_dfl_wq,
 783			&aw88081->start_work,
 784			AW88081_START_WORK_DELAY_MS);
 785}
 786
 787static struct snd_soc_dai_driver aw88081_dai[] = {
 788	{
 789		.name = "aw88081-aif",
 790		.id = 1,
 791		.playback = {
 792			.stream_name = "Speaker_Playback",
 793			.channels_min = 1,
 794			.channels_max = 2,
 795			.rates = AW88081_RATES,
 796			.formats = AW88081_FORMATS,
 797		},
 798		.capture = {
 799			.stream_name = "Speaker_Capture",
 800			.channels_min = 1,
 801			.channels_max = 2,
 802			.rates = AW88081_RATES,
 803			.formats = AW88081_FORMATS,
 804		},
 805	},
 806};
 807
 808static int aw88081_get_fade_in_time(struct snd_kcontrol *kcontrol,
 809	struct snd_ctl_elem_value *ucontrol)
 810{
 811	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 812	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(component);
 813	struct aw_device *aw_dev = aw88081->aw_pa;
 814
 815	ucontrol->value.integer.value[0] = aw_dev->fade_in_time;
 816
 817	return 0;
 818}
 819
 820static int aw88081_set_fade_in_time(struct snd_kcontrol *kcontrol,
 821	struct snd_ctl_elem_value *ucontrol)
 822{
 823	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 824	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(component);
 825	struct soc_mixer_control *mc =
 826		(struct soc_mixer_control *)kcontrol->private_value;
 827	struct aw_device *aw_dev = aw88081->aw_pa;
 828	int time;
 829
 830	time = ucontrol->value.integer.value[0];
 831
 832	if (time < mc->min || time > mc->max)
 833		return -EINVAL;
 834
 835	if (time != aw_dev->fade_in_time) {
 836		aw_dev->fade_in_time = time;
 837		return 1;
 838	}
 839
 840	return 0;
 841}
 842
 843static int aw88081_get_fade_out_time(struct snd_kcontrol *kcontrol,
 844	struct snd_ctl_elem_value *ucontrol)
 845{
 846	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 847	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(component);
 848	struct aw_device *aw_dev = aw88081->aw_pa;
 849
 850	ucontrol->value.integer.value[0] = aw_dev->fade_out_time;
 851
 852	return 0;
 853}
 854
 855static int aw88081_set_fade_out_time(struct snd_kcontrol *kcontrol,
 856	struct snd_ctl_elem_value *ucontrol)
 857{
 858	struct snd_soc_component *component = snd_kcontrol_chip(kcontrol);
 859	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(component);
 860	struct soc_mixer_control *mc =
 861		(struct soc_mixer_control *)kcontrol->private_value;
 862	struct aw_device *aw_dev = aw88081->aw_pa;
 863	int time;
 864
 865	time = ucontrol->value.integer.value[0];
 866	if (time < mc->min || time > mc->max)
 867		return -EINVAL;
 868
 869	if (time != aw_dev->fade_out_time) {
 870		aw_dev->fade_out_time = time;
 871		return 1;
 872	}
 873
 874	return 0;
 875}
 876
 877static int aw88081_dev_set_profile_index(struct aw_device *aw_dev, int index)
 878{
 879	/* check the index whether is valid */
 880	if ((index >= aw_dev->prof_info.count) || (index < 0))
 881		return -EINVAL;
 882	/* check the index whether change */
 883	if (aw_dev->prof_index == index)
 884		return -EPERM;
 885
 886	aw_dev->prof_index = index;
 887
 888	return 0;
 889}
 890
 891static int aw88081_profile_info(struct snd_kcontrol *kcontrol,
 892			 struct snd_ctl_elem_info *uinfo)
 893{
 894	struct snd_soc_component *codec = snd_kcontrol_chip(kcontrol);
 895	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(codec);
 896	char *prof_name;
 897	int count, ret;
 898
 899	uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
 900	uinfo->count = 1;
 901
 902	count = aw88081->aw_pa->prof_info.count;
 903	if (count <= 0) {
 904		uinfo->value.enumerated.items = 0;
 905		return 0;
 906	}
 907
 908	uinfo->value.enumerated.items = count;
 909
 910	if (uinfo->value.enumerated.item >= count)
 911		uinfo->value.enumerated.item = count - 1;
 912
 913	count = uinfo->value.enumerated.item;
 914
 915	ret = aw88081_dev_get_prof_name(aw88081->aw_pa, count, &prof_name);
 916	if (ret) {
 917		strscpy(uinfo->value.enumerated.name, "null");
 918		return 0;
 919	}
 920
 921	strscpy(uinfo->value.enumerated.name, prof_name);
 922
 923	return 0;
 924}
 925
 926static int aw88081_profile_get(struct snd_kcontrol *kcontrol,
 927			struct snd_ctl_elem_value *ucontrol)
 928{
 929	struct snd_soc_component *codec = snd_kcontrol_chip(kcontrol);
 930	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(codec);
 931
 932	ucontrol->value.integer.value[0] = aw88081->aw_pa->prof_index;
 933
 934	return 0;
 935}
 936
 937static int aw88081_profile_set(struct snd_kcontrol *kcontrol,
 938		struct snd_ctl_elem_value *ucontrol)
 939{
 940	struct snd_soc_component *codec = snd_kcontrol_chip(kcontrol);
 941	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(codec);
 942	int ret;
 943
 944	/* pa stop or stopping just set profile */
 945	mutex_lock(&aw88081->lock);
 946	ret = aw88081_dev_set_profile_index(aw88081->aw_pa, ucontrol->value.integer.value[0]);
 947	if (ret) {
 948		dev_dbg(codec->dev, "profile index does not change");
 949		mutex_unlock(&aw88081->lock);
 950		return 0;
 951	}
 952
 953	if (aw88081->aw_pa->status) {
 954		aw88081_stop(aw88081);
 955		aw88081_start(aw88081, AW88081_SYNC_START);
 956	}
 957
 958	mutex_unlock(&aw88081->lock);
 959
 960	return 1;
 961}
 962
 963static int aw88081_volume_get(struct snd_kcontrol *kcontrol,
 964				struct snd_ctl_elem_value *ucontrol)
 965{
 966	struct snd_soc_component *codec = snd_kcontrol_chip(kcontrol);
 967	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(codec);
 968	struct aw_volume_desc *vol_desc = &aw88081->aw_pa->volume_desc;
 969
 970	ucontrol->value.integer.value[0] = vol_desc->ctl_volume;
 971
 972	return 0;
 973}
 974
 975static int aw88081_volume_set(struct snd_kcontrol *kcontrol,
 976				struct snd_ctl_elem_value *ucontrol)
 977{
 978	struct snd_soc_component *codec = snd_kcontrol_chip(kcontrol);
 979	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(codec);
 980	struct aw_volume_desc *vol_desc = &aw88081->aw_pa->volume_desc;
 981	struct soc_mixer_control *mc =
 982		(struct soc_mixer_control *)kcontrol->private_value;
 983	int value;
 984
 985	value = ucontrol->value.integer.value[0];
 986
 987	if (value < mc->min || value > mc->max)
 988		return -EINVAL;
 989
 990	aw88083_i2c_wen(aw88081, true);
 991
 992	if (vol_desc->ctl_volume != value) {
 993		vol_desc->ctl_volume = value;
 994		aw88081_dev_set_volume(aw88081->aw_pa, vol_desc->ctl_volume);
 995		return 1;
 996	}
 997
 998	aw88083_i2c_wen(aw88081, false);
 999
1000	return 0;
1001}
1002
1003static int aw88081_get_fade_step(struct snd_kcontrol *kcontrol,
1004				struct snd_ctl_elem_value *ucontrol)
1005{
1006	struct snd_soc_component *codec = snd_kcontrol_chip(kcontrol);
1007	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(codec);
1008
1009	ucontrol->value.integer.value[0] = aw88081->aw_pa->fade_step;
1010
1011	return 0;
1012}
1013
1014static int aw88081_set_fade_step(struct snd_kcontrol *kcontrol,
1015				struct snd_ctl_elem_value *ucontrol)
1016{
1017	struct snd_soc_component *codec = snd_kcontrol_chip(kcontrol);
1018	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(codec);
1019	struct soc_mixer_control *mc =
1020		(struct soc_mixer_control *)kcontrol->private_value;
1021	int value;
1022
1023	value = ucontrol->value.integer.value[0];
1024	if (value < mc->min || value > mc->max)
1025		return -EINVAL;
1026
1027	if (aw88081->aw_pa->fade_step != value) {
1028		aw88081->aw_pa->fade_step = value;
1029		return 1;
1030	}
1031
1032	return 0;
1033}
1034
1035static const struct snd_kcontrol_new aw88081_controls[] = {
1036	SOC_SINGLE_EXT("PCM Playback Volume", AW88081_SYSCTRL2_REG,
1037		0, AW88081_MUTE_VOL, 0, aw88081_volume_get,
1038		aw88081_volume_set),
1039	SOC_SINGLE_EXT("Fade Step", 0, 0, AW88081_MUTE_VOL, 0,
1040		aw88081_get_fade_step, aw88081_set_fade_step),
1041	SOC_SINGLE_EXT("Volume Ramp Up Step", 0, 0, FADE_TIME_MAX, 0,
1042		aw88081_get_fade_in_time, aw88081_set_fade_in_time),
1043	SOC_SINGLE_EXT("Volume Ramp Down Step", 0, 0, FADE_TIME_MAX, 0,
1044		aw88081_get_fade_out_time, aw88081_set_fade_out_time),
1045	AW88081_PROFILE_EXT("Profile Set", aw88081_profile_info,
1046		aw88081_profile_get, aw88081_profile_set),
1047};
1048
1049static void aw88081_parse_channel_dt(struct aw88081 *aw88081)
1050{
1051	struct aw_device *aw_dev = aw88081->aw_pa;
1052	struct device_node *np = aw_dev->dev->of_node;
1053	u32 channel_value = AW88081_DEV_DEFAULT_CH;
1054
1055	of_property_read_u32(np, "awinic,audio-channel", &channel_value);
1056	aw88081->phase_sync = of_property_read_bool(np, "awinic,sync-flag");
1057
1058	aw_dev->channel = channel_value;
1059}
1060
1061static int aw88081_init(struct aw88081 *aw88081, struct i2c_client *i2c, struct regmap *regmap)
1062{
1063	struct aw_device *aw_dev;
1064	unsigned int chip_id;
1065	int ret;
1066
1067	/* read chip id */
1068	ret = regmap_read(regmap, AW88081_ID_REG, &chip_id);
1069	if (ret) {
1070		dev_err(&i2c->dev, "%s read chipid error. ret = %d", __func__, ret);
1071		return ret;
1072	}
1073
1074	switch (chip_id) {
1075	case AW88081_CHIP_ID:
1076		dev_dbg(&i2c->dev, "chip id = 0x%x\n", chip_id);
1077		break;
1078	case AW88083_CHIP_ID:
1079		dev_dbg(&i2c->dev, "chip id = 0x%x\n", chip_id);
1080		break;
1081	default:
1082		dev_err(&i2c->dev, "unsupported device");
1083		return -ENXIO;
1084	}
1085
1086	aw_dev = devm_kzalloc(&i2c->dev, sizeof(*aw_dev), GFP_KERNEL);
1087	if (!aw_dev)
1088		return -ENOMEM;
1089
1090	aw88081->aw_pa = aw_dev;
1091	aw_dev->i2c = i2c;
1092	aw_dev->regmap = regmap;
1093	aw_dev->dev = &i2c->dev;
1094	aw_dev->chip_id = chip_id;
1095	aw_dev->acf = NULL;
1096	aw_dev->prof_info.prof_desc = NULL;
1097	aw_dev->prof_info.prof_type = AW88395_DEV_NONE_TYPE_ID;
1098	aw_dev->fade_step = AW88081_VOLUME_STEP_DB;
1099	aw_dev->volume_desc.mute_volume = AW88081_MUTE_VOL;
1100	aw88081_parse_channel_dt(aw88081);
1101
1102	return 0;
1103}
1104
1105static int aw88081_dev_init(struct aw88081 *aw88081, struct aw_container *aw_cfg)
1106{
1107	struct aw_device *aw_dev = aw88081->aw_pa;
1108	int ret;
1109
1110	ret = aw88395_dev_cfg_load(aw_dev, aw_cfg);
1111	if (ret) {
1112		dev_err(aw_dev->dev, "aw_dev acf parse failed");
1113		return -EINVAL;
1114	}
1115
1116	ret = regmap_write(aw_dev->regmap, AW88081_ID_REG, AW88081_SOFT_RESET_VALUE);
1117	if (ret)
1118		return ret;
1119
1120	aw_dev->fade_in_time = AW88081_500_US;
1121	aw_dev->fade_out_time = AW88081_500_US;
1122	aw_dev->prof_cur = AW88081_INIT_PROFILE;
1123	aw_dev->prof_index = AW88081_INIT_PROFILE;
1124
1125	ret = aw88081_dev_fw_update(aw88081);
1126	if (ret) {
1127		dev_err(aw_dev->dev, "fw update failed ret = %d\n", ret);
1128		return ret;
1129	}
1130
1131	aw_dev->status = AW88081_DEV_PW_ON;
1132	aw88081_stop(aw88081);
1133
1134	return 0;
1135}
1136
1137static int aw88081_request_firmware_file(struct aw88081 *aw88081)
1138{
1139	const struct firmware *cont = NULL;
1140	int ret;
1141
1142	aw88081->aw_pa->fw_status = AW88081_DEV_FW_FAILED;
1143
1144	ret = request_firmware(&cont, AW88081_ACF_FILE, aw88081->aw_pa->dev);
1145	if (ret)
1146		return ret;
1147
1148	dev_dbg(aw88081->aw_pa->dev, "loaded %s - size: %zu\n",
1149			AW88081_ACF_FILE, cont ? cont->size : 0);
1150
1151	aw88081->aw_cfg = devm_kzalloc(aw88081->aw_pa->dev, cont->size + sizeof(int), GFP_KERNEL);
1152	if (!aw88081->aw_cfg) {
1153		release_firmware(cont);
1154		return -ENOMEM;
1155	}
1156	aw88081->aw_cfg->len = (int)cont->size;
1157	memcpy(aw88081->aw_cfg->data, cont->data, cont->size);
1158	release_firmware(cont);
1159
1160	ret = aw88395_dev_load_acf_check(aw88081->aw_pa, aw88081->aw_cfg);
1161	if (ret)
1162		return ret;
1163
1164	mutex_lock(&aw88081->lock);
1165	ret = aw88081_dev_init(aw88081, aw88081->aw_cfg);
1166	mutex_unlock(&aw88081->lock);
1167
1168	return ret;
1169}
1170
1171static int aw88081_playback_event(struct snd_soc_dapm_widget *w,
1172				struct snd_kcontrol *k, int event)
1173{
1174	struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
1175	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(component);
1176
1177	mutex_lock(&aw88081->lock);
1178	switch (event) {
1179	case SND_SOC_DAPM_PRE_PMU:
1180		aw88081_start(aw88081, AW88081_ASYNC_START);
1181		break;
1182	case SND_SOC_DAPM_POST_PMD:
1183		aw88081_stop(aw88081);
1184		break;
1185	default:
1186		break;
1187	}
1188	mutex_unlock(&aw88081->lock);
1189
1190	return 0;
1191}
1192
1193static const struct snd_soc_dapm_widget aw88081_dapm_widgets[] = {
1194	 /* playback */
1195	SND_SOC_DAPM_AIF_IN_E("AIF_RX", "Speaker_Playback", 0, SND_SOC_NOPM, 0, 0,
1196					aw88081_playback_event,
1197					SND_SOC_DAPM_PRE_PMU | SND_SOC_DAPM_POST_PMD),
1198	SND_SOC_DAPM_OUTPUT("DAC Output"),
1199
1200	/* capture */
1201	SND_SOC_DAPM_AIF_OUT("AIF_TX", "Speaker_Capture", 0, SND_SOC_NOPM, 0, 0),
1202	SND_SOC_DAPM_INPUT("ADC Input"),
1203};
1204
1205static const struct snd_soc_dapm_route aw88081_audio_map[] = {
1206	{"DAC Output", NULL, "AIF_RX"},
1207	{"AIF_TX", NULL, "ADC Input"},
1208};
1209
1210static int aw88081_codec_probe(struct snd_soc_component *component)
1211{
1212	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(component);
1213	int ret;
1214
1215	INIT_DELAYED_WORK(&aw88081->start_work, aw88081_startup_work);
1216
1217	ret = aw88081_request_firmware_file(aw88081);
1218	if (ret)
1219		dev_err(aw88081->aw_pa->dev, "%s: request firmware failed\n", __func__);
1220
1221	return ret;
1222}
1223
1224static void aw88081_codec_remove(struct snd_soc_component *aw_codec)
1225{
1226	struct aw88081 *aw88081 = snd_soc_component_get_drvdata(aw_codec);
1227
1228	cancel_delayed_work_sync(&aw88081->start_work);
1229}
1230
1231static const struct snd_soc_component_driver soc_codec_dev_aw88081 = {
1232	.probe = aw88081_codec_probe,
1233	.remove = aw88081_codec_remove,
1234	.dapm_widgets = aw88081_dapm_widgets,
1235	.num_dapm_widgets = ARRAY_SIZE(aw88081_dapm_widgets),
1236	.dapm_routes = aw88081_audio_map,
1237	.num_dapm_routes = ARRAY_SIZE(aw88081_audio_map),
1238	.controls = aw88081_controls,
1239	.num_controls = ARRAY_SIZE(aw88081_controls),
1240};
1241
1242static const struct i2c_device_id aw88081_i2c_id[] = {
1243	{ AW88081_I2C_NAME, AW88081},
1244	{ AW88083_I2C_NAME, AW88083},
1245	{ }
1246};
1247MODULE_DEVICE_TABLE(i2c, aw88081_i2c_id);
1248
1249static int aw88081_i2c_probe(struct i2c_client *i2c)
1250{
1251	const struct regmap_config *regmap_config;
1252	const struct i2c_device_id *id;
1253	struct aw88081 *aw88081;
1254	int ret;
1255
1256	ret = i2c_check_functionality(i2c->adapter, I2C_FUNC_I2C);
1257	if (!ret)
1258		return dev_err_probe(&i2c->dev, -ENXIO, "check_functionality failed");
1259
1260	aw88081 = devm_kzalloc(&i2c->dev, sizeof(*aw88081), GFP_KERNEL);
1261	if (!aw88081)
1262		return -ENOMEM;
1263
1264	id = i2c_match_id(aw88081_i2c_id, i2c);
1265	aw88081->devtype = id->driver_data;
1266
1267	mutex_init(&aw88081->lock);
1268
1269	i2c_set_clientdata(i2c, aw88081);
1270
1271	switch (aw88081->devtype) {
1272	case AW88081:
1273		regmap_config = &aw88081_regmap_config;
1274		break;
1275	case AW88083:
1276		regmap_config = &aw88083_regmap_config;
1277		break;
1278	default:
1279		return -EINVAL;
1280	}
1281
1282	aw88081->regmap = devm_regmap_init_i2c(i2c, regmap_config);
1283	if (IS_ERR(aw88081->regmap))
1284		return dev_err_probe(&i2c->dev, PTR_ERR(aw88081->regmap),
1285						"failed to init regmap\n");
1286
1287	/* aw pa init */
1288	ret = aw88081_init(aw88081, i2c, aw88081->regmap);
1289	if (ret)
1290		return ret;
1291
1292	return devm_snd_soc_register_component(&i2c->dev,
1293			&soc_codec_dev_aw88081,
1294			aw88081_dai, ARRAY_SIZE(aw88081_dai));
1295}
1296
1297#if defined(CONFIG_OF)
1298static const struct of_device_id aw88081_of_match[] = {
1299	{ .compatible = "awinic,aw88081" },
1300	{ .compatible = "awinic,aw88083" },
1301	{ }
1302};
1303MODULE_DEVICE_TABLE(of, aw88081_of_match);
1304#endif
1305
1306static struct i2c_driver aw88081_i2c_driver = {
1307	.driver = {
1308		.name = AW88081_I2C_NAME,
1309		.of_match_table = of_match_ptr(aw88081_of_match),
1310	},
1311	.probe = aw88081_i2c_probe,
1312	.id_table = aw88081_i2c_id,
1313};
1314module_i2c_driver(aw88081_i2c_driver);
1315
1316MODULE_DESCRIPTION("ASoC AW88081 Smart PA Driver");
1317MODULE_LICENSE("GPL v2");