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