1 // SPDX-License-Identifier: GPL-2.0-only 2 // 3 // aw88395_device.c -- AW88395 function for ALSA Audio Driver 4 // 5 // Copyright (c) 2022-2023 AWINIC Technology CO., LTD 6 // 7 // Author: Bruce zhao <zhaolei@awinic.com> 8 // Author: Ben Yi <yijiangtao@awinic.com> 9 // 10 11 #include <linux/cleanup.h> 12 #include <linux/crc32.h> 13 #include <linux/i2c.h> 14 #include <linux/minmax.h> 15 #include <linux/regmap.h> 16 #include "aw88395_device.h" 17 #include "aw88395_reg.h" 18 19 static int aw_dev_dsp_write_16bit(struct aw_device *aw_dev, 20 unsigned short dsp_addr, unsigned int dsp_data) 21 { 22 int ret; 23 24 ret = regmap_write(aw_dev->regmap, AW88395_DSPMADD_REG, dsp_addr); 25 if (ret) { 26 dev_err(aw_dev->dev, "%s write addr error, ret=%d", __func__, ret); 27 return ret; 28 } 29 30 ret = regmap_write(aw_dev->regmap, AW88395_DSPMDAT_REG, (u16)dsp_data); 31 if (ret) { 32 dev_err(aw_dev->dev, "%s write data error, ret=%d", __func__, ret); 33 return ret; 34 } 35 36 return 0; 37 } 38 39 static int aw_dev_dsp_write_32bit(struct aw_device *aw_dev, 40 unsigned short dsp_addr, unsigned int dsp_data) 41 { 42 u16 temp_data; 43 int ret; 44 45 ret = regmap_write(aw_dev->regmap, AW88395_DSPMADD_REG, dsp_addr); 46 if (ret) { 47 dev_err(aw_dev->dev, "%s write addr error, ret=%d", __func__, ret); 48 return ret; 49 } 50 51 temp_data = dsp_data & AW88395_DSP_16_DATA_MASK; 52 ret = regmap_write(aw_dev->regmap, AW88395_DSPMDAT_REG, (u16)temp_data); 53 if (ret) { 54 dev_err(aw_dev->dev, "%s write datal error, ret=%d", __func__, ret); 55 return ret; 56 } 57 58 temp_data = dsp_data >> 16; 59 ret = regmap_write(aw_dev->regmap, AW88395_DSPMDAT_REG, (u16)temp_data); 60 if (ret) { 61 dev_err(aw_dev->dev, "%s write datah error, ret=%d", __func__, ret); 62 return ret; 63 } 64 65 return 0; 66 } 67 68 int aw_dev_dsp_write(struct aw_device *aw_dev, 69 unsigned short dsp_addr, unsigned int dsp_data, unsigned char data_type) 70 { 71 u32 reg_value; 72 int ret; 73 74 guard(mutex)(&aw_dev->dsp_lock); 75 switch (data_type) { 76 case AW_DSP_16_DATA: 77 ret = aw_dev_dsp_write_16bit(aw_dev, dsp_addr, dsp_data); 78 if (ret) 79 dev_err(aw_dev->dev, "write dsp_addr[0x%x] 16-bit dsp_data[0x%x] failed", 80 (u32)dsp_addr, dsp_data); 81 break; 82 case AW_DSP_32_DATA: 83 ret = aw_dev_dsp_write_32bit(aw_dev, dsp_addr, dsp_data); 84 if (ret) 85 dev_err(aw_dev->dev, "write dsp_addr[0x%x] 32-bit dsp_data[0x%x] failed", 86 (u32)dsp_addr, dsp_data); 87 break; 88 default: 89 dev_err(aw_dev->dev, "data type[%d] unsupported", data_type); 90 ret = -EINVAL; 91 break; 92 } 93 94 /* clear dsp chip select state*/ 95 if (regmap_read(aw_dev->regmap, AW88395_ID_REG, ®_value)) 96 dev_err(aw_dev->dev, "%s fail to clear chip state. Err=%d\n", __func__, ret); 97 98 return ret; 99 } 100 EXPORT_SYMBOL_GPL(aw_dev_dsp_write); 101 102 static int aw_dev_dsp_read_16bit(struct aw_device *aw_dev, 103 unsigned short dsp_addr, unsigned int *dsp_data) 104 { 105 unsigned int temp_data; 106 int ret; 107 108 ret = regmap_write(aw_dev->regmap, AW88395_DSPMADD_REG, dsp_addr); 109 if (ret) { 110 dev_err(aw_dev->dev, "%s write error, ret=%d", __func__, ret); 111 return ret; 112 } 113 114 ret = regmap_read(aw_dev->regmap, AW88395_DSPMDAT_REG, &temp_data); 115 if (ret) { 116 dev_err(aw_dev->dev, "%s read error, ret=%d", __func__, ret); 117 return ret; 118 } 119 *dsp_data = temp_data; 120 121 return 0; 122 } 123 124 static int aw_dev_dsp_read_32bit(struct aw_device *aw_dev, 125 unsigned short dsp_addr, unsigned int *dsp_data) 126 { 127 unsigned int temp_data; 128 int ret; 129 130 ret = regmap_write(aw_dev->regmap, AW88395_DSPMADD_REG, dsp_addr); 131 if (ret) { 132 dev_err(aw_dev->dev, "%s write error, ret=%d", __func__, ret); 133 return ret; 134 } 135 136 ret = regmap_read(aw_dev->regmap, AW88395_DSPMDAT_REG, &temp_data); 137 if (ret) { 138 dev_err(aw_dev->dev, "%s read error, ret=%d", __func__, ret); 139 return ret; 140 } 141 *dsp_data = temp_data; 142 143 ret = regmap_read(aw_dev->regmap, AW88395_DSPMDAT_REG, &temp_data); 144 if (ret) { 145 dev_err(aw_dev->dev, "%s read error, ret=%d", __func__, ret); 146 return ret; 147 } 148 *dsp_data |= (temp_data << 16); 149 150 return 0; 151 } 152 153 int aw_dev_dsp_read(struct aw_device *aw_dev, 154 unsigned short dsp_addr, unsigned int *dsp_data, unsigned char data_type) 155 { 156 u32 reg_value; 157 int ret; 158 159 guard(mutex)(&aw_dev->dsp_lock); 160 switch (data_type) { 161 case AW_DSP_16_DATA: 162 ret = aw_dev_dsp_read_16bit(aw_dev, dsp_addr, dsp_data); 163 if (ret) 164 dev_err(aw_dev->dev, "read dsp_addr[0x%x] 16-bit dsp_data[0x%x] failed", 165 (u32)dsp_addr, *dsp_data); 166 break; 167 case AW_DSP_32_DATA: 168 ret = aw_dev_dsp_read_32bit(aw_dev, dsp_addr, dsp_data); 169 if (ret) 170 dev_err(aw_dev->dev, "read dsp_addr[0x%x] 32r-bit dsp_data[0x%x] failed", 171 (u32)dsp_addr, *dsp_data); 172 break; 173 default: 174 dev_err(aw_dev->dev, "data type[%d] unsupported", data_type); 175 ret = -EINVAL; 176 break; 177 } 178 179 /* clear dsp chip select state*/ 180 if (regmap_read(aw_dev->regmap, AW88395_ID_REG, ®_value)) 181 dev_err(aw_dev->dev, "%s fail to clear chip state. Err=%d\n", __func__, ret); 182 183 return ret; 184 } 185 EXPORT_SYMBOL_GPL(aw_dev_dsp_read); 186 187 static int aw_dev_read_chipid(struct aw_device *aw_dev, u16 *chip_id) 188 { 189 int reg_val; 190 int ret; 191 192 ret = regmap_read(aw_dev->regmap, AW88395_CHIP_ID_REG, ®_val); 193 if (ret) { 194 dev_err(aw_dev->dev, "%s read chipid error. ret = %d", __func__, ret); 195 return ret; 196 } 197 198 dev_info(aw_dev->dev, "chip id = %x\n", reg_val); 199 *chip_id = reg_val; 200 201 return 0; 202 } 203 204 static unsigned int reg_val_to_db(unsigned int value) 205 { 206 return (((value >> AW88395_VOL_6DB_START) * AW88395_VOLUME_STEP_DB) + 207 ((value & 0x3f) % AW88395_VOLUME_STEP_DB)); 208 } 209 210 static unsigned short db_to_reg_val(unsigned short value) 211 { 212 return (((value / AW88395_VOLUME_STEP_DB) << AW88395_VOL_6DB_START) + 213 (value % AW88395_VOLUME_STEP_DB)); 214 } 215 216 static int aw_dev_dsp_fw_check(struct aw_device *aw_dev) 217 { 218 struct aw_sec_data_desc *dsp_fw_desc; 219 struct aw_prof_desc *set_prof_desc; 220 u16 base_addr = AW88395_DSP_FW_ADDR; 221 u16 addr = base_addr; 222 u32 dsp_val; 223 u16 bin_val; 224 int ret, i; 225 226 ret = aw88395_dev_get_prof_data(aw_dev, aw_dev->prof_cur, &set_prof_desc); 227 if (ret) 228 return ret; 229 230 /* update reg */ 231 dsp_fw_desc = &set_prof_desc->sec_desc[AW88395_DATA_TYPE_DSP_FW]; 232 233 for (i = 0; i < AW88395_FW_CHECK_PART; i++) { 234 ret = aw_dev_dsp_read(aw_dev, addr, &dsp_val, AW_DSP_16_DATA); 235 if (ret) { 236 dev_err(aw_dev->dev, "dsp read failed"); 237 return ret; 238 } 239 240 bin_val = be16_to_cpup((void *)&dsp_fw_desc->data[2 * (addr - base_addr)]); 241 242 if (dsp_val != bin_val) { 243 dev_err(aw_dev->dev, "fw check failed, addr[0x%x], read[0x%x] != bindata[0x%x]", 244 addr, dsp_val, bin_val); 245 return -EINVAL; 246 } 247 248 addr += (dsp_fw_desc->len / 2) / AW88395_FW_CHECK_PART; 249 if ((addr - base_addr) > dsp_fw_desc->len) { 250 dev_err(aw_dev->dev, "fw check failed, addr[0x%x] too large", addr); 251 return -EINVAL; 252 } 253 } 254 255 return 0; 256 } 257 258 static int aw_dev_set_volume(struct aw_device *aw_dev, unsigned int value) 259 { 260 struct aw_volume_desc *vol_desc = &aw_dev->volume_desc; 261 unsigned int reg_value; 262 u16 real_value, volume; 263 int ret; 264 265 volume = min((value + vol_desc->init_volume), (unsigned int)AW88395_MUTE_VOL); 266 real_value = db_to_reg_val(volume); 267 268 /* cal real value */ 269 ret = regmap_read(aw_dev->regmap, AW88395_SYSCTRL2_REG, ®_value); 270 if (ret) 271 return ret; 272 273 dev_dbg(aw_dev->dev, "value 0x%x , reg:0x%x", value, real_value); 274 275 /* [15 : 6] volume */ 276 real_value = (real_value << AW88395_VOL_START_BIT) | (reg_value & AW88395_VOL_MASK); 277 278 /* write value */ 279 ret = regmap_write(aw_dev->regmap, AW88395_SYSCTRL2_REG, real_value); 280 281 return ret; 282 } 283 284 void aw88395_dev_set_volume(struct aw_device *aw_dev, unsigned short set_vol) 285 { 286 int ret; 287 288 ret = aw_dev_set_volume(aw_dev, set_vol); 289 if (ret) 290 dev_dbg(aw_dev->dev, "set volume failed"); 291 } 292 EXPORT_SYMBOL_GPL(aw88395_dev_set_volume); 293 294 static void aw_dev_fade_in(struct aw_device *aw_dev) 295 { 296 struct aw_volume_desc *desc = &aw_dev->volume_desc; 297 u16 fade_in_vol = desc->ctl_volume; 298 int fade_step = aw_dev->fade_step; 299 int i; 300 301 if (fade_step == 0 || aw_dev->fade_in_time == 0) { 302 aw_dev_set_volume(aw_dev, fade_in_vol); 303 return; 304 } 305 306 for (i = AW88395_MUTE_VOL; i >= fade_in_vol; i -= fade_step) { 307 aw_dev_set_volume(aw_dev, i); 308 usleep_range(aw_dev->fade_in_time, aw_dev->fade_in_time + 10); 309 } 310 311 if (i != fade_in_vol) 312 aw_dev_set_volume(aw_dev, fade_in_vol); 313 } 314 315 static void aw_dev_fade_out(struct aw_device *aw_dev) 316 { 317 struct aw_volume_desc *desc = &aw_dev->volume_desc; 318 int fade_step = aw_dev->fade_step; 319 int i; 320 321 if (fade_step == 0 || aw_dev->fade_out_time == 0) { 322 aw_dev_set_volume(aw_dev, AW88395_MUTE_VOL); 323 return; 324 } 325 326 for (i = desc->ctl_volume; i <= AW88395_MUTE_VOL; i += fade_step) { 327 aw_dev_set_volume(aw_dev, i); 328 usleep_range(aw_dev->fade_out_time, aw_dev->fade_out_time + 10); 329 } 330 331 if (i != AW88395_MUTE_VOL) { 332 aw_dev_set_volume(aw_dev, AW88395_MUTE_VOL); 333 usleep_range(aw_dev->fade_out_time, aw_dev->fade_out_time + 10); 334 } 335 } 336 337 static int aw_dev_modify_dsp_cfg(struct aw_device *aw_dev, 338 unsigned int addr, unsigned int dsp_data, unsigned char data_type) 339 { 340 struct aw_sec_data_desc *crc_dsp_cfg = &aw_dev->crc_dsp_cfg; 341 unsigned int addr_offset; 342 __le16 data1; 343 __le32 data2; 344 345 dev_dbg(aw_dev->dev, "addr:0x%x, dsp_data:0x%x", addr, dsp_data); 346 347 addr_offset = (addr - AW88395_DSP_CFG_ADDR) * 2; 348 if (addr_offset > crc_dsp_cfg->len) { 349 dev_err(aw_dev->dev, "addr_offset[%d] > crc_dsp_cfg->len[%d]", 350 addr_offset, crc_dsp_cfg->len); 351 return -EINVAL; 352 } 353 switch (data_type) { 354 case AW_DSP_16_DATA: 355 data1 = cpu_to_le16((u16)dsp_data); 356 memcpy(crc_dsp_cfg->data + addr_offset, (u8 *)&data1, 2); 357 break; 358 case AW_DSP_32_DATA: 359 data2 = cpu_to_le32(dsp_data); 360 memcpy(crc_dsp_cfg->data + addr_offset, (u8 *)&data2, 4); 361 break; 362 default: 363 dev_err(aw_dev->dev, "data type[%d] unsupported", data_type); 364 return -EINVAL; 365 } 366 367 return 0; 368 } 369 370 static int aw_dev_dsp_set_cali_re(struct aw_device *aw_dev) 371 { 372 u32 cali_re; 373 int ret; 374 375 cali_re = AW88395_SHOW_RE_TO_DSP_RE((aw_dev->cali_desc.cali_re + 376 aw_dev->cali_desc.ra), AW88395_DSP_RE_SHIFT); 377 378 /* set cali re to device */ 379 ret = aw_dev_dsp_write(aw_dev, 380 AW88395_DSP_REG_CFG_ADPZ_RE, cali_re, AW_DSP_32_DATA); 381 if (ret) { 382 dev_err(aw_dev->dev, "set cali re error"); 383 return ret; 384 } 385 386 ret = aw_dev_modify_dsp_cfg(aw_dev, AW88395_DSP_REG_CFG_ADPZ_RE, 387 cali_re, AW_DSP_32_DATA); 388 if (ret) 389 dev_err(aw_dev->dev, "modify dsp cfg failed"); 390 391 return ret; 392 } 393 394 static void aw_dev_i2s_tx_enable(struct aw_device *aw_dev, bool flag) 395 { 396 int ret; 397 398 if (flag) { 399 ret = regmap_update_bits(aw_dev->regmap, AW88395_I2SCFG1_REG, 400 ~AW88395_I2STXEN_MASK, AW88395_I2STXEN_ENABLE_VALUE); 401 } else { 402 ret = regmap_update_bits(aw_dev->regmap, AW88395_I2SCFG1_REG, 403 ~AW88395_I2STXEN_MASK, AW88395_I2STXEN_DISABLE_VALUE); 404 } 405 406 if (ret) 407 dev_dbg(aw_dev->dev, "%s failed", __func__); 408 } 409 410 static int aw_dev_dsp_set_crc32(struct aw_device *aw_dev) 411 { 412 struct aw_sec_data_desc *crc_dsp_cfg = &aw_dev->crc_dsp_cfg; 413 u32 crc_value, crc_data_len; 414 415 /* get crc data len */ 416 crc_data_len = (AW88395_DSP_REG_CRC_ADDR - AW88395_DSP_CFG_ADDR) * 2; 417 if (crc_data_len > crc_dsp_cfg->len) { 418 dev_err(aw_dev->dev, "crc data len :%d > cfg_data len:%d", 419 crc_data_len, crc_dsp_cfg->len); 420 return -EINVAL; 421 } 422 423 if (crc_data_len & 0x11) { 424 dev_err(aw_dev->dev, "The crc data len :%d unsupport", crc_data_len); 425 return -EINVAL; 426 } 427 428 crc_value = crc32c(0xFFFFFFFF, crc_dsp_cfg->data, crc_data_len) ^ 0xFFFFFFFF; 429 430 return aw_dev_dsp_write(aw_dev, AW88395_DSP_REG_CRC_ADDR, crc_value, 431 AW_DSP_32_DATA); 432 } 433 434 static void aw_dev_dsp_check_crc_enable(struct aw_device *aw_dev, bool flag) 435 { 436 int ret; 437 438 if (flag) { 439 ret = regmap_update_bits(aw_dev->regmap, AW88395_HAGCCFG7_REG, 440 ~AW88395_AGC_DSP_CTL_MASK, AW88395_AGC_DSP_CTL_ENABLE_VALUE); 441 } else { 442 ret = regmap_update_bits(aw_dev->regmap, AW88395_HAGCCFG7_REG, 443 ~AW88395_AGC_DSP_CTL_MASK, AW88395_AGC_DSP_CTL_DISABLE_VALUE); 444 } 445 if (ret) 446 dev_dbg(aw_dev->dev, "%s failed", __func__); 447 } 448 449 static int aw_dev_dsp_check_st(struct aw_device *aw_dev) 450 { 451 unsigned int reg_val; 452 int ret; 453 int i; 454 455 for (i = 0; i < AW88395_DSP_ST_CHECK_MAX; i++) { 456 ret = regmap_read(aw_dev->regmap, AW88395_SYSST_REG, ®_val); 457 if (ret) { 458 dev_err(aw_dev->dev, "read reg0x%x failed", AW88395_SYSST_REG); 459 continue; 460 } 461 462 if ((reg_val & (~AW88395_DSPS_MASK)) != AW88395_DSPS_NORMAL_VALUE) { 463 dev_err(aw_dev->dev, "check dsp st fail,reg_val:0x%04x", reg_val); 464 ret = -EPERM; 465 continue; 466 } else { 467 dev_dbg(aw_dev->dev, "dsp st check ok, reg_val:0x%04x", reg_val); 468 return 0; 469 } 470 } 471 472 return ret; 473 } 474 475 static void aw_dev_dsp_enable(struct aw_device *aw_dev, bool is_enable) 476 { 477 int ret; 478 479 if (is_enable) { 480 ret = regmap_update_bits(aw_dev->regmap, AW88395_SYSCTRL_REG, 481 ~AW88395_DSPBY_MASK, AW88395_DSPBY_WORKING_VALUE); 482 if (ret) 483 dev_dbg(aw_dev->dev, "enable dsp failed"); 484 } else { 485 ret = regmap_update_bits(aw_dev->regmap, AW88395_SYSCTRL_REG, 486 ~AW88395_DSPBY_MASK, AW88395_DSPBY_BYPASS_VALUE); 487 if (ret) 488 dev_dbg(aw_dev->dev, "disable dsp failed"); 489 } 490 } 491 492 static int aw_dev_dsp_check_crc32(struct aw_device *aw_dev) 493 { 494 int ret; 495 496 if (aw_dev->dsp_cfg == AW88395_DEV_DSP_BYPASS) { 497 dev_info(aw_dev->dev, "dsp bypass"); 498 return 0; 499 } 500 501 ret = aw_dev_dsp_set_crc32(aw_dev); 502 if (ret) { 503 dev_err(aw_dev->dev, "set dsp crc32 failed"); 504 return ret; 505 } 506 507 aw_dev_dsp_check_crc_enable(aw_dev, true); 508 509 /* dsp enable */ 510 aw_dev_dsp_enable(aw_dev, true); 511 usleep_range(AW88395_5000_US, AW88395_5000_US + 100); 512 513 ret = aw_dev_dsp_check_st(aw_dev); 514 if (ret) { 515 dev_err(aw_dev->dev, "check crc32 fail"); 516 } else { 517 aw_dev_dsp_check_crc_enable(aw_dev, false); 518 aw_dev->dsp_crc_st = AW88395_DSP_CRC_OK; 519 } 520 521 return ret; 522 } 523 524 static void aw_dev_pwd(struct aw_device *aw_dev, bool pwd) 525 { 526 int ret; 527 528 if (pwd) { 529 ret = regmap_update_bits(aw_dev->regmap, AW88395_SYSCTRL_REG, 530 ~AW88395_PWDN_MASK, AW88395_PWDN_POWER_DOWN_VALUE); 531 } else { 532 ret = regmap_update_bits(aw_dev->regmap, AW88395_SYSCTRL_REG, 533 ~AW88395_PWDN_MASK, AW88395_PWDN_WORKING_VALUE); 534 } 535 if (ret) 536 dev_dbg(aw_dev->dev, "%s failed", __func__); 537 } 538 539 static void aw_dev_amppd(struct aw_device *aw_dev, bool amppd) 540 { 541 int ret; 542 543 if (amppd) { 544 ret = regmap_update_bits(aw_dev->regmap, AW88395_SYSCTRL_REG, 545 ~AW88395_AMPPD_MASK, AW88395_AMPPD_POWER_DOWN_VALUE); 546 } else { 547 ret = regmap_update_bits(aw_dev->regmap, AW88395_SYSCTRL_REG, 548 ~AW88395_AMPPD_MASK, AW88395_AMPPD_WORKING_VALUE); 549 } 550 if (ret) 551 dev_dbg(aw_dev->dev, "%s failed", __func__); 552 } 553 554 void aw88395_dev_mute(struct aw_device *aw_dev, bool is_mute) 555 { 556 int ret; 557 558 if (is_mute) { 559 aw_dev_fade_out(aw_dev); 560 ret = regmap_update_bits(aw_dev->regmap, AW88395_SYSCTRL_REG, 561 ~AW88395_HMUTE_MASK, AW88395_HMUTE_ENABLE_VALUE); 562 } else { 563 ret = regmap_update_bits(aw_dev->regmap, AW88395_SYSCTRL_REG, 564 ~AW88395_HMUTE_MASK, AW88395_HMUTE_DISABLE_VALUE); 565 aw_dev_fade_in(aw_dev); 566 } 567 568 if (ret) 569 dev_dbg(aw_dev->dev, "%s failed", __func__); 570 } 571 EXPORT_SYMBOL_GPL(aw88395_dev_mute); 572 573 static int aw_dev_get_icalk(struct aw_device *aw_dev, int16_t *icalk) 574 { 575 unsigned int reg_val; 576 u16 reg_icalk; 577 int ret; 578 579 ret = regmap_read(aw_dev->regmap, AW88395_EFRM2_REG, ®_val); 580 if (ret) 581 return ret; 582 583 reg_icalk = reg_val & (~AW88395_EF_ISN_GESLP_MASK); 584 585 if (reg_icalk & (~AW88395_EF_ISN_GESLP_SIGN_MASK)) 586 reg_icalk = reg_icalk | AW88395_EF_ISN_GESLP_SIGN_NEG; 587 588 *icalk = (int16_t)reg_icalk; 589 590 return ret; 591 } 592 593 static int aw_dev_get_vcalk(struct aw_device *aw_dev, int16_t *vcalk) 594 { 595 unsigned int reg_val; 596 u16 reg_vcalk; 597 int ret; 598 599 ret = regmap_read(aw_dev->regmap, AW88395_EFRH_REG, ®_val); 600 if (ret) 601 return ret; 602 603 reg_val = reg_val >> AW88395_EF_VSENSE_GAIN_SHIFT; 604 605 reg_vcalk = (u16)reg_val & (~AW88395_EF_VSN_GESLP_MASK); 606 607 if (reg_vcalk & (~AW88395_EF_VSN_GESLP_SIGN_MASK)) 608 reg_vcalk = reg_vcalk | AW88395_EF_VSN_GESLP_SIGN_NEG; 609 610 *vcalk = (int16_t)reg_vcalk; 611 612 return ret; 613 } 614 615 static int aw_dev_get_vcalk_dac(struct aw_device *aw_dev, int16_t *vcalk) 616 { 617 unsigned int reg_val; 618 u16 reg_vcalk; 619 int ret; 620 621 ret = regmap_read(aw_dev->regmap, AW88395_EFRM2_REG, ®_val); 622 if (ret) 623 return ret; 624 625 reg_vcalk = reg_val >> AW88395_EF_DAC_GESLP_SHIFT; 626 627 if (reg_vcalk & AW88395_EF_DAC_GESLP_SIGN_MASK) 628 reg_vcalk = reg_vcalk | AW88395_EF_DAC_GESLP_SIGN_NEG; 629 630 *vcalk = (int16_t)reg_vcalk; 631 632 return ret; 633 } 634 635 static int aw_dev_vsense_select(struct aw_device *aw_dev, int *vsense_select) 636 { 637 unsigned int vsense_reg_val; 638 int ret; 639 640 ret = regmap_read(aw_dev->regmap, AW88395_I2SCFG3_REG, &vsense_reg_val); 641 if (ret) { 642 dev_err(aw_dev->dev, "read vsense_reg_val failed"); 643 return ret; 644 } 645 dev_dbg(aw_dev->dev, "vsense_reg = 0x%x", vsense_reg_val); 646 647 if (vsense_reg_val & (~AW88395_VDSEL_MASK)) { 648 *vsense_select = AW88395_DEV_VDSEL_VSENSE; 649 dev_dbg(aw_dev->dev, "vsense outside"); 650 } else { 651 *vsense_select = AW88395_DEV_VDSEL_DAC; 652 dev_dbg(aw_dev->dev, "vsense inside"); 653 } 654 655 return 0; 656 } 657 658 static int aw_dev_set_vcalb(struct aw_device *aw_dev) 659 { 660 int16_t icalk_val, vcalk_val; 661 int icalk, vsense_select; 662 u32 vcalb_adj, reg_val; 663 int vcalb, vcalk; 664 int ret; 665 666 ret = aw_dev_dsp_read(aw_dev, AW88395_DSP_REG_VCALB, &vcalb_adj, AW_DSP_16_DATA); 667 if (ret) { 668 dev_err(aw_dev->dev, "read vcalb_adj failed"); 669 return ret; 670 } 671 672 ret = aw_dev_vsense_select(aw_dev, &vsense_select); 673 if (ret) 674 return ret; 675 dev_dbg(aw_dev->dev, "vsense_select = %d", vsense_select); 676 677 ret = aw_dev_get_icalk(aw_dev, &icalk_val); 678 if (ret) 679 return ret; 680 icalk = AW88395_CABL_BASE_VALUE + AW88395_ICABLK_FACTOR * icalk_val; 681 682 switch (vsense_select) { 683 case AW88395_DEV_VDSEL_VSENSE: 684 ret = aw_dev_get_vcalk(aw_dev, &vcalk_val); 685 if (ret) 686 return ret; 687 vcalk = AW88395_CABL_BASE_VALUE + AW88395_VCABLK_FACTOR * vcalk_val; 688 vcalb = AW88395_VCAL_FACTOR * AW88395_VSCAL_FACTOR / 689 AW88395_ISCAL_FACTOR * icalk / vcalk * vcalb_adj; 690 691 dev_dbg(aw_dev->dev, "vcalk_factor=%d, vscal_factor=%d, icalk=%d, vcalk=%d", 692 AW88395_VCABLK_FACTOR, AW88395_VSCAL_FACTOR, icalk, vcalk); 693 break; 694 case AW88395_DEV_VDSEL_DAC: 695 ret = aw_dev_get_vcalk_dac(aw_dev, &vcalk_val); 696 if (ret) 697 return ret; 698 vcalk = AW88395_CABL_BASE_VALUE + AW88395_VCABLK_FACTOR_DAC * vcalk_val; 699 vcalb = AW88395_VCAL_FACTOR * AW88395_VSCAL_FACTOR_DAC / 700 AW88395_ISCAL_FACTOR * icalk / vcalk * vcalb_adj; 701 702 dev_dbg(aw_dev->dev, "vcalk_dac_factor=%d, vscal_dac_factor=%d, icalk=%d, vcalk=%d", 703 AW88395_VCABLK_FACTOR_DAC, 704 AW88395_VSCAL_FACTOR_DAC, icalk, vcalk); 705 break; 706 default: 707 dev_err(aw_dev->dev, "unsupported vsense status"); 708 return -EINVAL; 709 } 710 711 if ((vcalk == 0) || (AW88395_ISCAL_FACTOR == 0)) { 712 dev_err(aw_dev->dev, "vcalk:%d or desc->iscal_factor:%d unsupported", 713 vcalk, AW88395_ISCAL_FACTOR); 714 return -EINVAL; 715 } 716 717 vcalb = vcalb >> AW88395_VCALB_ADJ_FACTOR; 718 reg_val = (u32)vcalb; 719 720 dev_dbg(aw_dev->dev, "vcalb=%d, reg_val=0x%x, vcalb_adj =0x%x", 721 vcalb, reg_val, vcalb_adj); 722 723 ret = aw_dev_dsp_write(aw_dev, AW88395_DSP_REG_VCALB, reg_val, AW_DSP_16_DATA); 724 if (ret) { 725 dev_err(aw_dev->dev, "write vcalb failed"); 726 return ret; 727 } 728 729 ret = aw_dev_modify_dsp_cfg(aw_dev, AW88395_DSP_REG_VCALB, 730 (u32)reg_val, AW_DSP_16_DATA); 731 if (ret) 732 dev_err(aw_dev->dev, "modify dsp cfg failed"); 733 734 return ret; 735 } 736 737 static int aw_dev_get_cali_f0_delay(struct aw_device *aw_dev) 738 { 739 struct aw_cali_delay_desc *desc = &aw_dev->cali_delay_desc; 740 u32 cali_delay; 741 int ret; 742 743 ret = aw_dev_dsp_read(aw_dev, 744 AW88395_DSP_CALI_F0_DELAY, &cali_delay, AW_DSP_16_DATA); 745 if (ret) 746 dev_err(aw_dev->dev, "read cali delay failed, ret=%d", ret); 747 else 748 desc->delay = AW88395_CALI_DELAY_CACL(cali_delay); 749 750 dev_dbg(aw_dev->dev, "read cali delay: %d ms", desc->delay); 751 752 return ret; 753 } 754 755 static void aw_dev_get_int_status(struct aw_device *aw_dev, unsigned short *int_status) 756 { 757 unsigned int reg_val; 758 int ret; 759 760 ret = regmap_read(aw_dev->regmap, AW88395_SYSINT_REG, ®_val); 761 if (ret) 762 dev_err(aw_dev->dev, "read interrupt reg fail, ret=%d", ret); 763 else 764 *int_status = reg_val; 765 766 dev_dbg(aw_dev->dev, "read interrupt reg = 0x%04x", *int_status); 767 } 768 769 static void aw_dev_clear_int_status(struct aw_device *aw_dev) 770 { 771 u16 int_status; 772 773 /* read int status and clear */ 774 aw_dev_get_int_status(aw_dev, &int_status); 775 /* make sure int status is clear */ 776 aw_dev_get_int_status(aw_dev, &int_status); 777 if (int_status) 778 dev_info(aw_dev->dev, "int status(%d) is not cleaned.\n", int_status); 779 } 780 781 static int aw_dev_get_iis_status(struct aw_device *aw_dev) 782 { 783 unsigned int reg_val; 784 int ret; 785 786 ret = regmap_read(aw_dev->regmap, AW88395_SYSST_REG, ®_val); 787 if (ret) 788 return -EIO; 789 if ((reg_val & AW88395_BIT_PLL_CHECK) != AW88395_BIT_PLL_CHECK) { 790 dev_err(aw_dev->dev, "check pll lock fail,reg_val:0x%04x", reg_val); 791 return -EINVAL; 792 } 793 794 return 0; 795 } 796 797 static int aw_dev_check_mode1_pll(struct aw_device *aw_dev) 798 { 799 int ret, i; 800 801 for (i = 0; i < AW88395_DEV_SYSST_CHECK_MAX; i++) { 802 ret = aw_dev_get_iis_status(aw_dev); 803 if (ret < 0) { 804 dev_err(aw_dev->dev, "mode1 iis signal check error"); 805 usleep_range(AW88395_2000_US, AW88395_2000_US + 10); 806 } else { 807 return 0; 808 } 809 } 810 811 return -EPERM; 812 } 813 814 static int aw_dev_check_mode2_pll(struct aw_device *aw_dev) 815 { 816 unsigned int reg_val; 817 int ret, i; 818 819 ret = regmap_read(aw_dev->regmap, AW88395_PLLCTRL1_REG, ®_val); 820 if (ret) 821 return ret; 822 823 reg_val &= (~AW88395_CCO_MUX_MASK); 824 if (reg_val == AW88395_CCO_MUX_DIVIDED_VALUE) { 825 dev_dbg(aw_dev->dev, "CCO_MUX is already divider"); 826 return -EPERM; 827 } 828 829 /* change mode2 */ 830 ret = regmap_update_bits(aw_dev->regmap, AW88395_PLLCTRL1_REG, 831 ~AW88395_CCO_MUX_MASK, AW88395_CCO_MUX_DIVIDED_VALUE); 832 if (ret) 833 return ret; 834 835 for (i = 0; i < AW88395_DEV_SYSST_CHECK_MAX; i++) { 836 ret = aw_dev_get_iis_status(aw_dev); 837 if (ret) { 838 dev_err(aw_dev->dev, "mode2 iis signal check error"); 839 usleep_range(AW88395_2000_US, AW88395_2000_US + 10); 840 } else { 841 break; 842 } 843 } 844 845 /* change mode1 */ 846 ret = regmap_update_bits(aw_dev->regmap, AW88395_PLLCTRL1_REG, 847 ~AW88395_CCO_MUX_MASK, AW88395_CCO_MUX_BYPASS_VALUE); 848 if (ret == 0) { 849 usleep_range(AW88395_2000_US, AW88395_2000_US + 10); 850 for (i = 0; i < AW88395_DEV_SYSST_CHECK_MAX; i++) { 851 ret = aw_dev_check_mode1_pll(aw_dev); 852 if (ret < 0) { 853 dev_err(aw_dev->dev, "mode2 switch to mode1, iis signal check error"); 854 usleep_range(AW88395_2000_US, AW88395_2000_US + 10); 855 } else { 856 break; 857 } 858 } 859 } 860 861 return ret; 862 } 863 864 static int aw_dev_check_syspll(struct aw_device *aw_dev) 865 { 866 int ret; 867 868 ret = aw_dev_check_mode1_pll(aw_dev); 869 if (ret) { 870 dev_dbg(aw_dev->dev, "mode1 check iis failed try switch to mode2 check"); 871 ret = aw_dev_check_mode2_pll(aw_dev); 872 if (ret) { 873 dev_err(aw_dev->dev, "mode2 check iis failed"); 874 return ret; 875 } 876 } 877 878 return ret; 879 } 880 881 static int aw_dev_check_sysst(struct aw_device *aw_dev) 882 { 883 unsigned int check_val; 884 unsigned int reg_val; 885 int ret, i; 886 887 for (i = 0; i < AW88395_DEV_SYSST_CHECK_MAX; i++) { 888 ret = regmap_read(aw_dev->regmap, AW88395_SYSST_REG, ®_val); 889 if (ret) 890 return ret; 891 892 check_val = reg_val & (~AW88395_BIT_SYSST_CHECK_MASK) 893 & AW88395_BIT_SYSST_CHECK; 894 if (check_val != AW88395_BIT_SYSST_CHECK) { 895 dev_err(aw_dev->dev, "check sysst fail, cnt=%d, reg_val=0x%04x, check:0x%x", 896 i, reg_val, AW88395_BIT_SYSST_CHECK); 897 usleep_range(AW88395_2000_US, AW88395_2000_US + 10); 898 } else { 899 return 0; 900 } 901 } 902 903 return -EPERM; 904 } 905 906 static int aw_dev_check_sysint(struct aw_device *aw_dev) 907 { 908 u16 reg_val; 909 910 aw_dev_get_int_status(aw_dev, ®_val); 911 912 if (reg_val & AW88395_BIT_SYSINT_CHECK) { 913 dev_err(aw_dev->dev, "pa stop check fail:0x%04x", reg_val); 914 return -EINVAL; 915 } 916 917 return 0; 918 } 919 920 static void aw_dev_get_cur_mode_st(struct aw_device *aw_dev) 921 { 922 struct aw_profctrl_desc *profctrl_desc = &aw_dev->profctrl_desc; 923 unsigned int reg_val; 924 int ret; 925 926 ret = regmap_read(aw_dev->regmap, AW88395_SYSCTRL_REG, ®_val); 927 if (ret) { 928 dev_dbg(aw_dev->dev, "%s failed", __func__); 929 return; 930 } 931 if ((reg_val & (~AW88395_RCV_MODE_MASK)) == AW88395_RCV_MODE_RECEIVER_VALUE) 932 profctrl_desc->cur_mode = AW88395_RCV_MODE; 933 else 934 profctrl_desc->cur_mode = AW88395_NOT_RCV_MODE; 935 } 936 937 static void aw_dev_get_dsp_config(struct aw_device *aw_dev, unsigned char *dsp_cfg) 938 { 939 unsigned int reg_val = 0; 940 int ret; 941 942 ret = regmap_read(aw_dev->regmap, AW88395_SYSCTRL_REG, ®_val); 943 if (ret) { 944 dev_dbg(aw_dev->dev, "%s failed", __func__); 945 return; 946 } 947 if (reg_val & (~AW88395_DSPBY_MASK)) 948 *dsp_cfg = AW88395_DEV_DSP_BYPASS; 949 else 950 *dsp_cfg = AW88395_DEV_DSP_WORK; 951 } 952 953 static void aw_dev_select_memclk(struct aw_device *aw_dev, unsigned char flag) 954 { 955 int ret; 956 957 switch (flag) { 958 case AW88395_DEV_MEMCLK_PLL: 959 ret = regmap_update_bits(aw_dev->regmap, AW88395_DBGCTRL_REG, 960 ~AW88395_MEM_CLKSEL_MASK, 961 AW88395_MEM_CLKSEL_DAP_HCLK_VALUE); 962 if (ret) 963 dev_err(aw_dev->dev, "memclk select pll failed"); 964 break; 965 case AW88395_DEV_MEMCLK_OSC: 966 ret = regmap_update_bits(aw_dev->regmap, AW88395_DBGCTRL_REG, 967 ~AW88395_MEM_CLKSEL_MASK, 968 AW88395_MEM_CLKSEL_OSC_CLK_VALUE); 969 if (ret) 970 dev_err(aw_dev->dev, "memclk select OSC failed"); 971 break; 972 default: 973 dev_err(aw_dev->dev, "unknown memclk config, flag=0x%x", flag); 974 break; 975 } 976 } 977 978 static int aw_dev_get_dsp_status(struct aw_device *aw_dev) 979 { 980 unsigned int reg_val; 981 int ret; 982 983 ret = regmap_read(aw_dev->regmap, AW88395_WDT_REG, ®_val); 984 if (ret) 985 return ret; 986 if (!(reg_val & (~AW88395_WDT_CNT_MASK))) 987 ret = -EPERM; 988 989 return ret; 990 } 991 992 static int aw_dev_get_vmax(struct aw_device *aw_dev, unsigned int *vmax) 993 { 994 return aw_dev_dsp_read(aw_dev, AW88395_DSP_REG_VMAX, vmax, AW_DSP_16_DATA); 995 } 996 997 static int aw_dev_update_reg_container(struct aw_device *aw_dev, 998 unsigned char *data, unsigned int len) 999 { 1000 struct aw_volume_desc *vol_desc = &aw_dev->volume_desc; 1001 unsigned int read_val; 1002 int16_t *reg_data; 1003 int data_len; 1004 u16 read_vol; 1005 u16 reg_val; 1006 u8 reg_addr; 1007 int i, ret; 1008 1009 reg_data = (int16_t *)data; 1010 data_len = len >> 1; 1011 1012 if (data_len & 0x1) { 1013 dev_err(aw_dev->dev, "data len:%d unsupported", data_len); 1014 return -EINVAL; 1015 } 1016 1017 for (i = 0; i < data_len; i += 2) { 1018 reg_addr = reg_data[i]; 1019 reg_val = reg_data[i + 1]; 1020 1021 if (reg_addr == AW88395_SYSCTRL_REG) { 1022 ret = regmap_read(aw_dev->regmap, reg_addr, &read_val); 1023 if (ret) 1024 break; 1025 read_val &= (~AW88395_HMUTE_MASK); 1026 reg_val &= AW88395_HMUTE_MASK; 1027 reg_val |= read_val; 1028 } 1029 if (reg_addr == AW88395_HAGCCFG7_REG) 1030 reg_val &= AW88395_AGC_DSP_CTL_MASK; 1031 1032 if (reg_addr == AW88395_I2SCFG1_REG) { 1033 /* close tx */ 1034 reg_val &= AW88395_I2STXEN_MASK; 1035 reg_val |= AW88395_I2STXEN_DISABLE_VALUE; 1036 } 1037 1038 if (reg_addr == AW88395_SYSCTRL2_REG) { 1039 read_vol = (reg_val & (~AW88395_VOL_MASK)) >> 1040 AW88395_VOL_START_BIT; 1041 aw_dev->volume_desc.init_volume = 1042 reg_val_to_db(read_vol); 1043 } 1044 ret = regmap_write(aw_dev->regmap, reg_addr, reg_val); 1045 if (ret) 1046 break; 1047 1048 } 1049 1050 aw_dev_get_cur_mode_st(aw_dev); 1051 1052 if (aw_dev->prof_cur != aw_dev->prof_index) { 1053 /* clear control volume when PA change profile */ 1054 vol_desc->ctl_volume = 0; 1055 } else { 1056 /* keep control volume when PA start with sync mode */ 1057 aw_dev_set_volume(aw_dev, vol_desc->ctl_volume); 1058 } 1059 1060 aw_dev_get_dsp_config(aw_dev, &aw_dev->dsp_cfg); 1061 1062 return ret; 1063 } 1064 1065 static int aw_dev_reg_update(struct aw_device *aw_dev, 1066 unsigned char *data, unsigned int len) 1067 { 1068 int ret; 1069 1070 if (!len || !data) { 1071 dev_err(aw_dev->dev, "reg data is null or len is 0"); 1072 return -EINVAL; 1073 } 1074 1075 ret = aw_dev_update_reg_container(aw_dev, data, len); 1076 if (ret) { 1077 dev_err(aw_dev->dev, "reg update failed"); 1078 return ret; 1079 } 1080 1081 return 0; 1082 } 1083 1084 static int aw_dev_get_ra(struct aw_cali_desc *cali_desc) 1085 { 1086 struct aw_device *aw_dev = 1087 container_of(cali_desc, struct aw_device, cali_desc); 1088 u32 dsp_ra; 1089 int ret; 1090 1091 ret = aw_dev_dsp_read(aw_dev, AW88395_DSP_REG_CFG_ADPZ_RA, 1092 &dsp_ra, AW_DSP_32_DATA); 1093 if (ret) { 1094 dev_err(aw_dev->dev, "read ra error"); 1095 return ret; 1096 } 1097 1098 cali_desc->ra = AW88395_DSP_RE_TO_SHOW_RE(dsp_ra, 1099 AW88395_DSP_RE_SHIFT); 1100 1101 return ret; 1102 } 1103 1104 static int aw_dev_dsp_update_container(struct aw_device *aw_dev, 1105 unsigned char *data, unsigned int len, unsigned short base) 1106 { 1107 int i, ret; 1108 1109 #ifdef AW88395_DSP_I2C_WRITES 1110 u32 tmp_len; 1111 1112 guard(mutex)(&aw_dev->dsp_lock); 1113 ret = regmap_write(aw_dev->regmap, AW88395_DSPMADD_REG, base); 1114 if (ret) 1115 return ret; 1116 1117 for (i = 0; i < len; i += AW88395_MAX_RAM_WRITE_BYTE_SIZE) { 1118 tmp_len = min(len - i, AW88395_MAX_RAM_WRITE_BYTE_SIZE); 1119 ret = regmap_raw_write(aw_dev->regmap, AW88395_DSPMDAT_REG, 1120 &data[i], tmp_len); 1121 if (ret) 1122 return ret; 1123 } 1124 #else 1125 __be16 reg_val; 1126 1127 guard(mutex)(&aw_dev->dsp_lock); 1128 /* i2c write */ 1129 ret = regmap_write(aw_dev->regmap, AW88395_DSPMADD_REG, base); 1130 if (ret) 1131 return ret; 1132 for (i = 0; i < len; i += 2) { 1133 reg_val = cpu_to_be16p((u16 *)(data + i)); 1134 ret = regmap_write(aw_dev->regmap, AW88395_DSPMDAT_REG, 1135 (u16)reg_val); 1136 if (ret) 1137 return ret; 1138 } 1139 #endif 1140 1141 return 0; 1142 } 1143 1144 static int aw_dev_dsp_update_fw(struct aw_device *aw_dev, 1145 unsigned char *data, unsigned int len) 1146 { 1147 1148 dev_dbg(aw_dev->dev, "dsp firmware len:%d", len); 1149 1150 if (!len || !data) { 1151 dev_err(aw_dev->dev, "dsp firmware data is null or len is 0"); 1152 return -EINVAL; 1153 } 1154 aw_dev_dsp_update_container(aw_dev, data, len, AW88395_DSP_FW_ADDR); 1155 aw_dev->dsp_fw_len = len; 1156 1157 return 0; 1158 } 1159 1160 static int aw_dev_copy_to_crc_dsp_cfg(struct aw_device *aw_dev, 1161 unsigned char *data, unsigned int size) 1162 { 1163 struct aw_sec_data_desc *crc_dsp_cfg = &aw_dev->crc_dsp_cfg; 1164 1165 if (!crc_dsp_cfg->data) { 1166 crc_dsp_cfg->data = devm_kzalloc(aw_dev->dev, size, GFP_KERNEL); 1167 if (!crc_dsp_cfg->data) 1168 return -ENOMEM; 1169 crc_dsp_cfg->len = size; 1170 } else if (crc_dsp_cfg->len < size) { 1171 devm_kfree(aw_dev->dev, crc_dsp_cfg->data); 1172 crc_dsp_cfg->data = devm_kzalloc(aw_dev->dev, size, GFP_KERNEL); 1173 if (!crc_dsp_cfg->data) 1174 return -ENOMEM; 1175 crc_dsp_cfg->len = size; 1176 } 1177 memcpy(crc_dsp_cfg->data, data, size); 1178 swab16_array((u16 *)crc_dsp_cfg->data, size >> 1); 1179 1180 return 0; 1181 } 1182 1183 static int aw_dev_dsp_update_cfg(struct aw_device *aw_dev, 1184 unsigned char *data, unsigned int len) 1185 { 1186 int ret; 1187 1188 dev_dbg(aw_dev->dev, "dsp config len:%d", len); 1189 1190 if (!len || !data) { 1191 dev_err(aw_dev->dev, "dsp config data is null or len is 0"); 1192 return -EINVAL; 1193 } 1194 1195 aw_dev_dsp_update_container(aw_dev, data, len, AW88395_DSP_CFG_ADDR); 1196 aw_dev->dsp_cfg_len = len; 1197 1198 ret = aw_dev_copy_to_crc_dsp_cfg(aw_dev, data, len); 1199 if (ret) 1200 return ret; 1201 1202 ret = aw_dev_set_vcalb(aw_dev); 1203 if (ret) 1204 return ret; 1205 ret = aw_dev_get_ra(&aw_dev->cali_desc); 1206 if (ret) 1207 return ret; 1208 ret = aw_dev_get_cali_f0_delay(aw_dev); 1209 if (ret) 1210 return ret; 1211 1212 ret = aw_dev_get_vmax(aw_dev, &aw_dev->vmax_desc.init_vmax); 1213 if (ret) { 1214 dev_err(aw_dev->dev, "get vmax failed"); 1215 return ret; 1216 } 1217 dev_dbg(aw_dev->dev, "get init vmax:0x%x", aw_dev->vmax_desc.init_vmax); 1218 aw_dev->dsp_crc_st = AW88395_DSP_CRC_NA; 1219 1220 return 0; 1221 } 1222 1223 static int aw_dev_check_sram(struct aw_device *aw_dev) 1224 { 1225 unsigned int reg_val; 1226 1227 guard(mutex)(&aw_dev->dsp_lock); 1228 /* check the odd bits of reg 0x40 */ 1229 regmap_write(aw_dev->regmap, AW88395_DSPMADD_REG, AW88395_DSP_ODD_NUM_BIT_TEST); 1230 regmap_read(aw_dev->regmap, AW88395_DSPMADD_REG, ®_val); 1231 if (reg_val != AW88395_DSP_ODD_NUM_BIT_TEST) { 1232 dev_err(aw_dev->dev, "check reg 0x40 odd bit failed, read[0x%x] != write[0x%x]", 1233 reg_val, AW88395_DSP_ODD_NUM_BIT_TEST); 1234 return -EPERM; 1235 } 1236 1237 /* check the even bits of reg 0x40 */ 1238 regmap_write(aw_dev->regmap, AW88395_DSPMADD_REG, AW88395_DSP_EVEN_NUM_BIT_TEST); 1239 regmap_read(aw_dev->regmap, AW88395_DSPMADD_REG, ®_val); 1240 if (reg_val != AW88395_DSP_EVEN_NUM_BIT_TEST) { 1241 dev_err(aw_dev->dev, "check reg 0x40 even bit failed, read[0x%x] != write[0x%x]", 1242 reg_val, AW88395_DSP_EVEN_NUM_BIT_TEST); 1243 return -EPERM; 1244 } 1245 1246 /* check dsp_fw_base_addr */ 1247 aw_dev_dsp_write_16bit(aw_dev, AW88395_DSP_FW_ADDR, AW88395_DSP_EVEN_NUM_BIT_TEST); 1248 aw_dev_dsp_read_16bit(aw_dev, AW88395_DSP_FW_ADDR, ®_val); 1249 if (reg_val != AW88395_DSP_EVEN_NUM_BIT_TEST) { 1250 dev_err(aw_dev->dev, "check dsp fw addr failed, read[0x%x] != write[0x%x]", 1251 reg_val, AW88395_DSP_EVEN_NUM_BIT_TEST); 1252 return -EPERM; 1253 } 1254 1255 /* check dsp_cfg_base_addr */ 1256 aw_dev_dsp_write_16bit(aw_dev, AW88395_DSP_CFG_ADDR, AW88395_DSP_ODD_NUM_BIT_TEST); 1257 aw_dev_dsp_read_16bit(aw_dev, AW88395_DSP_CFG_ADDR, ®_val); 1258 if (reg_val != AW88395_DSP_ODD_NUM_BIT_TEST) { 1259 dev_err(aw_dev->dev, "check dsp cfg failed, read[0x%x] != write[0x%x]", 1260 reg_val, AW88395_DSP_ODD_NUM_BIT_TEST); 1261 return -EPERM; 1262 } 1263 1264 return 0; 1265 } 1266 1267 int aw88395_dev_fw_update(struct aw_device *aw_dev, bool up_dsp_fw_en, bool force_up_en) 1268 { 1269 struct aw_prof_desc *prof_index_desc; 1270 struct aw_sec_data_desc *sec_desc; 1271 char *prof_name; 1272 int ret; 1273 1274 if ((aw_dev->prof_cur == aw_dev->prof_index) && 1275 (force_up_en == AW88395_FORCE_UPDATE_OFF)) { 1276 dev_dbg(aw_dev->dev, "scene no change, not update"); 1277 return 0; 1278 } 1279 1280 if (aw_dev->fw_status == AW88395_DEV_FW_FAILED) { 1281 dev_err(aw_dev->dev, "fw status[%d] error", aw_dev->fw_status); 1282 return -EPERM; 1283 } 1284 1285 ret = aw88395_dev_get_prof_name(aw_dev, aw_dev->prof_index, &prof_name); 1286 if (ret) 1287 return ret; 1288 1289 dev_dbg(aw_dev->dev, "start update %s", prof_name); 1290 1291 ret = aw88395_dev_get_prof_data(aw_dev, aw_dev->prof_index, &prof_index_desc); 1292 if (ret) 1293 return ret; 1294 1295 /* update reg */ 1296 sec_desc = prof_index_desc->sec_desc; 1297 ret = aw_dev_reg_update(aw_dev, sec_desc[AW88395_DATA_TYPE_REG].data, 1298 sec_desc[AW88395_DATA_TYPE_REG].len); 1299 if (ret) { 1300 dev_err(aw_dev->dev, "update reg failed"); 1301 return ret; 1302 } 1303 1304 aw88395_dev_mute(aw_dev, true); 1305 1306 if (aw_dev->dsp_cfg == AW88395_DEV_DSP_WORK) 1307 aw_dev_dsp_enable(aw_dev, false); 1308 1309 aw_dev_select_memclk(aw_dev, AW88395_DEV_MEMCLK_OSC); 1310 1311 if (up_dsp_fw_en) { 1312 ret = aw_dev_check_sram(aw_dev); 1313 if (ret) { 1314 dev_err(aw_dev->dev, "check sram failed"); 1315 goto error; 1316 } 1317 1318 /* update dsp firmware */ 1319 dev_dbg(aw_dev->dev, "fw_ver: [%x]", prof_index_desc->fw_ver); 1320 ret = aw_dev_dsp_update_fw(aw_dev, sec_desc[AW88395_DATA_TYPE_DSP_FW].data, 1321 sec_desc[AW88395_DATA_TYPE_DSP_FW].len); 1322 if (ret) { 1323 dev_err(aw_dev->dev, "update dsp fw failed"); 1324 goto error; 1325 } 1326 } 1327 1328 /* update dsp config */ 1329 ret = aw_dev_dsp_update_cfg(aw_dev, sec_desc[AW88395_DATA_TYPE_DSP_CFG].data, 1330 sec_desc[AW88395_DATA_TYPE_DSP_CFG].len); 1331 if (ret) { 1332 dev_err(aw_dev->dev, "update dsp cfg failed"); 1333 goto error; 1334 } 1335 1336 aw_dev_select_memclk(aw_dev, AW88395_DEV_MEMCLK_PLL); 1337 1338 aw_dev->prof_cur = aw_dev->prof_index; 1339 1340 return 0; 1341 1342 error: 1343 aw_dev_select_memclk(aw_dev, AW88395_DEV_MEMCLK_PLL); 1344 return ret; 1345 } 1346 EXPORT_SYMBOL_GPL(aw88395_dev_fw_update); 1347 1348 static int aw_dev_dsp_check(struct aw_device *aw_dev) 1349 { 1350 int ret, i; 1351 1352 switch (aw_dev->dsp_cfg) { 1353 case AW88395_DEV_DSP_BYPASS: 1354 dev_dbg(aw_dev->dev, "dsp bypass"); 1355 ret = 0; 1356 break; 1357 case AW88395_DEV_DSP_WORK: 1358 aw_dev_dsp_enable(aw_dev, false); 1359 aw_dev_dsp_enable(aw_dev, true); 1360 usleep_range(AW88395_1000_US, AW88395_1000_US + 10); 1361 for (i = 0; i < AW88395_DEV_DSP_CHECK_MAX; i++) { 1362 ret = aw_dev_get_dsp_status(aw_dev); 1363 if (ret) { 1364 dev_err(aw_dev->dev, "dsp wdt status error=%d", ret); 1365 usleep_range(AW88395_2000_US, AW88395_2000_US + 10); 1366 } 1367 } 1368 break; 1369 default: 1370 dev_err(aw_dev->dev, "unknown dsp cfg=%d", aw_dev->dsp_cfg); 1371 ret = -EINVAL; 1372 break; 1373 } 1374 1375 return ret; 1376 } 1377 1378 static void aw_dev_update_cali_re(struct aw_cali_desc *cali_desc) 1379 { 1380 struct aw_device *aw_dev = 1381 container_of(cali_desc, struct aw_device, cali_desc); 1382 int ret; 1383 1384 if ((aw_dev->cali_desc.cali_re < AW88395_CALI_RE_MAX) && 1385 (aw_dev->cali_desc.cali_re > AW88395_CALI_RE_MIN)) { 1386 1387 ret = aw_dev_dsp_set_cali_re(aw_dev); 1388 if (ret) 1389 dev_err(aw_dev->dev, "set cali re failed"); 1390 } 1391 } 1392 1393 int aw88395_dev_start(struct aw_device *aw_dev) 1394 { 1395 int ret; 1396 1397 if (aw_dev->status == AW88395_DEV_PW_ON) { 1398 dev_info(aw_dev->dev, "already power on"); 1399 return 0; 1400 } 1401 /* power on */ 1402 aw_dev_pwd(aw_dev, false); 1403 usleep_range(AW88395_2000_US, AW88395_2000_US + 10); 1404 1405 ret = aw_dev_check_syspll(aw_dev); 1406 if (ret) { 1407 dev_err(aw_dev->dev, "pll check failed cannot start"); 1408 goto pll_check_fail; 1409 } 1410 1411 /* amppd on */ 1412 aw_dev_amppd(aw_dev, false); 1413 usleep_range(AW88395_1000_US, AW88395_1000_US + 50); 1414 1415 /* check i2s status */ 1416 ret = aw_dev_check_sysst(aw_dev); 1417 if (ret) { 1418 dev_err(aw_dev->dev, "sysst check failed"); 1419 goto sysst_check_fail; 1420 } 1421 1422 if (aw_dev->dsp_cfg == AW88395_DEV_DSP_WORK) { 1423 /* dsp bypass */ 1424 aw_dev_dsp_enable(aw_dev, false); 1425 ret = aw_dev_dsp_fw_check(aw_dev); 1426 if (ret) 1427 goto dev_dsp_fw_check_fail; 1428 1429 aw_dev_update_cali_re(&aw_dev->cali_desc); 1430 1431 if (aw_dev->dsp_crc_st != AW88395_DSP_CRC_OK) { 1432 ret = aw_dev_dsp_check_crc32(aw_dev); 1433 if (ret) { 1434 dev_err(aw_dev->dev, "dsp crc check failed"); 1435 goto crc_check_fail; 1436 } 1437 } 1438 1439 ret = aw_dev_dsp_check(aw_dev); 1440 if (ret) { 1441 dev_err(aw_dev->dev, "dsp status check failed"); 1442 goto dsp_check_fail; 1443 } 1444 } else { 1445 dev_dbg(aw_dev->dev, "start pa with dsp bypass"); 1446 } 1447 1448 /* enable tx feedback */ 1449 aw_dev_i2s_tx_enable(aw_dev, true); 1450 1451 /* close mute */ 1452 aw88395_dev_mute(aw_dev, false); 1453 /* clear inturrupt */ 1454 aw_dev_clear_int_status(aw_dev); 1455 aw_dev->status = AW88395_DEV_PW_ON; 1456 1457 return 0; 1458 1459 dsp_check_fail: 1460 crc_check_fail: 1461 aw_dev_dsp_enable(aw_dev, false); 1462 dev_dsp_fw_check_fail: 1463 sysst_check_fail: 1464 aw_dev_clear_int_status(aw_dev); 1465 aw_dev_amppd(aw_dev, true); 1466 pll_check_fail: 1467 aw_dev_pwd(aw_dev, true); 1468 aw_dev->status = AW88395_DEV_PW_OFF; 1469 1470 return ret; 1471 } 1472 EXPORT_SYMBOL_GPL(aw88395_dev_start); 1473 1474 int aw88395_dev_stop(struct aw_device *aw_dev) 1475 { 1476 struct aw_sec_data_desc *dsp_cfg = 1477 &aw_dev->prof_info.prof_desc[aw_dev->prof_cur].sec_desc[AW88395_DATA_TYPE_DSP_CFG]; 1478 struct aw_sec_data_desc *dsp_fw = 1479 &aw_dev->prof_info.prof_desc[aw_dev->prof_cur].sec_desc[AW88395_DATA_TYPE_DSP_FW]; 1480 int int_st = 0; 1481 int ret; 1482 1483 if (aw_dev->status == AW88395_DEV_PW_OFF) { 1484 dev_info(aw_dev->dev, "already power off"); 1485 return 0; 1486 } 1487 1488 aw_dev->status = AW88395_DEV_PW_OFF; 1489 1490 /* set mute */ 1491 aw88395_dev_mute(aw_dev, true); 1492 usleep_range(AW88395_4000_US, AW88395_4000_US + 100); 1493 1494 /* close tx feedback */ 1495 aw_dev_i2s_tx_enable(aw_dev, false); 1496 usleep_range(AW88395_1000_US, AW88395_1000_US + 100); 1497 1498 /* check sysint state */ 1499 int_st = aw_dev_check_sysint(aw_dev); 1500 1501 /* close dsp */ 1502 aw_dev_dsp_enable(aw_dev, false); 1503 1504 /* enable amppd */ 1505 aw_dev_amppd(aw_dev, true); 1506 1507 if (int_st < 0) { 1508 /* system status anomaly */ 1509 aw_dev_select_memclk(aw_dev, AW88395_DEV_MEMCLK_OSC); 1510 ret = aw_dev_dsp_update_fw(aw_dev, dsp_fw->data, dsp_fw->len); 1511 if (ret) 1512 dev_err(aw_dev->dev, "update dsp fw failed"); 1513 ret = aw_dev_dsp_update_cfg(aw_dev, dsp_cfg->data, dsp_cfg->len); 1514 if (ret) 1515 dev_err(aw_dev->dev, "update dsp cfg failed"); 1516 aw_dev_select_memclk(aw_dev, AW88395_DEV_MEMCLK_PLL); 1517 } 1518 1519 /* set power down */ 1520 aw_dev_pwd(aw_dev, true); 1521 1522 return 0; 1523 } 1524 EXPORT_SYMBOL_GPL(aw88395_dev_stop); 1525 1526 int aw88395_dev_init(struct aw_device *aw_dev, struct aw_container *aw_cfg) 1527 { 1528 int ret; 1529 1530 if ((!aw_dev) || (!aw_cfg)) { 1531 pr_err("aw_dev is NULL or aw_cfg is NULL"); 1532 return -ENOMEM; 1533 } 1534 ret = aw88395_dev_cfg_load(aw_dev, aw_cfg); 1535 if (ret) { 1536 dev_err(aw_dev->dev, "aw_dev acf parse failed"); 1537 return -EINVAL; 1538 } 1539 aw_dev->fade_in_time = AW88395_1000_US / 10; 1540 aw_dev->fade_out_time = AW88395_1000_US >> 1; 1541 aw_dev->prof_cur = aw_dev->prof_info.prof_desc[0].id; 1542 aw_dev->prof_index = aw_dev->prof_info.prof_desc[0].id; 1543 1544 ret = aw88395_dev_fw_update(aw_dev, AW88395_FORCE_UPDATE_ON, AW88395_DSP_FW_UPDATE_ON); 1545 if (ret) { 1546 dev_err(aw_dev->dev, "fw update failed ret = %d\n", ret); 1547 return ret; 1548 } 1549 1550 /* set mute */ 1551 aw88395_dev_mute(aw_dev, true); 1552 usleep_range(AW88395_4000_US, AW88395_4000_US + 100); 1553 1554 /* close tx feedback */ 1555 aw_dev_i2s_tx_enable(aw_dev, false); 1556 usleep_range(AW88395_1000_US, AW88395_1000_US + 100); 1557 1558 /* close dsp */ 1559 aw_dev_dsp_enable(aw_dev, false); 1560 /* enable amppd */ 1561 aw_dev_amppd(aw_dev, true); 1562 /* set power down */ 1563 aw_dev_pwd(aw_dev, true); 1564 1565 return 0; 1566 } 1567 EXPORT_SYMBOL_GPL(aw88395_dev_init); 1568 1569 static void aw88395_parse_channel_dt(struct aw_device *aw_dev) 1570 { 1571 struct device_node *np = aw_dev->dev->of_node; 1572 u32 channel_value; 1573 int ret; 1574 1575 ret = of_property_read_u32(np, "awinic,audio-channel", &channel_value); 1576 if (ret) { 1577 dev_dbg(aw_dev->dev, 1578 "read audio-channel failed,use default 0"); 1579 aw_dev->channel = AW88395_DEV_DEFAULT_CH; 1580 return; 1581 } 1582 1583 dev_dbg(aw_dev->dev, "read audio-channel value is: %d", 1584 channel_value); 1585 aw_dev->channel = channel_value; 1586 } 1587 1588 static int aw_dev_init(struct aw_device *aw_dev) 1589 { 1590 aw_dev->chip_id = AW88395_CHIP_ID; 1591 /* call aw device init func */ 1592 aw_dev->acf = NULL; 1593 aw_dev->prof_info.prof_desc = NULL; 1594 aw_dev->prof_info.count = 0; 1595 aw_dev->prof_info.prof_type = AW88395_DEV_NONE_TYPE_ID; 1596 aw_dev->channel = 0; 1597 aw_dev->fw_status = AW88395_DEV_FW_FAILED; 1598 1599 aw_dev->fade_step = AW88395_VOLUME_STEP_DB; 1600 aw_dev->volume_desc.ctl_volume = AW88395_VOL_DEFAULT_VALUE; 1601 aw88395_parse_channel_dt(aw_dev); 1602 1603 return 0; 1604 } 1605 1606 int aw88395_dev_get_profile_count(struct aw_device *aw_dev) 1607 { 1608 return aw_dev->prof_info.count; 1609 } 1610 EXPORT_SYMBOL_GPL(aw88395_dev_get_profile_count); 1611 1612 int aw88395_dev_get_profile_index(struct aw_device *aw_dev) 1613 { 1614 return aw_dev->prof_index; 1615 } 1616 EXPORT_SYMBOL_GPL(aw88395_dev_get_profile_index); 1617 1618 int aw88395_dev_set_profile_index(struct aw_device *aw_dev, int index) 1619 { 1620 /* check the index whether is valid */ 1621 if ((index >= aw_dev->prof_info.count) || (index < 0)) 1622 return -EINVAL; 1623 /* check the index whether change */ 1624 if (aw_dev->prof_index == index) 1625 return -EINVAL; 1626 1627 aw_dev->prof_index = index; 1628 dev_dbg(aw_dev->dev, "set prof[%s]", 1629 aw_dev->prof_info.prof_name_list[aw_dev->prof_info.prof_desc[index].id]); 1630 1631 return 0; 1632 } 1633 EXPORT_SYMBOL_GPL(aw88395_dev_set_profile_index); 1634 1635 int aw88395_dev_get_prof_name(struct aw_device *aw_dev, int index, char **prof_name) 1636 { 1637 struct aw_prof_info *prof_info = &aw_dev->prof_info; 1638 struct aw_prof_desc *prof_desc; 1639 1640 if ((index >= aw_dev->prof_info.count) || (index < 0)) { 1641 dev_err(aw_dev->dev, "index[%d] overflow count[%d]", 1642 index, aw_dev->prof_info.count); 1643 return -EINVAL; 1644 } 1645 1646 prof_desc = &aw_dev->prof_info.prof_desc[index]; 1647 1648 *prof_name = prof_info->prof_name_list[prof_desc->id]; 1649 1650 return 0; 1651 } 1652 EXPORT_SYMBOL_GPL(aw88395_dev_get_prof_name); 1653 1654 int aw88395_dev_get_prof_data(struct aw_device *aw_dev, int index, 1655 struct aw_prof_desc **prof_desc) 1656 { 1657 if ((index >= aw_dev->prof_info.count) || (index < 0)) { 1658 dev_err(aw_dev->dev, "%s: index[%d] overflow count[%d]\n", 1659 __func__, index, aw_dev->prof_info.count); 1660 return -EINVAL; 1661 } 1662 1663 *prof_desc = &aw_dev->prof_info.prof_desc[index]; 1664 1665 return 0; 1666 } 1667 EXPORT_SYMBOL_GPL(aw88395_dev_get_prof_data); 1668 1669 int aw88395_init(struct aw_device **aw_dev, struct i2c_client *i2c, struct regmap *regmap) 1670 { 1671 u16 chip_id; 1672 int ret; 1673 1674 if (*aw_dev) { 1675 dev_info(&i2c->dev, "it should be initialized here.\n"); 1676 } else { 1677 *aw_dev = devm_kzalloc(&i2c->dev, sizeof(struct aw_device), GFP_KERNEL); 1678 if (!(*aw_dev)) 1679 return -ENOMEM; 1680 } 1681 1682 (*aw_dev)->i2c = i2c; 1683 (*aw_dev)->dev = &i2c->dev; 1684 (*aw_dev)->regmap = regmap; 1685 mutex_init(&(*aw_dev)->dsp_lock); 1686 1687 /* read chip id */ 1688 ret = aw_dev_read_chipid((*aw_dev), &chip_id); 1689 if (ret) { 1690 dev_err(&i2c->dev, "dev_read_chipid failed ret=%d", ret); 1691 return ret; 1692 } 1693 1694 switch (chip_id) { 1695 case AW88395_CHIP_ID: 1696 ret = aw_dev_init((*aw_dev)); 1697 break; 1698 default: 1699 ret = -EINVAL; 1700 dev_err((*aw_dev)->dev, "unsupported device"); 1701 break; 1702 } 1703 1704 return ret; 1705 } 1706 EXPORT_SYMBOL_GPL(aw88395_init); 1707 1708 MODULE_DESCRIPTION("AW88395 device lib"); 1709 MODULE_LICENSE("GPL v2"); 1710