sound/pci/hda/tas2781_hda_i2c.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 //
   3 // TAS2781 HDA I2C driver
   4 //
   5 // Copyright 2023 Texas Instruments, Inc.
   6 //
   7 // Author: Shenghao Ding <shenghao-ding@ti.com>
   8
   9 #include <linux/acpi.h>
  10 #include <linux/crc8.h>
  11 #include <linux/crc32.h>
  12 #include <linux/efi.h>
  13 #include <linux/firmware.h>
  14 #include <linux/i2c.h>
  15 #include <linux/mod_devicetable.h>
  16 #include <linux/module.h>
  17 #include <linux/pm_runtime.h>
  18 #include <linux/regmap.h>
  19 #include <sound/hda_codec.h>
  20 #include <sound/soc.h>
  21 #include <sound/tas2781.h>
  22 #include <sound/tlv.h>
  23 #include <sound/tas2781-tlv.h>
  24
  25 #include "hda_local.h"
  26 #include "hda_auto_parser.h"
  27 #include "hda_component.h"
  28 #include "hda_jack.h"
  29 #include "hda_generic.h"
  30
  31 #define TASDEVICE_SPEAKER_CALIBRATION_SIZE      20
  32
  33 /* No standard control callbacks for SNDRV_CTL_ELEM_IFACE_CARD
  34  * Define two controls, one is Volume control callbacks, the other is
  35  * flag setting control callbacks.
  36  */
  37
  38 /* Volume control callbacks for tas2781 */
  39 #define ACARD_SINGLE_RANGE_EXT_TLV(xname, xreg, xshift, xmin, xmax, xinvert, \
  40         xhandler_get, xhandler_put, tlv_array) \
  41 {       .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = (xname),\
  42         .access = SNDRV_CTL_ELEM_ACCESS_TLV_READ |\
  43                  SNDRV_CTL_ELEM_ACCESS_READWRITE,\
  44         .tlv.p = (tlv_array), \
  45         .info = snd_soc_info_volsw_range, \
  46         .get = xhandler_get, .put = xhandler_put, \
  47         .private_value = (unsigned long)&(struct soc_mixer_control) \
  48                 {.reg = xreg, .rreg = xreg, .shift = xshift, \
  49                  .rshift = xshift, .min = xmin, .max = xmax, \
  50                  .invert = xinvert} }
  51
  52 /* Flag control callbacks for tas2781 */
  53 #define ACARD_SINGLE_BOOL_EXT(xname, xdata, xhandler_get, xhandler_put) \
  54 {       .iface = SNDRV_CTL_ELEM_IFACE_CARD, .name = xname, \
  55         .info = snd_ctl_boolean_mono_info, \
  56         .get = xhandler_get, .put = xhandler_put, \
  57         .private_value = xdata }
  58
  59 enum calib_data {
  60         R0_VAL = 0,
  61         INV_R0,
  62         R0LOW,
  63         POWER,
  64         TLIM,
  65         CALIB_MAX
  66 };
  67
  68 #define TAS2563_MAX_CHANNELS    4
  69
  70 #define TAS2563_CAL_POWER       TASDEVICE_REG(0, 0x0d, 0x3c)
  71 #define TAS2563_CAL_R0          TASDEVICE_REG(0, 0x0f, 0x34)
  72 #define TAS2563_CAL_INVR0       TASDEVICE_REG(0, 0x0f, 0x40)
  73 #define TAS2563_CAL_R0_LOW      TASDEVICE_REG(0, 0x0f, 0x48)
  74 #define TAS2563_CAL_TLIM        TASDEVICE_REG(0, 0x10, 0x14)
  75 #define TAS2563_CAL_N           5
  76 #define TAS2563_CAL_DATA_SIZE   4
  77 #define TAS2563_CAL_CH_SIZE     20
  78 #define TAS2563_CAL_ARRAY_SIZE  80
  79
  80 static unsigned int cal_regs[TAS2563_CAL_N] = {
  81         TAS2563_CAL_POWER, TAS2563_CAL_R0, TAS2563_CAL_INVR0,
  82         TAS2563_CAL_R0_LOW, TAS2563_CAL_TLIM,
  83 };
  84
  85
  86 struct tas2781_hda {
  87         struct device *dev;
  88         struct tasdevice_priv *priv;
  89         struct snd_kcontrol *dsp_prog_ctl;
  90         struct snd_kcontrol *dsp_conf_ctl;
  91         struct snd_kcontrol *prof_ctl;
  92         struct snd_kcontrol *snd_ctls[3];
  93 };
  94
  95 static int tas2781_get_i2c_res(struct acpi_resource *ares, void *data)
  96 {
  97         struct tasdevice_priv *tas_priv = data;
  98         struct acpi_resource_i2c_serialbus *sb;
  99
 100         if (i2c_acpi_get_i2c_resource(ares, &sb)) {
 101                 if (tas_priv->ndev < TASDEVICE_MAX_CHANNELS &&
 102                         sb->slave_address != tas_priv->global_addr) {
 103                         tas_priv->tasdevice[tas_priv->ndev].dev_addr =
 104                                 (unsigned int)sb->slave_address;
 105                         tas_priv->ndev++;
 106                 }
 107         }
 108         return 1;
 109 }
 110
 111 static int tas2781_read_acpi(struct tasdevice_priv *p, const char *hid)
 112 {
 113         struct acpi_device *adev;
 114         LIST_HEAD(resources);
 115         int ret;
 116
 117         adev = acpi_dev_get_first_match_dev(hid, NULL, -1);
 118         if (!adev) {
 119                 dev_err(p->dev,
 120                         "Failed to find an ACPI device for %s\n", hid);
 121                 return -ENODEV;
 122         }
 123
 124         ret = acpi_dev_get_resources(adev, &resources, tas2781_get_i2c_res, p);
 125         if (ret < 0)
 126                 goto err;
 127
 128         acpi_dev_free_resource_list(&resources);
 129         strscpy(p->dev_name, hid, sizeof(p->dev_name));
 130         acpi_dev_put(adev);
 131
 132         return 0;
 133
 134 err:
 135         dev_err(p->dev, "read acpi error, ret: %d\n", ret);
 136         acpi_dev_put(adev);
 137
 138         return ret;
 139 }
 140
 141 static void tas2781_hda_playback_hook(struct device *dev, int action)
 142 {
 143         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 144
 145         dev_dbg(tas_hda->dev, "%s: action = %d\n", __func__, action);
 146         switch (action) {
 147         case HDA_GEN_PCM_ACT_OPEN:
 148                 pm_runtime_get_sync(dev);
 149                 mutex_lock(&tas_hda->priv->codec_lock);
 150                 tasdevice_tuning_switch(tas_hda->priv, 0);
 151                 tas_hda->priv->playback_started = true;
 152                 mutex_unlock(&tas_hda->priv->codec_lock);
 153                 break;
 154         case HDA_GEN_PCM_ACT_CLOSE:
 155                 mutex_lock(&tas_hda->priv->codec_lock);
 156                 tasdevice_tuning_switch(tas_hda->priv, 1);
 157                 tas_hda->priv->playback_started = false;
 158                 mutex_unlock(&tas_hda->priv->codec_lock);
 159
 160                 pm_runtime_mark_last_busy(dev);
 161                 pm_runtime_put_autosuspend(dev);
 162                 break;
 163         default:
 164                 dev_dbg(tas_hda->dev, "Playback action not supported: %d\n",
 165                         action);
 166                 break;
 167         }
 168 }
 169
 170 static int tasdevice_info_profile(struct snd_kcontrol *kcontrol,
 171                         struct snd_ctl_elem_info *uinfo)
 172 {
 173         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 174
 175         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 176         uinfo->count = 1;
 177         uinfo->value.integer.min = 0;
 178         uinfo->value.integer.max = tas_priv->rcabin.ncfgs - 1;
 179
 180         return 0;
 181 }
 182
 183 static int tasdevice_get_profile_id(struct snd_kcontrol *kcontrol,
 184                         struct snd_ctl_elem_value *ucontrol)
 185 {
 186         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 187
 188         ucontrol->value.integer.value[0] = tas_priv->rcabin.profile_cfg_id;
 189
 190         return 0;
 191 }
 192
 193 static int tasdevice_set_profile_id(struct snd_kcontrol *kcontrol,
 194                 struct snd_ctl_elem_value *ucontrol)
 195 {
 196         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 197         int nr_profile = ucontrol->value.integer.value[0];
 198         int max = tas_priv->rcabin.ncfgs - 1;
 199         int val, ret = 0;
 200
 201         val = clamp(nr_profile, 0, max);
 202
 203         if (tas_priv->rcabin.profile_cfg_id != val) {
 204                 tas_priv->rcabin.profile_cfg_id = val;
 205                 ret = 1;
 206         }
 207
 208         return ret;
 209 }
 210
 211 static int tasdevice_info_programs(struct snd_kcontrol *kcontrol,
 212                         struct snd_ctl_elem_info *uinfo)
 213 {
 214         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 215         struct tasdevice_fw *tas_fw = tas_priv->fmw;
 216
 217         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 218         uinfo->count = 1;
 219         uinfo->value.integer.min = 0;
 220         uinfo->value.integer.max = tas_fw->nr_programs - 1;
 221
 222         return 0;
 223 }
 224
 225 static int tasdevice_info_config(struct snd_kcontrol *kcontrol,
 226         struct snd_ctl_elem_info *uinfo)
 227 {
 228         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 229         struct tasdevice_fw *tas_fw = tas_priv->fmw;
 230
 231         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 232         uinfo->count = 1;
 233         uinfo->value.integer.min = 0;
 234         uinfo->value.integer.max = tas_fw->nr_configurations - 1;
 235
 236         return 0;
 237 }
 238
 239 static int tasdevice_program_get(struct snd_kcontrol *kcontrol,
 240         struct snd_ctl_elem_value *ucontrol)
 241 {
 242         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 243
 244         ucontrol->value.integer.value[0] = tas_priv->cur_prog;
 245
 246         return 0;
 247 }
 248
 249 static int tasdevice_program_put(struct snd_kcontrol *kcontrol,
 250         struct snd_ctl_elem_value *ucontrol)
 251 {
 252         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 253         struct tasdevice_fw *tas_fw = tas_priv->fmw;
 254         int nr_program = ucontrol->value.integer.value[0];
 255         int max = tas_fw->nr_programs - 1;
 256         int val, ret = 0;
 257
 258         val = clamp(nr_program, 0, max);
 259
 260         if (tas_priv->cur_prog != val) {
 261                 tas_priv->cur_prog = val;
 262                 ret = 1;
 263         }
 264
 265         return ret;
 266 }
 267
 268 static int tasdevice_config_get(struct snd_kcontrol *kcontrol,
 269         struct snd_ctl_elem_value *ucontrol)
 270 {
 271         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 272
 273         ucontrol->value.integer.value[0] = tas_priv->cur_conf;
 274
 275         return 0;
 276 }
 277
 278 static int tasdevice_config_put(struct snd_kcontrol *kcontrol,
 279         struct snd_ctl_elem_value *ucontrol)
 280 {
 281         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 282         struct tasdevice_fw *tas_fw = tas_priv->fmw;
 283         int nr_config = ucontrol->value.integer.value[0];
 284         int max = tas_fw->nr_configurations - 1;
 285         int val, ret = 0;
 286
 287         val = clamp(nr_config, 0, max);
 288
 289         if (tas_priv->cur_conf != val) {
 290                 tas_priv->cur_conf = val;
 291                 ret = 1;
 292         }
 293
 294         return ret;
 295 }
 296
 297 /*
 298  * tas2781_digital_getvol - get the volum control
 299  * @kcontrol: control pointer
 300  * @ucontrol: User data
 301  * Customer Kcontrol for tas2781 is primarily for regmap booking, paging
 302  * depends on internal regmap mechanism.
 303  * tas2781 contains book and page two-level register map, especially
 304  * book switching will set the register BXXP00R7F, after switching to the
 305  * correct book, then leverage the mechanism for paging to access the
 306  * register.
 307  */
 308 static int tas2781_digital_getvol(struct snd_kcontrol *kcontrol,
 309         struct snd_ctl_elem_value *ucontrol)
 310 {
 311         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 312         struct soc_mixer_control *mc =
 313                 (struct soc_mixer_control *)kcontrol->private_value;
 314
 315         return tasdevice_digital_getvol(tas_priv, ucontrol, mc);
 316 }
 317
 318 static int tas2781_amp_getvol(struct snd_kcontrol *kcontrol,
 319         struct snd_ctl_elem_value *ucontrol)
 320 {
 321         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 322         struct soc_mixer_control *mc =
 323                 (struct soc_mixer_control *)kcontrol->private_value;
 324
 325         return tasdevice_amp_getvol(tas_priv, ucontrol, mc);
 326 }
 327
 328 static int tas2781_digital_putvol(struct snd_kcontrol *kcontrol,
 329         struct snd_ctl_elem_value *ucontrol)
 330 {
 331         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 332         struct soc_mixer_control *mc =
 333                 (struct soc_mixer_control *)kcontrol->private_value;
 334
 335         /* The check of the given value is in tasdevice_digital_putvol. */
 336         return tasdevice_digital_putvol(tas_priv, ucontrol, mc);
 337 }
 338
 339 static int tas2781_amp_putvol(struct snd_kcontrol *kcontrol,
 340         struct snd_ctl_elem_value *ucontrol)
 341 {
 342         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 343         struct soc_mixer_control *mc =
 344                 (struct soc_mixer_control *)kcontrol->private_value;
 345
 346         /* The check of the given value is in tasdevice_amp_putvol. */
 347         return tasdevice_amp_putvol(tas_priv, ucontrol, mc);
 348 }
 349
 350 static int tas2781_force_fwload_get(struct snd_kcontrol *kcontrol,
 351         struct snd_ctl_elem_value *ucontrol)
 352 {
 353         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 354
 355         ucontrol->value.integer.value[0] = (int)tas_priv->force_fwload_status;
 356         dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__,
 357                         tas_priv->force_fwload_status ? "ON" : "OFF");
 358
 359         return 0;
 360 }
 361
 362 static int tas2781_force_fwload_put(struct snd_kcontrol *kcontrol,
 363         struct snd_ctl_elem_value *ucontrol)
 364 {
 365         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 366         bool change, val = (bool)ucontrol->value.integer.value[0];
 367
 368         if (tas_priv->force_fwload_status == val)
 369                 change = false;
 370         else {
 371                 change = true;
 372                 tas_priv->force_fwload_status = val;
 373         }
 374         dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__,
 375                 tas_priv->force_fwload_status ? "ON" : "OFF");
 376
 377         return change;
 378 }
 379
 380 static const struct snd_kcontrol_new tas2781_snd_controls[] = {
 381         ACARD_SINGLE_RANGE_EXT_TLV("Speaker Analog Gain", TAS2781_AMP_LEVEL,
 382                 1, 0, 20, 0, tas2781_amp_getvol,
 383                 tas2781_amp_putvol, amp_vol_tlv),
 384         ACARD_SINGLE_RANGE_EXT_TLV("Speaker Digital Gain", TAS2781_DVC_LVL,
 385                 0, 0, 200, 1, tas2781_digital_getvol,
 386                 tas2781_digital_putvol, dvc_tlv),
 387         ACARD_SINGLE_BOOL_EXT("Speaker Force Firmware Load", 0,
 388                 tas2781_force_fwload_get, tas2781_force_fwload_put),
 389 };
 390
 391 static const struct snd_kcontrol_new tas2781_prof_ctrl = {
 392         .name = "Speaker Profile Id",
 393         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
 394         .info = tasdevice_info_profile,
 395         .get = tasdevice_get_profile_id,
 396         .put = tasdevice_set_profile_id,
 397 };
 398
 399 static const struct snd_kcontrol_new tas2781_dsp_prog_ctrl = {
 400         .name = "Speaker Program Id",
 401         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
 402         .info = tasdevice_info_programs,
 403         .get = tasdevice_program_get,
 404         .put = tasdevice_program_put,
 405 };
 406
 407 static const struct snd_kcontrol_new tas2781_dsp_conf_ctrl = {
 408         .name = "Speaker Config Id",
 409         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
 410         .info = tasdevice_info_config,
 411         .get = tasdevice_config_get,
 412         .put = tasdevice_config_put,
 413 };
 414
 415 static void tas2563_apply_calib(struct tasdevice_priv *tas_priv)
 416 {
 417         int offset = 0;
 418         __be32 data;
 419         int ret;
 420
 421         for (int i = 0; i < tas_priv->ndev; i++) {
 422                 for (int j = 0; j < TAS2563_CAL_N; ++j) {
 423                         data = cpu_to_be32(
 424                                 *(uint32_t *)&tas_priv->cali_data.data[offset]);
 425                         ret = tasdevice_dev_bulk_write(tas_priv, i, cal_regs[j],
 426                                 (unsigned char *)&data, TAS2563_CAL_DATA_SIZE);
 427                         if (ret)
 428                                 dev_err(tas_priv->dev,
 429                                         "Error writing calib regs\n");
 430                         offset += TAS2563_CAL_DATA_SIZE;
 431                 }
 432         }
 433 }
 434
 435 static int tas2563_save_calibration(struct tasdevice_priv *tas_priv)
 436 {
 437         static efi_guid_t efi_guid = EFI_GUID(0x1f52d2a1, 0xbb3a, 0x457d, 0xbc,
 438                 0x09, 0x43, 0xa3, 0xf4, 0x31, 0x0a, 0x92);
 439
 440         static efi_char16_t *efi_vars[TAS2563_MAX_CHANNELS][TAS2563_CAL_N] = {
 441                 { L"Power_1", L"R0_1", L"InvR0_1", L"R0_Low_1", L"TLim_1" },
 442                 { L"Power_2", L"R0_2", L"InvR0_2", L"R0_Low_2", L"TLim_2" },
 443                 { L"Power_3", L"R0_3", L"InvR0_3", L"R0_Low_3", L"TLim_3" },
 444                 { L"Power_4", L"R0_4", L"InvR0_4", L"R0_Low_4", L"TLim_4" },
 445         };
 446
 447         unsigned long max_size = TAS2563_CAL_DATA_SIZE;
 448         unsigned int offset = 0;
 449         efi_status_t status;
 450         unsigned int attr;
 451
 452         tas_priv->cali_data.data = devm_kzalloc(tas_priv->dev,
 453                         TAS2563_CAL_ARRAY_SIZE, GFP_KERNEL);
 454         if (!tas_priv->cali_data.data)
 455                 return -ENOMEM;
 456
 457         for (int i = 0; i < tas_priv->ndev; ++i) {
 458                 for (int j = 0; j < TAS2563_CAL_N; ++j) {
 459                         status = efi.get_variable(efi_vars[i][j],
 460                                 &efi_guid, &attr, &max_size,
 461                                 &tas_priv->cali_data.data[offset]);
 462                         if (status != EFI_SUCCESS ||
 463                                 max_size != TAS2563_CAL_DATA_SIZE) {
 464                                 dev_warn(tas_priv->dev,
 465                                 "Calibration data read failed %ld\n", status);
 466                                 return -EINVAL;
 467                         }
 468                         offset += TAS2563_CAL_DATA_SIZE;
 469                 }
 470         }
 471
 472         tas_priv->cali_data.total_sz = offset;
 473         tasdevice_apply_calibration(tas_priv);
 474
 475         return 0;
 476 }
 477
 478 static void tas2781_apply_calib(struct tasdevice_priv *tas_priv)
 479 {
 480         static const unsigned char page_array[CALIB_MAX] = {
 481                 0x17, 0x18, 0x18, 0x0d, 0x18
 482         };
 483         static const unsigned char rgno_array[CALIB_MAX] = {
 484                 0x74, 0x0c, 0x14, 0x3c, 0x7c
 485         };
 486         unsigned char *data;
 487         int i, j, rc;
 488
 489         for (i = 0; i < tas_priv->ndev; i++) {
 490                 data = tas_priv->cali_data.data +
 491                         i * TASDEVICE_SPEAKER_CALIBRATION_SIZE;
 492                 for (j = 0; j < CALIB_MAX; j++) {
 493                         rc = tasdevice_dev_bulk_write(tas_priv, i,
 494                                 TASDEVICE_REG(0, page_array[j], rgno_array[j]),
 495                                 &(data[4 * j]), 4);
 496                         if (rc < 0)
 497                                 dev_err(tas_priv->dev,
 498                                         "chn %d calib %d bulk_wr err = %d\n",
 499                                         i, j, rc);
 500                 }
 501         }
 502 }
 503
 504 /* Update the calibration data, including speaker impedance, f0, etc, into algo.
 505  * Calibrate data is done by manufacturer in the factory. These data are used
 506  * by Algo for calculating the speaker temperature, speaker membrane excursion
 507  * and f0 in real time during playback.
 508  */
 509 static int tas2781_save_calibration(struct tasdevice_priv *tas_priv)
 510 {
 511         efi_guid_t efi_guid = EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d,
 512                 0x93, 0xfe, 0x5a, 0xa3, 0x5d, 0xb3);
 513         static efi_char16_t efi_name[] = L"CALI_DATA";
 514         struct tm *tm = &tas_priv->tm;
 515         unsigned int attr, crc;
 516         unsigned int *tmp_val;
 517         efi_status_t status;
 518
 519         /* Lenovo devices */
 520         if (tas_priv->catlog_id == LENOVO)
 521                 efi_guid = EFI_GUID(0x1f52d2a1, 0xbb3a, 0x457d, 0xbc, 0x09,
 522                         0x43, 0xa3, 0xf4, 0x31, 0x0a, 0x92);
 523
 524         tas_priv->cali_data.total_sz = 0;
 525         /* Get real size of UEFI variable */
 526         status = efi.get_variable(efi_name, &efi_guid, &attr,
 527                 &tas_priv->cali_data.total_sz, tas_priv->cali_data.data);
 528         if (status == EFI_BUFFER_TOO_SMALL) {
 529                 /* Allocate data buffer of data_size bytes */
 530                 tas_priv->cali_data.data = devm_kzalloc(tas_priv->dev,
 531                         tas_priv->cali_data.total_sz, GFP_KERNEL);
 532                 if (!tas_priv->cali_data.data)
 533                         return -ENOMEM;
 534                 /* Get variable contents into buffer */
 535                 status = efi.get_variable(efi_name, &efi_guid, &attr,
 536                         &tas_priv->cali_data.total_sz,
 537                         tas_priv->cali_data.data);
 538         }
 539         if (status != EFI_SUCCESS)
 540                 return -EINVAL;
 541
 542         tmp_val = (unsigned int *)tas_priv->cali_data.data;
 543
 544         crc = crc32(~0, tas_priv->cali_data.data, 84) ^ ~0;
 545         dev_dbg(tas_priv->dev, "cali crc 0x%08x PK tmp_val 0x%08x\n",
 546                 crc, tmp_val[21]);
 547
 548         if (crc == tmp_val[21]) {
 549                 time64_to_tm(tmp_val[20], 0, tm);
 550                 dev_dbg(tas_priv->dev, "%4ld-%2d-%2d, %2d:%2d:%2d\n",
 551                         tm->tm_year, tm->tm_mon, tm->tm_mday,
 552                         tm->tm_hour, tm->tm_min, tm->tm_sec);
 553                 tasdevice_apply_calibration(tas_priv);
 554         } else
 555                 tas_priv->cali_data.total_sz = 0;
 556
 557         return 0;
 558 }
 559
 560 static void tas2781_hda_remove_controls(struct tas2781_hda *tas_hda)
 561 {
 562         struct hda_codec *codec = tas_hda->priv->codec;
 563
 564         if (tas_hda->dsp_prog_ctl)
 565                 snd_ctl_remove(codec->card, tas_hda->dsp_prog_ctl);
 566
 567         if (tas_hda->dsp_conf_ctl)
 568                 snd_ctl_remove(codec->card, tas_hda->dsp_conf_ctl);
 569
 570         for (int i = ARRAY_SIZE(tas_hda->snd_ctls) - 1; i >= 0; i--)
 571                 if (tas_hda->snd_ctls[i])
 572                         snd_ctl_remove(codec->card, tas_hda->snd_ctls[i]);
 573
 574         if (tas_hda->prof_ctl)
 575                 snd_ctl_remove(codec->card, tas_hda->prof_ctl);
 576 }
 577
 578 static void tasdev_fw_ready(const struct firmware *fmw, void *context)
 579 {
 580         struct tasdevice_priv *tas_priv = context;
 581         struct tas2781_hda *tas_hda = dev_get_drvdata(tas_priv->dev);
 582         struct hda_codec *codec = tas_priv->codec;
 583         int i, ret;
 584
 585         pm_runtime_get_sync(tas_priv->dev);
 586         mutex_lock(&tas_priv->codec_lock);
 587
 588         ret = tasdevice_rca_parser(tas_priv, fmw);
 589         if (ret)
 590                 goto out;
 591
 592         tas_hda->prof_ctl = snd_ctl_new1(&tas2781_prof_ctrl, tas_priv);
 593         ret = snd_ctl_add(codec->card, tas_hda->prof_ctl);
 594         if (ret) {
 595                 dev_err(tas_priv->dev,
 596                         "Failed to add KControl %s = %d\n",
 597                         tas2781_prof_ctrl.name, ret);
 598                 goto out;
 599         }
 600
 601         for (i = 0; i < ARRAY_SIZE(tas2781_snd_controls); i++) {
 602                 tas_hda->snd_ctls[i] = snd_ctl_new1(&tas2781_snd_controls[i],
 603                         tas_priv);
 604                 ret = snd_ctl_add(codec->card, tas_hda->snd_ctls[i]);
 605                 if (ret) {
 606                         dev_err(tas_priv->dev,
 607                                 "Failed to add KControl %s = %d\n",
 608                                 tas2781_snd_controls[i].name, ret);
 609                         goto out;
 610                 }
 611         }
 612
 613         tasdevice_dsp_remove(tas_priv);
 614
 615         tas_priv->fw_state = TASDEVICE_DSP_FW_PENDING;
 616         scnprintf(tas_priv->coef_binaryname, 64, "TAS2XXX%04X.bin",
 617                 codec->core.subsystem_id & 0xffff);
 618         ret = tasdevice_dsp_parser(tas_priv);
 619         if (ret) {
 620                 dev_err(tas_priv->dev, "dspfw load %s error\n",
 621                         tas_priv->coef_binaryname);
 622                 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
 623                 goto out;
 624         }
 625
 626         tas_hda->dsp_prog_ctl = snd_ctl_new1(&tas2781_dsp_prog_ctrl,
 627                 tas_priv);
 628         ret = snd_ctl_add(codec->card, tas_hda->dsp_prog_ctl);
 629         if (ret) {
 630                 dev_err(tas_priv->dev,
 631                         "Failed to add KControl %s = %d\n",
 632                         tas2781_dsp_prog_ctrl.name, ret);
 633                 goto out;
 634         }
 635
 636         tas_hda->dsp_conf_ctl = snd_ctl_new1(&tas2781_dsp_conf_ctrl,
 637                 tas_priv);
 638         ret = snd_ctl_add(codec->card, tas_hda->dsp_conf_ctl);
 639         if (ret) {
 640                 dev_err(tas_priv->dev,
 641                         "Failed to add KControl %s = %d\n",
 642                         tas2781_dsp_conf_ctrl.name, ret);
 643                 goto out;
 644         }
 645
 646         tas_priv->fw_state = TASDEVICE_DSP_FW_ALL_OK;
 647         tasdevice_prmg_load(tas_priv, 0);
 648         if (tas_priv->fmw->nr_programs > 0)
 649                 tas_priv->cur_prog = 0;
 650         if (tas_priv->fmw->nr_configurations > 0)
 651                 tas_priv->cur_conf = 0;
 652
 653         /* If calibrated data occurs error, dsp will still works with default
 654          * calibrated data inside algo.
 655          */
 656         tasdevice_save_calibration(tas_priv);
 657
 658         tasdevice_tuning_switch(tas_hda->priv, 0);
 659         tas_hda->priv->playback_started = true;
 660
 661 out:
 662         mutex_unlock(&tas_hda->priv->codec_lock);
 663         if (fmw)
 664                 release_firmware(fmw);
 665         pm_runtime_mark_last_busy(tas_hda->dev);
 666         pm_runtime_put_autosuspend(tas_hda->dev);
 667 }
 668
 669 static int tas2781_hda_bind(struct device *dev, struct device *master,
 670         void *master_data)
 671 {
 672         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 673         struct hda_component *comps = master_data;
 674         struct hda_codec *codec;
 675         unsigned int subid;
 676         int ret;
 677
 678         if (!comps || tas_hda->priv->index < 0 ||
 679                 tas_hda->priv->index >= HDA_MAX_COMPONENTS)
 680                 return -EINVAL;
 681
 682         comps = &comps[tas_hda->priv->index];
 683         if (comps->dev)
 684                 return -EBUSY;
 685
 686         codec = comps->codec;
 687         subid = codec->core.subsystem_id >> 16;
 688
 689         switch (subid) {
 690         case 0x17aa:
 691                 tas_hda->priv->catlog_id = LENOVO;
 692                 break;
 693         default:
 694                 tas_hda->priv->catlog_id = OTHERS;
 695                 break;
 696         }
 697
 698         pm_runtime_get_sync(dev);
 699
 700         comps->dev = dev;
 701
 702         strscpy(comps->name, dev_name(dev), sizeof(comps->name));
 703
 704         ret = tascodec_init(tas_hda->priv, codec, THIS_MODULE, tasdev_fw_ready);
 705         if (!ret)
 706                 comps->playback_hook = tas2781_hda_playback_hook;
 707
 708         pm_runtime_mark_last_busy(dev);
 709         pm_runtime_put_autosuspend(dev);
 710
 711         return ret;
 712 }
 713
 714 static void tas2781_hda_unbind(struct device *dev,
 715         struct device *master, void *master_data)
 716 {
 717         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 718         struct hda_component *comps = master_data;
 719         comps = &comps[tas_hda->priv->index];
 720
 721         if (comps->dev == dev) {
 722                 comps->dev = NULL;
 723                 memset(comps->name, 0, sizeof(comps->name));
 724                 comps->playback_hook = NULL;
 725         }
 726
 727         tas2781_hda_remove_controls(tas_hda);
 728
 729         tasdevice_config_info_remove(tas_hda->priv);
 730         tasdevice_dsp_remove(tas_hda->priv);
 731
 732         tas_hda->priv->fw_state = TASDEVICE_DSP_FW_PENDING;
 733 }
 734
 735 static const struct component_ops tas2781_hda_comp_ops = {
 736         .bind = tas2781_hda_bind,
 737         .unbind = tas2781_hda_unbind,
 738 };
 739
 740 static void tas2781_hda_remove(struct device *dev)
 741 {
 742         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 743
 744         pm_runtime_get_sync(tas_hda->dev);
 745         pm_runtime_disable(tas_hda->dev);
 746
 747         component_del(tas_hda->dev, &tas2781_hda_comp_ops);
 748
 749         pm_runtime_put_noidle(tas_hda->dev);
 750
 751         tasdevice_remove(tas_hda->priv);
 752 }
 753
 754 static int tas2781_hda_i2c_probe(struct i2c_client *clt)
 755 {
 756         struct tas2781_hda *tas_hda;
 757         const char *device_name;
 758         int ret;
 759
 760
 761         tas_hda = devm_kzalloc(&clt->dev, sizeof(*tas_hda), GFP_KERNEL);
 762         if (!tas_hda)
 763                 return -ENOMEM;
 764
 765         dev_set_drvdata(&clt->dev, tas_hda);
 766         tas_hda->dev = &clt->dev;
 767
 768         tas_hda->priv = tasdevice_kzalloc(clt);
 769         if (!tas_hda->priv)
 770                 return -ENOMEM;
 771
 772         if (strstr(dev_name(&clt->dev), "TIAS2781")) {
 773                 device_name = "TIAS2781";
 774                 tas_hda->priv->save_calibration = tas2781_save_calibration;
 775                 tas_hda->priv->apply_calibration = tas2781_apply_calib;
 776                 tas_hda->priv->global_addr = TAS2781_GLOBAL_ADDR;
 777         } else if (strstr(dev_name(&clt->dev), "INT8866")) {
 778                 device_name = "INT8866";
 779                 tas_hda->priv->save_calibration = tas2563_save_calibration;
 780                 tas_hda->priv->apply_calibration = tas2563_apply_calib;
 781                 tas_hda->priv->global_addr = TAS2563_GLOBAL_ADDR;
 782         } else
 783                 return -ENODEV;
 784
 785         tas_hda->priv->irq_info.irq = clt->irq;
 786         ret = tas2781_read_acpi(tas_hda->priv, device_name);
 787         if (ret)
 788                 return dev_err_probe(tas_hda->dev, ret,
 789                         "Platform not supported\n");
 790
 791         ret = tasdevice_init(tas_hda->priv);
 792         if (ret)
 793                 goto err;
 794
 795         pm_runtime_set_autosuspend_delay(tas_hda->dev, 3000);
 796         pm_runtime_use_autosuspend(tas_hda->dev);
 797         pm_runtime_mark_last_busy(tas_hda->dev);
 798         pm_runtime_set_active(tas_hda->dev);
 799         pm_runtime_enable(tas_hda->dev);
 800
 801         tas2781_reset(tas_hda->priv);
 802
 803         ret = component_add(tas_hda->dev, &tas2781_hda_comp_ops);
 804         if (ret) {
 805                 dev_err(tas_hda->dev, "Register component failed: %d\n", ret);
 806                 pm_runtime_disable(tas_hda->dev);
 807         }
 808
 809 err:
 810         if (ret)
 811                 tas2781_hda_remove(&clt->dev);
 812         return ret;
 813 }
 814
 815 static void tas2781_hda_i2c_remove(struct i2c_client *clt)
 816 {
 817         tas2781_hda_remove(&clt->dev);
 818 }
 819
 820 static int tas2781_runtime_suspend(struct device *dev)
 821 {
 822         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 823
 824         dev_dbg(tas_hda->dev, "Runtime Suspend\n");
 825
 826         mutex_lock(&tas_hda->priv->codec_lock);
 827
 828         /* The driver powers up the amplifiers at module load time.
 829          * Stop the playback if it's unused.
 830          */
 831         if (tas_hda->priv->playback_started) {
 832                 tasdevice_tuning_switch(tas_hda->priv, 1);
 833                 tas_hda->priv->playback_started = false;
 834         }
 835
 836         mutex_unlock(&tas_hda->priv->codec_lock);
 837
 838         return 0;
 839 }
 840
 841 static int tas2781_runtime_resume(struct device *dev)
 842 {
 843         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 844
 845         dev_dbg(tas_hda->dev, "Runtime Resume\n");
 846
 847         mutex_lock(&tas_hda->priv->codec_lock);
 848
 849         tasdevice_prmg_load(tas_hda->priv, tas_hda->priv->cur_prog);
 850
 851         /* If calibrated data occurs error, dsp will still works with default
 852          * calibrated data inside algo.
 853          */
 854         tasdevice_apply_calibration(tas_hda->priv);
 855
 856         mutex_unlock(&tas_hda->priv->codec_lock);
 857
 858         return 0;
 859 }
 860
 861 static int tas2781_system_suspend(struct device *dev)
 862 {
 863         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 864
 865         dev_dbg(tas_hda->priv->dev, "System Suspend\n");
 866
 867         mutex_lock(&tas_hda->priv->codec_lock);
 868
 869         /* Shutdown chip before system suspend */
 870         if (tas_hda->priv->playback_started)
 871                 tasdevice_tuning_switch(tas_hda->priv, 1);
 872
 873         mutex_unlock(&tas_hda->priv->codec_lock);
 874
 875         /*
 876          * Reset GPIO may be shared, so cannot reset here.
 877          * However beyond this point, amps may be powered down.
 878          */
 879         return 0;
 880 }
 881
 882 static int tas2781_system_resume(struct device *dev)
 883 {
 884         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 885         int i;
 886
 887         dev_dbg(tas_hda->priv->dev, "System Resume\n");
 888
 889         mutex_lock(&tas_hda->priv->codec_lock);
 890
 891         for (i = 0; i < tas_hda->priv->ndev; i++) {
 892                 tas_hda->priv->tasdevice[i].cur_book = -1;
 893                 tas_hda->priv->tasdevice[i].cur_prog = -1;
 894                 tas_hda->priv->tasdevice[i].cur_conf = -1;
 895         }
 896         tas2781_reset(tas_hda->priv);
 897         tasdevice_prmg_load(tas_hda->priv, tas_hda->priv->cur_prog);
 898
 899         /* If calibrated data occurs error, dsp will still work with default
 900          * calibrated data inside algo.
 901          */
 902         tasdevice_apply_calibration(tas_hda->priv);
 903
 904         if (tas_hda->priv->playback_started)
 905                 tasdevice_tuning_switch(tas_hda->priv, 0);
 906
 907         mutex_unlock(&tas_hda->priv->codec_lock);
 908
 909         return 0;
 910 }
 911
 912 static const struct dev_pm_ops tas2781_hda_pm_ops = {
 913         RUNTIME_PM_OPS(tas2781_runtime_suspend, tas2781_runtime_resume, NULL)
 914         SYSTEM_SLEEP_PM_OPS(tas2781_system_suspend, tas2781_system_resume)
 915 };
 916
 917 static const struct i2c_device_id tas2781_hda_i2c_id[] = {
 918         { "tas2781-hda", 0 },
 919         {}
 920 };
 921
 922 static const struct acpi_device_id tas2781_acpi_hda_match[] = {
 923         {"TIAS2781", 0 },
 924         {"INT8866", 0 },
 925         {}
 926 };
 927 MODULE_DEVICE_TABLE(acpi, tas2781_acpi_hda_match);
 928
 929 static struct i2c_driver tas2781_hda_i2c_driver = {
 930         .driver = {
 931                 .name           = "tas2781-hda",
 932                 .acpi_match_table = tas2781_acpi_hda_match,
 933                 .pm             = &tas2781_hda_pm_ops,
 934         },
 935         .id_table       = tas2781_hda_i2c_id,
 936         .probe          = tas2781_hda_i2c_probe,
 937         .remove         = tas2781_hda_i2c_remove,
 938 };
 939 module_i2c_driver(tas2781_hda_i2c_driver);
 940
 941 MODULE_DESCRIPTION("TAS2781 HDA Driver");
 942 MODULE_AUTHOR("Shenghao Ding, TI, <shenghao-ding@ti.com>");
 943 MODULE_LICENSE("GPL");
 944 MODULE_IMPORT_NS(SND_SOC_TAS2781_FMWLIB);