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