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[2];
  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                 break;
 165         }
 166 }
 167
 168 static int tasdevice_info_profile(struct snd_kcontrol *kcontrol,
 169                         struct snd_ctl_elem_info *uinfo)
 170 {
 171         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 172
 173         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 174         uinfo->count = 1;
 175         uinfo->value.integer.min = 0;
 176         uinfo->value.integer.max = tas_priv->rcabin.ncfgs - 1;
 177
 178         return 0;
 179 }
 180
 181 static int tasdevice_get_profile_id(struct snd_kcontrol *kcontrol,
 182                         struct snd_ctl_elem_value *ucontrol)
 183 {
 184         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 185
 186         mutex_lock(&tas_priv->codec_lock);
 187
 188         ucontrol->value.integer.value[0] = tas_priv->rcabin.profile_cfg_id;
 189
 190         dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n",
 191                 __func__, kcontrol->id.name, tas_priv->rcabin.profile_cfg_id);
 192
 193         mutex_unlock(&tas_priv->codec_lock);
 194
 195         return 0;
 196 }
 197
 198 static int tasdevice_set_profile_id(struct snd_kcontrol *kcontrol,
 199                 struct snd_ctl_elem_value *ucontrol)
 200 {
 201         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 202         int nr_profile = ucontrol->value.integer.value[0];
 203         int max = tas_priv->rcabin.ncfgs - 1;
 204         int val, ret = 0;
 205
 206         val = clamp(nr_profile, 0, max);
 207
 208         mutex_lock(&tas_priv->codec_lock);
 209
 210         dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n",
 211                 __func__, kcontrol->id.name,
 212                 tas_priv->rcabin.profile_cfg_id, val);
 213
 214         if (tas_priv->rcabin.profile_cfg_id != val) {
 215                 tas_priv->rcabin.profile_cfg_id = val;
 216                 ret = 1;
 217         }
 218
 219         mutex_unlock(&tas_priv->codec_lock);
 220
 221         return ret;
 222 }
 223
 224 static int tasdevice_info_programs(struct snd_kcontrol *kcontrol,
 225                         struct snd_ctl_elem_info *uinfo)
 226 {
 227         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 228         struct tasdevice_fw *tas_fw = tas_priv->fmw;
 229
 230         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 231         uinfo->count = 1;
 232         uinfo->value.integer.min = 0;
 233         uinfo->value.integer.max = tas_fw->nr_programs - 1;
 234
 235         return 0;
 236 }
 237
 238 static int tasdevice_info_config(struct snd_kcontrol *kcontrol,
 239         struct snd_ctl_elem_info *uinfo)
 240 {
 241         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 242         struct tasdevice_fw *tas_fw = tas_priv->fmw;
 243
 244         uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
 245         uinfo->count = 1;
 246         uinfo->value.integer.min = 0;
 247         uinfo->value.integer.max = tas_fw->nr_configurations - 1;
 248
 249         return 0;
 250 }
 251
 252 static int tasdevice_program_get(struct snd_kcontrol *kcontrol,
 253         struct snd_ctl_elem_value *ucontrol)
 254 {
 255         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 256
 257         mutex_lock(&tas_priv->codec_lock);
 258
 259         ucontrol->value.integer.value[0] = tas_priv->cur_prog;
 260
 261         dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n",
 262                 __func__, kcontrol->id.name, tas_priv->cur_prog);
 263
 264         mutex_unlock(&tas_priv->codec_lock);
 265
 266         return 0;
 267 }
 268
 269 static int tasdevice_program_put(struct snd_kcontrol *kcontrol,
 270         struct snd_ctl_elem_value *ucontrol)
 271 {
 272         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 273         struct tasdevice_fw *tas_fw = tas_priv->fmw;
 274         int nr_program = ucontrol->value.integer.value[0];
 275         int max = tas_fw->nr_programs - 1;
 276         int val, ret = 0;
 277
 278         val = clamp(nr_program, 0, max);
 279
 280         mutex_lock(&tas_priv->codec_lock);
 281
 282         dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n",
 283                 __func__, kcontrol->id.name, tas_priv->cur_prog, val);
 284
 285         if (tas_priv->cur_prog != val) {
 286                 tas_priv->cur_prog = val;
 287                 ret = 1;
 288         }
 289
 290         mutex_unlock(&tas_priv->codec_lock);
 291
 292         return ret;
 293 }
 294
 295 static int tasdevice_config_get(struct snd_kcontrol *kcontrol,
 296         struct snd_ctl_elem_value *ucontrol)
 297 {
 298         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 299
 300         mutex_lock(&tas_priv->codec_lock);
 301
 302         ucontrol->value.integer.value[0] = tas_priv->cur_conf;
 303
 304         dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n",
 305                 __func__, kcontrol->id.name, tas_priv->cur_conf);
 306
 307         mutex_unlock(&tas_priv->codec_lock);
 308
 309         return 0;
 310 }
 311
 312 static int tasdevice_config_put(struct snd_kcontrol *kcontrol,
 313         struct snd_ctl_elem_value *ucontrol)
 314 {
 315         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 316         struct tasdevice_fw *tas_fw = tas_priv->fmw;
 317         int nr_config = ucontrol->value.integer.value[0];
 318         int max = tas_fw->nr_configurations - 1;
 319         int val, ret = 0;
 320
 321         val = clamp(nr_config, 0, max);
 322
 323         mutex_lock(&tas_priv->codec_lock);
 324
 325         dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n",
 326                 __func__, kcontrol->id.name, tas_priv->cur_conf, val);
 327
 328         if (tas_priv->cur_conf != val) {
 329                 tas_priv->cur_conf = val;
 330                 ret = 1;
 331         }
 332
 333         mutex_unlock(&tas_priv->codec_lock);
 334
 335         return ret;
 336 }
 337
 338 static int tas2781_amp_getvol(struct snd_kcontrol *kcontrol,
 339         struct snd_ctl_elem_value *ucontrol)
 340 {
 341         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 342         struct soc_mixer_control *mc =
 343                 (struct soc_mixer_control *)kcontrol->private_value;
 344         int ret;
 345
 346         mutex_lock(&tas_priv->codec_lock);
 347
 348         ret = tasdevice_amp_getvol(tas_priv, ucontrol, mc);
 349
 350         dev_dbg(tas_priv->dev, "%s: kcontrol %s: %ld\n",
 351                 __func__, kcontrol->id.name, ucontrol->value.integer.value[0]);
 352
 353         mutex_unlock(&tas_priv->codec_lock);
 354
 355         return ret;
 356 }
 357
 358 static int tas2781_amp_putvol(struct snd_kcontrol *kcontrol,
 359         struct snd_ctl_elem_value *ucontrol)
 360 {
 361         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 362         struct soc_mixer_control *mc =
 363                 (struct soc_mixer_control *)kcontrol->private_value;
 364         int ret;
 365
 366         mutex_lock(&tas_priv->codec_lock);
 367
 368         dev_dbg(tas_priv->dev, "%s: kcontrol %s: -> %ld\n",
 369                 __func__, kcontrol->id.name, ucontrol->value.integer.value[0]);
 370
 371         /* The check of the given value is in tasdevice_amp_putvol. */
 372         ret = tasdevice_amp_putvol(tas_priv, ucontrol, mc);
 373
 374         mutex_unlock(&tas_priv->codec_lock);
 375
 376         return ret;
 377 }
 378
 379 static int tas2781_force_fwload_get(struct snd_kcontrol *kcontrol,
 380         struct snd_ctl_elem_value *ucontrol)
 381 {
 382         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 383
 384         mutex_lock(&tas_priv->codec_lock);
 385
 386         ucontrol->value.integer.value[0] = (int)tas_priv->force_fwload_status;
 387         dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d\n",
 388                 __func__, kcontrol->id.name, tas_priv->force_fwload_status);
 389
 390         mutex_unlock(&tas_priv->codec_lock);
 391
 392         return 0;
 393 }
 394
 395 static int tas2781_force_fwload_put(struct snd_kcontrol *kcontrol,
 396         struct snd_ctl_elem_value *ucontrol)
 397 {
 398         struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
 399         bool change, val = (bool)ucontrol->value.integer.value[0];
 400
 401         mutex_lock(&tas_priv->codec_lock);
 402
 403         dev_dbg(tas_priv->dev, "%s: kcontrol %s: %d -> %d\n",
 404                 __func__, kcontrol->id.name,
 405                 tas_priv->force_fwload_status, val);
 406
 407         if (tas_priv->force_fwload_status == val)
 408                 change = false;
 409         else {
 410                 change = true;
 411                 tas_priv->force_fwload_status = val;
 412         }
 413
 414         mutex_unlock(&tas_priv->codec_lock);
 415
 416         return change;
 417 }
 418
 419 static const struct snd_kcontrol_new tas2781_snd_controls[] = {
 420         ACARD_SINGLE_RANGE_EXT_TLV("Speaker Analog Gain", TAS2781_AMP_LEVEL,
 421                 1, 0, 20, 0, tas2781_amp_getvol,
 422                 tas2781_amp_putvol, amp_vol_tlv),
 423         ACARD_SINGLE_BOOL_EXT("Speaker Force Firmware Load", 0,
 424                 tas2781_force_fwload_get, tas2781_force_fwload_put),
 425 };
 426
 427 static const struct snd_kcontrol_new tas2781_prof_ctrl = {
 428         .name = "Speaker Profile Id",
 429         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
 430         .info = tasdevice_info_profile,
 431         .get = tasdevice_get_profile_id,
 432         .put = tasdevice_set_profile_id,
 433 };
 434
 435 static const struct snd_kcontrol_new tas2781_dsp_prog_ctrl = {
 436         .name = "Speaker Program Id",
 437         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
 438         .info = tasdevice_info_programs,
 439         .get = tasdevice_program_get,
 440         .put = tasdevice_program_put,
 441 };
 442
 443 static const struct snd_kcontrol_new tas2781_dsp_conf_ctrl = {
 444         .name = "Speaker Config Id",
 445         .iface = SNDRV_CTL_ELEM_IFACE_CARD,
 446         .info = tasdevice_info_config,
 447         .get = tasdevice_config_get,
 448         .put = tasdevice_config_put,
 449 };
 450
 451 static void tas2563_apply_calib(struct tasdevice_priv *tas_priv)
 452 {
 453         int offset = 0;
 454         __be32 data;
 455         int ret;
 456
 457         for (int i = 0; i < tas_priv->ndev; i++) {
 458                 for (int j = 0; j < TAS2563_CAL_N; ++j) {
 459                         data = cpu_to_be32(
 460                                 *(uint32_t *)&tas_priv->cali_data.data[offset]);
 461                         ret = tasdevice_dev_bulk_write(tas_priv, i, cal_regs[j],
 462                                 (unsigned char *)&data, TAS2563_CAL_DATA_SIZE);
 463                         if (ret)
 464                                 dev_err(tas_priv->dev,
 465                                         "Error writing calib regs\n");
 466                         offset += TAS2563_CAL_DATA_SIZE;
 467                 }
 468         }
 469 }
 470
 471 static int tas2563_save_calibration(struct tasdevice_priv *tas_priv)
 472 {
 473         static efi_guid_t efi_guid = EFI_GUID(0x1f52d2a1, 0xbb3a, 0x457d, 0xbc,
 474                 0x09, 0x43, 0xa3, 0xf4, 0x31, 0x0a, 0x92);
 475
 476         static efi_char16_t *efi_vars[TAS2563_MAX_CHANNELS][TAS2563_CAL_N] = {
 477                 { L"Power_1", L"R0_1", L"InvR0_1", L"R0_Low_1", L"TLim_1" },
 478                 { L"Power_2", L"R0_2", L"InvR0_2", L"R0_Low_2", L"TLim_2" },
 479                 { L"Power_3", L"R0_3", L"InvR0_3", L"R0_Low_3", L"TLim_3" },
 480                 { L"Power_4", L"R0_4", L"InvR0_4", L"R0_Low_4", L"TLim_4" },
 481         };
 482
 483         unsigned long max_size = TAS2563_CAL_DATA_SIZE;
 484         unsigned int offset = 0;
 485         efi_status_t status;
 486         unsigned int attr;
 487
 488         tas_priv->cali_data.data = devm_kzalloc(tas_priv->dev,
 489                         TAS2563_CAL_ARRAY_SIZE, GFP_KERNEL);
 490         if (!tas_priv->cali_data.data)
 491                 return -ENOMEM;
 492
 493         for (int i = 0; i < tas_priv->ndev; ++i) {
 494                 for (int j = 0; j < TAS2563_CAL_N; ++j) {
 495                         status = efi.get_variable(efi_vars[i][j],
 496                                 &efi_guid, &attr, &max_size,
 497                                 &tas_priv->cali_data.data[offset]);
 498                         if (status != EFI_SUCCESS ||
 499                                 max_size != TAS2563_CAL_DATA_SIZE) {
 500                                 dev_warn(tas_priv->dev,
 501                                 "Calibration data read failed %ld\n", status);
 502                                 return -EINVAL;
 503                         }
 504                         offset += TAS2563_CAL_DATA_SIZE;
 505                 }
 506         }
 507
 508         tas_priv->cali_data.total_sz = offset;
 509         tasdevice_apply_calibration(tas_priv);
 510
 511         return 0;
 512 }
 513
 514 static void tas2781_apply_calib(struct tasdevice_priv *tas_priv)
 515 {
 516         static const unsigned char page_array[CALIB_MAX] = {
 517                 0x17, 0x18, 0x18, 0x13, 0x18,
 518         };
 519         static const unsigned char rgno_array[CALIB_MAX] = {
 520                 0x74, 0x0c, 0x14, 0x70, 0x7c,
 521         };
 522         unsigned char *data;
 523         int i, j, rc;
 524
 525         for (i = 0; i < tas_priv->ndev; i++) {
 526                 data = tas_priv->cali_data.data +
 527                         i * TASDEVICE_SPEAKER_CALIBRATION_SIZE;
 528                 for (j = 0; j < CALIB_MAX; j++) {
 529                         rc = tasdevice_dev_bulk_write(tas_priv, i,
 530                                 TASDEVICE_REG(0, page_array[j], rgno_array[j]),
 531                                 &(data[4 * j]), 4);
 532                         if (rc < 0)
 533                                 dev_err(tas_priv->dev,
 534                                         "chn %d calib %d bulk_wr err = %d\n",
 535                                         i, j, rc);
 536                 }
 537         }
 538 }
 539
 540 /* Update the calibration data, including speaker impedance, f0, etc, into algo.
 541  * Calibrate data is done by manufacturer in the factory. These data are used
 542  * by Algo for calculating the speaker temperature, speaker membrane excursion
 543  * and f0 in real time during playback.
 544  */
 545 static int tas2781_save_calibration(struct tasdevice_priv *tas_priv)
 546 {
 547         efi_guid_t efi_guid = EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d,
 548                 0x93, 0xfe, 0x5a, 0xa3, 0x5d, 0xb3);
 549         static efi_char16_t efi_name[] = L"CALI_DATA";
 550         struct tm *tm = &tas_priv->tm;
 551         unsigned int attr, crc;
 552         unsigned int *tmp_val;
 553         efi_status_t status;
 554
 555         /* Lenovo devices */
 556         if (tas_priv->catlog_id == LENOVO)
 557                 efi_guid = EFI_GUID(0x1f52d2a1, 0xbb3a, 0x457d, 0xbc, 0x09,
 558                         0x43, 0xa3, 0xf4, 0x31, 0x0a, 0x92);
 559
 560         tas_priv->cali_data.total_sz = 0;
 561         /* Get real size of UEFI variable */
 562         status = efi.get_variable(efi_name, &efi_guid, &attr,
 563                 &tas_priv->cali_data.total_sz, tas_priv->cali_data.data);
 564         if (status == EFI_BUFFER_TOO_SMALL) {
 565                 /* Allocate data buffer of data_size bytes */
 566                 tas_priv->cali_data.data = devm_kzalloc(tas_priv->dev,
 567                         tas_priv->cali_data.total_sz, GFP_KERNEL);
 568                 if (!tas_priv->cali_data.data)
 569                         return -ENOMEM;
 570                 /* Get variable contents into buffer */
 571                 status = efi.get_variable(efi_name, &efi_guid, &attr,
 572                         &tas_priv->cali_data.total_sz,
 573                         tas_priv->cali_data.data);
 574         }
 575         if (status != EFI_SUCCESS)
 576                 return -EINVAL;
 577
 578         tmp_val = (unsigned int *)tas_priv->cali_data.data;
 579
 580         crc = crc32(~0, tas_priv->cali_data.data, 84) ^ ~0;
 581         dev_dbg(tas_priv->dev, "cali crc 0x%08x PK tmp_val 0x%08x\n",
 582                 crc, tmp_val[21]);
 583
 584         if (crc == tmp_val[21]) {
 585                 time64_to_tm(tmp_val[20], 0, tm);
 586                 dev_dbg(tas_priv->dev, "%4ld-%2d-%2d, %2d:%2d:%2d\n",
 587                         tm->tm_year, tm->tm_mon, tm->tm_mday,
 588                         tm->tm_hour, tm->tm_min, tm->tm_sec);
 589                 tasdevice_apply_calibration(tas_priv);
 590         } else
 591                 tas_priv->cali_data.total_sz = 0;
 592
 593         return 0;
 594 }
 595
 596 static void tas2781_hda_remove_controls(struct tas2781_hda *tas_hda)
 597 {
 598         struct hda_codec *codec = tas_hda->priv->codec;
 599
 600         if (tas_hda->dsp_prog_ctl)
 601                 snd_ctl_remove(codec->card, tas_hda->dsp_prog_ctl);
 602
 603         if (tas_hda->dsp_conf_ctl)
 604                 snd_ctl_remove(codec->card, tas_hda->dsp_conf_ctl);
 605
 606         for (int i = ARRAY_SIZE(tas_hda->snd_ctls) - 1; i >= 0; i--)
 607                 if (tas_hda->snd_ctls[i])
 608                         snd_ctl_remove(codec->card, tas_hda->snd_ctls[i]);
 609
 610         if (tas_hda->prof_ctl)
 611                 snd_ctl_remove(codec->card, tas_hda->prof_ctl);
 612 }
 613
 614 static void tasdev_fw_ready(const struct firmware *fmw, void *context)
 615 {
 616         struct tasdevice_priv *tas_priv = context;
 617         struct tas2781_hda *tas_hda = dev_get_drvdata(tas_priv->dev);
 618         struct hda_codec *codec = tas_priv->codec;
 619         int i, ret;
 620
 621         pm_runtime_get_sync(tas_priv->dev);
 622         mutex_lock(&tas_priv->codec_lock);
 623
 624         ret = tasdevice_rca_parser(tas_priv, fmw);
 625         if (ret)
 626                 goto out;
 627
 628         tas_hda->prof_ctl = snd_ctl_new1(&tas2781_prof_ctrl, tas_priv);
 629         ret = snd_ctl_add(codec->card, tas_hda->prof_ctl);
 630         if (ret) {
 631                 dev_err(tas_priv->dev,
 632                         "Failed to add KControl %s = %d\n",
 633                         tas2781_prof_ctrl.name, ret);
 634                 goto out;
 635         }
 636
 637         for (i = 0; i < ARRAY_SIZE(tas2781_snd_controls); i++) {
 638                 tas_hda->snd_ctls[i] = snd_ctl_new1(&tas2781_snd_controls[i],
 639                         tas_priv);
 640                 ret = snd_ctl_add(codec->card, tas_hda->snd_ctls[i]);
 641                 if (ret) {
 642                         dev_err(tas_priv->dev,
 643                                 "Failed to add KControl %s = %d\n",
 644                                 tas2781_snd_controls[i].name, ret);
 645                         goto out;
 646                 }
 647         }
 648
 649         tasdevice_dsp_remove(tas_priv);
 650
 651         tas_priv->fw_state = TASDEVICE_DSP_FW_PENDING;
 652         scnprintf(tas_priv->coef_binaryname, 64, "TAS2XXX%04X.bin",
 653                 codec->core.subsystem_id & 0xffff);
 654         ret = tasdevice_dsp_parser(tas_priv);
 655         if (ret) {
 656                 dev_err(tas_priv->dev, "dspfw load %s error\n",
 657                         tas_priv->coef_binaryname);
 658                 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
 659                 goto out;
 660         }
 661
 662         tas_hda->dsp_prog_ctl = snd_ctl_new1(&tas2781_dsp_prog_ctrl,
 663                 tas_priv);
 664         ret = snd_ctl_add(codec->card, tas_hda->dsp_prog_ctl);
 665         if (ret) {
 666                 dev_err(tas_priv->dev,
 667                         "Failed to add KControl %s = %d\n",
 668                         tas2781_dsp_prog_ctrl.name, ret);
 669                 goto out;
 670         }
 671
 672         tas_hda->dsp_conf_ctl = snd_ctl_new1(&tas2781_dsp_conf_ctrl,
 673                 tas_priv);
 674         ret = snd_ctl_add(codec->card, tas_hda->dsp_conf_ctl);
 675         if (ret) {
 676                 dev_err(tas_priv->dev,
 677                         "Failed to add KControl %s = %d\n",
 678                         tas2781_dsp_conf_ctrl.name, ret);
 679                 goto out;
 680         }
 681
 682         tas_priv->fw_state = TASDEVICE_DSP_FW_ALL_OK;
 683         tasdevice_prmg_load(tas_priv, 0);
 684         if (tas_priv->fmw->nr_programs > 0)
 685                 tas_priv->cur_prog = 0;
 686         if (tas_priv->fmw->nr_configurations > 0)
 687                 tas_priv->cur_conf = 0;
 688
 689         /* If calibrated data occurs error, dsp will still works with default
 690          * calibrated data inside algo.
 691          */
 692         tasdevice_save_calibration(tas_priv);
 693
 694         tasdevice_tuning_switch(tas_hda->priv, 0);
 695         tas_hda->priv->playback_started = true;
 696
 697 out:
 698         mutex_unlock(&tas_hda->priv->codec_lock);
 699         if (fmw)
 700                 release_firmware(fmw);
 701         pm_runtime_mark_last_busy(tas_hda->dev);
 702         pm_runtime_put_autosuspend(tas_hda->dev);
 703 }
 704
 705 static int tas2781_hda_bind(struct device *dev, struct device *master,
 706         void *master_data)
 707 {
 708         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 709         struct hda_component *comps = master_data;
 710         struct hda_codec *codec;
 711         unsigned int subid;
 712         int ret;
 713
 714         if (!comps || tas_hda->priv->index < 0 ||
 715                 tas_hda->priv->index >= HDA_MAX_COMPONENTS)
 716                 return -EINVAL;
 717
 718         comps = &comps[tas_hda->priv->index];
 719         if (comps->dev)
 720                 return -EBUSY;
 721
 722         codec = comps->codec;
 723         subid = codec->core.subsystem_id >> 16;
 724
 725         switch (subid) {
 726         case 0x17aa:
 727                 tas_hda->priv->catlog_id = LENOVO;
 728                 break;
 729         default:
 730                 tas_hda->priv->catlog_id = OTHERS;
 731                 break;
 732         }
 733
 734         pm_runtime_get_sync(dev);
 735
 736         comps->dev = dev;
 737
 738         strscpy(comps->name, dev_name(dev), sizeof(comps->name));
 739
 740         ret = tascodec_init(tas_hda->priv, codec, THIS_MODULE, tasdev_fw_ready);
 741         if (!ret)
 742                 comps->playback_hook = tas2781_hda_playback_hook;
 743
 744         pm_runtime_mark_last_busy(dev);
 745         pm_runtime_put_autosuspend(dev);
 746
 747         return ret;
 748 }
 749
 750 static void tas2781_hda_unbind(struct device *dev,
 751         struct device *master, void *master_data)
 752 {
 753         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 754         struct hda_component *comps = master_data;
 755         comps = &comps[tas_hda->priv->index];
 756
 757         if (comps->dev == dev) {
 758                 comps->dev = NULL;
 759                 memset(comps->name, 0, sizeof(comps->name));
 760                 comps->playback_hook = NULL;
 761         }
 762
 763         tas2781_hda_remove_controls(tas_hda);
 764
 765         tasdevice_config_info_remove(tas_hda->priv);
 766         tasdevice_dsp_remove(tas_hda->priv);
 767
 768         tas_hda->priv->fw_state = TASDEVICE_DSP_FW_PENDING;
 769 }
 770
 771 static const struct component_ops tas2781_hda_comp_ops = {
 772         .bind = tas2781_hda_bind,
 773         .unbind = tas2781_hda_unbind,
 774 };
 775
 776 static void tas2781_hda_remove(struct device *dev)
 777 {
 778         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 779
 780         pm_runtime_get_sync(tas_hda->dev);
 781         pm_runtime_disable(tas_hda->dev);
 782
 783         component_del(tas_hda->dev, &tas2781_hda_comp_ops);
 784
 785         pm_runtime_put_noidle(tas_hda->dev);
 786
 787         tasdevice_remove(tas_hda->priv);
 788 }
 789
 790 static int tas2781_hda_i2c_probe(struct i2c_client *clt)
 791 {
 792         struct tas2781_hda *tas_hda;
 793         const char *device_name;
 794         int ret;
 795
 796
 797         tas_hda = devm_kzalloc(&clt->dev, sizeof(*tas_hda), GFP_KERNEL);
 798         if (!tas_hda)
 799                 return -ENOMEM;
 800
 801         dev_set_drvdata(&clt->dev, tas_hda);
 802         tas_hda->dev = &clt->dev;
 803
 804         tas_hda->priv = tasdevice_kzalloc(clt);
 805         if (!tas_hda->priv)
 806                 return -ENOMEM;
 807
 808         if (strstr(dev_name(&clt->dev), "TIAS2781")) {
 809                 device_name = "TIAS2781";
 810                 tas_hda->priv->save_calibration = tas2781_save_calibration;
 811                 tas_hda->priv->apply_calibration = tas2781_apply_calib;
 812                 tas_hda->priv->global_addr = TAS2781_GLOBAL_ADDR;
 813         } else if (strstr(dev_name(&clt->dev), "INT8866")) {
 814                 device_name = "INT8866";
 815                 tas_hda->priv->save_calibration = tas2563_save_calibration;
 816                 tas_hda->priv->apply_calibration = tas2563_apply_calib;
 817                 tas_hda->priv->global_addr = TAS2563_GLOBAL_ADDR;
 818         } else
 819                 return -ENODEV;
 820
 821         tas_hda->priv->irq_info.irq = clt->irq;
 822         ret = tas2781_read_acpi(tas_hda->priv, device_name);
 823         if (ret)
 824                 return dev_err_probe(tas_hda->dev, ret,
 825                         "Platform not supported\n");
 826
 827         ret = tasdevice_init(tas_hda->priv);
 828         if (ret)
 829                 goto err;
 830
 831         pm_runtime_set_autosuspend_delay(tas_hda->dev, 3000);
 832         pm_runtime_use_autosuspend(tas_hda->dev);
 833         pm_runtime_mark_last_busy(tas_hda->dev);
 834         pm_runtime_set_active(tas_hda->dev);
 835         pm_runtime_enable(tas_hda->dev);
 836
 837         tas2781_reset(tas_hda->priv);
 838
 839         ret = component_add(tas_hda->dev, &tas2781_hda_comp_ops);
 840         if (ret) {
 841                 dev_err(tas_hda->dev, "Register component failed: %d\n", ret);
 842                 pm_runtime_disable(tas_hda->dev);
 843         }
 844
 845 err:
 846         if (ret)
 847                 tas2781_hda_remove(&clt->dev);
 848         return ret;
 849 }
 850
 851 static void tas2781_hda_i2c_remove(struct i2c_client *clt)
 852 {
 853         tas2781_hda_remove(&clt->dev);
 854 }
 855
 856 static int tas2781_runtime_suspend(struct device *dev)
 857 {
 858         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 859
 860         dev_dbg(tas_hda->dev, "Runtime Suspend\n");
 861
 862         mutex_lock(&tas_hda->priv->codec_lock);
 863
 864         /* The driver powers up the amplifiers at module load time.
 865          * Stop the playback if it's unused.
 866          */
 867         if (tas_hda->priv->playback_started) {
 868                 tasdevice_tuning_switch(tas_hda->priv, 1);
 869                 tas_hda->priv->playback_started = false;
 870         }
 871
 872         mutex_unlock(&tas_hda->priv->codec_lock);
 873
 874         return 0;
 875 }
 876
 877 static int tas2781_runtime_resume(struct device *dev)
 878 {
 879         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 880
 881         dev_dbg(tas_hda->dev, "Runtime Resume\n");
 882
 883         mutex_lock(&tas_hda->priv->codec_lock);
 884
 885         tasdevice_prmg_load(tas_hda->priv, tas_hda->priv->cur_prog);
 886
 887         /* If calibrated data occurs error, dsp will still works with default
 888          * calibrated data inside algo.
 889          */
 890         tasdevice_apply_calibration(tas_hda->priv);
 891
 892         mutex_unlock(&tas_hda->priv->codec_lock);
 893
 894         return 0;
 895 }
 896
 897 static int tas2781_system_suspend(struct device *dev)
 898 {
 899         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 900
 901         dev_dbg(tas_hda->priv->dev, "System Suspend\n");
 902
 903         mutex_lock(&tas_hda->priv->codec_lock);
 904
 905         /* Shutdown chip before system suspend */
 906         if (tas_hda->priv->playback_started)
 907                 tasdevice_tuning_switch(tas_hda->priv, 1);
 908
 909         mutex_unlock(&tas_hda->priv->codec_lock);
 910
 911         /*
 912          * Reset GPIO may be shared, so cannot reset here.
 913          * However beyond this point, amps may be powered down.
 914          */
 915         return 0;
 916 }
 917
 918 static int tas2781_system_resume(struct device *dev)
 919 {
 920         struct tas2781_hda *tas_hda = dev_get_drvdata(dev);
 921         int i;
 922
 923         dev_dbg(tas_hda->priv->dev, "System Resume\n");
 924
 925         mutex_lock(&tas_hda->priv->codec_lock);
 926
 927         for (i = 0; i < tas_hda->priv->ndev; i++) {
 928                 tas_hda->priv->tasdevice[i].cur_book = -1;
 929                 tas_hda->priv->tasdevice[i].cur_prog = -1;
 930                 tas_hda->priv->tasdevice[i].cur_conf = -1;
 931         }
 932         tas2781_reset(tas_hda->priv);
 933         tasdevice_prmg_load(tas_hda->priv, tas_hda->priv->cur_prog);
 934
 935         /* If calibrated data occurs error, dsp will still work with default
 936          * calibrated data inside algo.
 937          */
 938         tasdevice_apply_calibration(tas_hda->priv);
 939
 940         if (tas_hda->priv->playback_started)
 941                 tasdevice_tuning_switch(tas_hda->priv, 0);
 942
 943         mutex_unlock(&tas_hda->priv->codec_lock);
 944
 945         return 0;
 946 }
 947
 948 static const struct dev_pm_ops tas2781_hda_pm_ops = {
 949         RUNTIME_PM_OPS(tas2781_runtime_suspend, tas2781_runtime_resume, NULL)
 950         SYSTEM_SLEEP_PM_OPS(tas2781_system_suspend, tas2781_system_resume)
 951 };
 952
 953 static const struct i2c_device_id tas2781_hda_i2c_id[] = {
 954         { "tas2781-hda", 0 },
 955         {}
 956 };
 957
 958 static const struct acpi_device_id tas2781_acpi_hda_match[] = {
 959         {"TIAS2781", 0 },
 960         {"INT8866", 0 },
 961         {}
 962 };
 963 MODULE_DEVICE_TABLE(acpi, tas2781_acpi_hda_match);
 964
 965 static struct i2c_driver tas2781_hda_i2c_driver = {
 966         .driver = {
 967                 .name           = "tas2781-hda",
 968                 .acpi_match_table = tas2781_acpi_hda_match,
 969                 .pm             = &tas2781_hda_pm_ops,
 970         },
 971         .id_table       = tas2781_hda_i2c_id,
 972         .probe          = tas2781_hda_i2c_probe,
 973         .remove         = tas2781_hda_i2c_remove,
 974 };
 975 module_i2c_driver(tas2781_hda_i2c_driver);
 976
 977 MODULE_DESCRIPTION("TAS2781 HDA Driver");
 978 MODULE_AUTHOR("Shenghao Ding, TI, <shenghao-ding@ti.com>");
 979 MODULE_LICENSE("GPL");
 980 MODULE_IMPORT_NS(SND_SOC_TAS2781_FMWLIB);