1 // SPDX-License-Identifier: GPL-2.0
3 // TAS2781 HDA I2C driver
5 // Copyright 2023 Texas Instruments, Inc.
7 // Author: Shenghao Ding <shenghao-ding@ti.com>
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>
25 #include "hda_local.h"
26 #include "hda_auto_parser.h"
27 #include "hda_component.h"
29 #include "hda_generic.h"
31 #define TASDEVICE_SPEAKER_CALIBRATION_SIZE 20
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.
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, \
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 }
68 static int tas2781_get_i2c_res(struct acpi_resource *ares, void *data)
70 struct tasdevice_priv *tas_priv = data;
71 struct acpi_resource_i2c_serialbus *sb;
73 if (i2c_acpi_get_i2c_resource(ares, &sb)) {
74 if (tas_priv->ndev < TASDEVICE_MAX_CHANNELS &&
75 sb->slave_address != TAS2781_GLOBAL_ADDR) {
76 tas_priv->tasdevice[tas_priv->ndev].dev_addr =
77 (unsigned int)sb->slave_address;
84 static int tas2781_read_acpi(struct tasdevice_priv *p, const char *hid)
86 struct acpi_device *adev;
87 struct device *physdev;
92 adev = acpi_dev_get_first_match_dev(hid, NULL, -1);
95 "Failed to find an ACPI device for %s\n", hid);
99 ret = acpi_dev_get_resources(adev, &resources, tas2781_get_i2c_res, p);
103 acpi_dev_free_resource_list(&resources);
104 strscpy(p->dev_name, hid, sizeof(p->dev_name));
105 physdev = get_device(acpi_get_first_physical_node(adev));
108 /* No side-effect to the playback even if subsystem_id is NULL*/
109 sub = acpi_get_subsystem_id(ACPI_HANDLE(physdev));
113 p->acpi_subsystem_id = sub;
120 dev_err(p->dev, "read acpi error, ret: %d\n", ret);
126 static void tas2781_hda_playback_hook(struct device *dev, int action)
128 struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
130 dev_dbg(tas_priv->dev, "%s: action = %d\n", __func__, action);
132 case HDA_GEN_PCM_ACT_OPEN:
133 pm_runtime_get_sync(dev);
134 mutex_lock(&tas_priv->codec_lock);
135 tasdevice_tuning_switch(tas_priv, 0);
136 mutex_unlock(&tas_priv->codec_lock);
138 case HDA_GEN_PCM_ACT_CLOSE:
139 mutex_lock(&tas_priv->codec_lock);
140 tasdevice_tuning_switch(tas_priv, 1);
141 mutex_unlock(&tas_priv->codec_lock);
143 pm_runtime_mark_last_busy(dev);
144 pm_runtime_put_autosuspend(dev);
147 dev_dbg(tas_priv->dev, "Playback action not supported: %d\n",
153 static int tasdevice_info_profile(struct snd_kcontrol *kcontrol,
154 struct snd_ctl_elem_info *uinfo)
156 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
158 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
160 uinfo->value.integer.min = 0;
161 uinfo->value.integer.max = tas_priv->rcabin.ncfgs - 1;
166 static int tasdevice_get_profile_id(struct snd_kcontrol *kcontrol,
167 struct snd_ctl_elem_value *ucontrol)
169 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
171 ucontrol->value.integer.value[0] = tas_priv->rcabin.profile_cfg_id;
176 static int tasdevice_set_profile_id(struct snd_kcontrol *kcontrol,
177 struct snd_ctl_elem_value *ucontrol)
179 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
180 int nr_profile = ucontrol->value.integer.value[0];
181 int max = tas_priv->rcabin.ncfgs - 1;
184 val = clamp(nr_profile, 0, max);
186 if (tas_priv->rcabin.profile_cfg_id != val) {
187 tas_priv->rcabin.profile_cfg_id = val;
194 static int tasdevice_info_programs(struct snd_kcontrol *kcontrol,
195 struct snd_ctl_elem_info *uinfo)
197 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
198 struct tasdevice_fw *tas_fw = tas_priv->fmw;
200 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
202 uinfo->value.integer.min = 0;
203 uinfo->value.integer.max = tas_fw->nr_programs - 1;
208 static int tasdevice_info_config(struct snd_kcontrol *kcontrol,
209 struct snd_ctl_elem_info *uinfo)
211 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
212 struct tasdevice_fw *tas_fw = tas_priv->fmw;
214 uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
216 uinfo->value.integer.min = 0;
217 uinfo->value.integer.max = tas_fw->nr_configurations - 1;
222 static int tasdevice_program_get(struct snd_kcontrol *kcontrol,
223 struct snd_ctl_elem_value *ucontrol)
225 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
227 ucontrol->value.integer.value[0] = tas_priv->cur_prog;
232 static int tasdevice_program_put(struct snd_kcontrol *kcontrol,
233 struct snd_ctl_elem_value *ucontrol)
235 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
236 struct tasdevice_fw *tas_fw = tas_priv->fmw;
237 int nr_program = ucontrol->value.integer.value[0];
238 int max = tas_fw->nr_programs - 1;
241 val = clamp(nr_program, 0, max);
243 if (tas_priv->cur_prog != val) {
244 tas_priv->cur_prog = val;
251 static int tasdevice_config_get(struct snd_kcontrol *kcontrol,
252 struct snd_ctl_elem_value *ucontrol)
254 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
256 ucontrol->value.integer.value[0] = tas_priv->cur_conf;
261 static int tasdevice_config_put(struct snd_kcontrol *kcontrol,
262 struct snd_ctl_elem_value *ucontrol)
264 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
265 struct tasdevice_fw *tas_fw = tas_priv->fmw;
266 int nr_config = ucontrol->value.integer.value[0];
267 int max = tas_fw->nr_configurations - 1;
270 val = clamp(nr_config, 0, max);
272 if (tas_priv->cur_conf != val) {
273 tas_priv->cur_conf = val;
281 * tas2781_digital_getvol - get the volum control
282 * @kcontrol: control pointer
283 * @ucontrol: User data
284 * Customer Kcontrol for tas2781 is primarily for regmap booking, paging
285 * depends on internal regmap mechanism.
286 * tas2781 contains book and page two-level register map, especially
287 * book switching will set the register BXXP00R7F, after switching to the
288 * correct book, then leverage the mechanism for paging to access the
291 static int tas2781_digital_getvol(struct snd_kcontrol *kcontrol,
292 struct snd_ctl_elem_value *ucontrol)
294 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
295 struct soc_mixer_control *mc =
296 (struct soc_mixer_control *)kcontrol->private_value;
298 return tasdevice_digital_getvol(tas_priv, ucontrol, mc);
301 static int tas2781_amp_getvol(struct snd_kcontrol *kcontrol,
302 struct snd_ctl_elem_value *ucontrol)
304 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
305 struct soc_mixer_control *mc =
306 (struct soc_mixer_control *)kcontrol->private_value;
308 return tasdevice_amp_getvol(tas_priv, ucontrol, mc);
311 static int tas2781_digital_putvol(struct snd_kcontrol *kcontrol,
312 struct snd_ctl_elem_value *ucontrol)
314 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
315 struct soc_mixer_control *mc =
316 (struct soc_mixer_control *)kcontrol->private_value;
318 /* The check of the given value is in tasdevice_digital_putvol. */
319 return tasdevice_digital_putvol(tas_priv, ucontrol, mc);
322 static int tas2781_amp_putvol(struct snd_kcontrol *kcontrol,
323 struct snd_ctl_elem_value *ucontrol)
325 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
326 struct soc_mixer_control *mc =
327 (struct soc_mixer_control *)kcontrol->private_value;
329 /* The check of the given value is in tasdevice_amp_putvol. */
330 return tasdevice_amp_putvol(tas_priv, ucontrol, mc);
333 static int tas2781_force_fwload_get(struct snd_kcontrol *kcontrol,
334 struct snd_ctl_elem_value *ucontrol)
336 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
338 ucontrol->value.integer.value[0] = (int)tas_priv->force_fwload_status;
339 dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__,
340 tas_priv->force_fwload_status ? "ON" : "OFF");
345 static int tas2781_force_fwload_put(struct snd_kcontrol *kcontrol,
346 struct snd_ctl_elem_value *ucontrol)
348 struct tasdevice_priv *tas_priv = snd_kcontrol_chip(kcontrol);
349 bool change, val = (bool)ucontrol->value.integer.value[0];
351 if (tas_priv->force_fwload_status == val)
355 tas_priv->force_fwload_status = val;
357 dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__,
358 tas_priv->force_fwload_status ? "ON" : "OFF");
363 static const struct snd_kcontrol_new tas2781_snd_controls[] = {
364 ACARD_SINGLE_RANGE_EXT_TLV("Speaker Analog Gain", TAS2781_AMP_LEVEL,
365 1, 0, 20, 0, tas2781_amp_getvol,
366 tas2781_amp_putvol, amp_vol_tlv),
367 ACARD_SINGLE_RANGE_EXT_TLV("Speaker Digital Gain", TAS2781_DVC_LVL,
368 0, 0, 200, 1, tas2781_digital_getvol,
369 tas2781_digital_putvol, dvc_tlv),
370 ACARD_SINGLE_BOOL_EXT("Speaker Force Firmware Load", 0,
371 tas2781_force_fwload_get, tas2781_force_fwload_put),
374 static const struct snd_kcontrol_new tas2781_prof_ctrl = {
375 .name = "Speaker Profile Id",
376 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
377 .info = tasdevice_info_profile,
378 .get = tasdevice_get_profile_id,
379 .put = tasdevice_set_profile_id,
382 static const struct snd_kcontrol_new tas2781_dsp_prog_ctrl = {
383 .name = "Speaker Program Id",
384 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
385 .info = tasdevice_info_programs,
386 .get = tasdevice_program_get,
387 .put = tasdevice_program_put,
390 static const struct snd_kcontrol_new tas2781_dsp_conf_ctrl = {
391 .name = "Speaker Config Id",
392 .iface = SNDRV_CTL_ELEM_IFACE_CARD,
393 .info = tasdevice_info_config,
394 .get = tasdevice_config_get,
395 .put = tasdevice_config_put,
398 static void tas2781_apply_calib(struct tasdevice_priv *tas_priv)
400 static const unsigned char page_array[CALIB_MAX] = {
401 0x17, 0x18, 0x18, 0x0d, 0x18
403 static const unsigned char rgno_array[CALIB_MAX] = {
404 0x74, 0x0c, 0x14, 0x3c, 0x7c
409 for (i = 0; i < tas_priv->ndev; i++) {
410 data = tas_priv->cali_data.data +
411 i * TASDEVICE_SPEAKER_CALIBRATION_SIZE;
412 for (j = 0; j < CALIB_MAX; j++) {
413 rc = tasdevice_dev_bulk_write(tas_priv, i,
414 TASDEVICE_REG(0, page_array[j], rgno_array[j]),
417 dev_err(tas_priv->dev,
418 "chn %d calib %d bulk_wr err = %d\n",
424 /* Update the calibrate data, including speaker impedance, f0, etc, into algo.
425 * Calibrate data is done by manufacturer in the factory. These data are used
426 * by Algo for calucating the speaker temperature, speaker membrance excursion
427 * and f0 in real time during playback.
429 static int tas2781_save_calibration(struct tasdevice_priv *tas_priv)
431 efi_guid_t efi_guid = EFI_GUID(0x02f9af02, 0x7734, 0x4233, 0xb4, 0x3d,
432 0x93, 0xfe, 0x5a, 0xa3, 0x5d, 0xb3);
433 static efi_char16_t efi_name[] = L"CALI_DATA";
434 struct tm *tm = &tas_priv->tm;
435 unsigned int attr, crc;
436 unsigned int *tmp_val;
440 if (tas_priv->catlog_id == LENOVO)
441 efi_guid = EFI_GUID(0x1f52d2a1, 0xbb3a, 0x457d, 0xbc, 0x09,
442 0x43, 0xa3, 0xf4, 0x31, 0x0a, 0x92);
444 tas_priv->cali_data.total_sz = 0;
445 /* Get real size of UEFI variable */
446 status = efi.get_variable(efi_name, &efi_guid, &attr,
447 &tas_priv->cali_data.total_sz, tas_priv->cali_data.data);
448 if (status == EFI_BUFFER_TOO_SMALL) {
449 /* Allocate data buffer of data_size bytes */
450 tas_priv->cali_data.data = devm_kzalloc(tas_priv->dev,
451 tas_priv->cali_data.total_sz, GFP_KERNEL);
452 if (!tas_priv->cali_data.data)
454 /* Get variable contents into buffer */
455 status = efi.get_variable(efi_name, &efi_guid, &attr,
456 &tas_priv->cali_data.total_sz,
457 tas_priv->cali_data.data);
459 if (status != EFI_SUCCESS)
462 tmp_val = (unsigned int *)tas_priv->cali_data.data;
464 crc = crc32(~0, tas_priv->cali_data.data, 84) ^ ~0;
465 dev_dbg(tas_priv->dev, "cali crc 0x%08x PK tmp_val 0x%08x\n",
468 if (crc == tmp_val[21]) {
469 time64_to_tm(tmp_val[20], 0, tm);
470 dev_dbg(tas_priv->dev, "%4ld-%2d-%2d, %2d:%2d:%2d\n",
471 tm->tm_year, tm->tm_mon, tm->tm_mday,
472 tm->tm_hour, tm->tm_min, tm->tm_sec);
473 tas2781_apply_calib(tas_priv);
475 tas_priv->cali_data.total_sz = 0;
480 static void tasdev_fw_ready(const struct firmware *fmw, void *context)
482 struct tasdevice_priv *tas_priv = context;
483 struct hda_codec *codec = tas_priv->codec;
486 pm_runtime_get_sync(tas_priv->dev);
487 mutex_lock(&tas_priv->codec_lock);
489 ret = tasdevice_rca_parser(tas_priv, fmw);
493 ret = snd_ctl_add(codec->card,
494 snd_ctl_new1(&tas2781_prof_ctrl, tas_priv));
496 dev_err(tas_priv->dev,
497 "Failed to add KControl %s = %d\n",
498 tas2781_prof_ctrl.name, ret);
502 for (i = 0; i < ARRAY_SIZE(tas2781_snd_controls); i++) {
503 ret = snd_ctl_add(codec->card,
504 snd_ctl_new1(&tas2781_snd_controls[i], tas_priv));
506 dev_err(tas_priv->dev,
507 "Failed to add KControl %s = %d\n",
508 tas2781_snd_controls[i].name, ret);
513 tasdevice_dsp_remove(tas_priv);
515 tas_priv->fw_state = TASDEVICE_DSP_FW_PENDING;
516 scnprintf(tas_priv->coef_binaryname, 64, "TAS2XXX%04X.bin",
517 codec->core.subsystem_id & 0xffff);
518 ret = tasdevice_dsp_parser(tas_priv);
520 dev_err(tas_priv->dev, "dspfw load %s error\n",
521 tas_priv->coef_binaryname);
522 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
526 ret = snd_ctl_add(codec->card,
527 snd_ctl_new1(&tas2781_dsp_prog_ctrl, tas_priv));
529 dev_err(tas_priv->dev,
530 "Failed to add KControl %s = %d\n",
531 tas2781_dsp_prog_ctrl.name, ret);
535 ret = snd_ctl_add(codec->card,
536 snd_ctl_new1(&tas2781_dsp_conf_ctrl, tas_priv));
538 dev_err(tas_priv->dev,
539 "Failed to add KControl %s = %d\n",
540 tas2781_dsp_conf_ctrl.name, ret);
544 tas_priv->fw_state = TASDEVICE_DSP_FW_ALL_OK;
545 tasdevice_prmg_load(tas_priv, 0);
547 /* If calibrated data occurs error, dsp will still works with default
548 * calibrated data inside algo.
550 tas2781_save_calibration(tas_priv);
553 mutex_unlock(&tas_priv->codec_lock);
555 release_firmware(fmw);
556 pm_runtime_mark_last_busy(tas_priv->dev);
557 pm_runtime_put_autosuspend(tas_priv->dev);
560 static int tas2781_hda_bind(struct device *dev, struct device *master,
563 struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
564 struct hda_component *comps = master_data;
565 struct hda_codec *codec;
569 if (!comps || tas_priv->index < 0 ||
570 tas_priv->index >= HDA_MAX_COMPONENTS)
573 comps = &comps[tas_priv->index];
577 codec = comps->codec;
578 subid = codec->core.subsystem_id >> 16;
582 tas_priv->catlog_id = LENOVO;
585 tas_priv->catlog_id = OTHERS;
589 pm_runtime_get_sync(dev);
593 strscpy(comps->name, dev_name(dev), sizeof(comps->name));
595 ret = tascodec_init(tas_priv, codec, tasdev_fw_ready);
597 comps->playback_hook = tas2781_hda_playback_hook;
599 pm_runtime_mark_last_busy(dev);
600 pm_runtime_put_autosuspend(dev);
605 static void tas2781_hda_unbind(struct device *dev,
606 struct device *master, void *master_data)
608 struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
609 struct hda_component *comps = master_data;
610 comps = &comps[tas_priv->index];
612 if (comps->dev == dev) {
614 memset(comps->name, 0, sizeof(comps->name));
615 comps->playback_hook = NULL;
618 tasdevice_config_info_remove(tas_priv);
619 tasdevice_dsp_remove(tas_priv);
621 tas_priv->fw_state = TASDEVICE_DSP_FW_PENDING;
624 static const struct component_ops tas2781_hda_comp_ops = {
625 .bind = tas2781_hda_bind,
626 .unbind = tas2781_hda_unbind,
629 static void tas2781_hda_remove(struct device *dev)
631 struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
633 pm_runtime_get_sync(tas_priv->dev);
634 pm_runtime_disable(tas_priv->dev);
636 component_del(tas_priv->dev, &tas2781_hda_comp_ops);
638 pm_runtime_put_noidle(tas_priv->dev);
640 tasdevice_remove(tas_priv);
643 static int tas2781_hda_i2c_probe(struct i2c_client *clt)
645 struct tasdevice_priv *tas_priv;
646 const char *device_name;
649 if (strstr(dev_name(&clt->dev), "TIAS2781"))
650 device_name = "TIAS2781";
654 tas_priv = tasdevice_kzalloc(clt);
658 tas_priv->irq_info.irq = clt->irq;
659 ret = tas2781_read_acpi(tas_priv, device_name);
661 return dev_err_probe(tas_priv->dev, ret,
662 "Platform not supported\n");
664 ret = tasdevice_init(tas_priv);
668 pm_runtime_set_autosuspend_delay(tas_priv->dev, 3000);
669 pm_runtime_use_autosuspend(tas_priv->dev);
670 pm_runtime_mark_last_busy(tas_priv->dev);
671 pm_runtime_set_active(tas_priv->dev);
672 pm_runtime_get_noresume(tas_priv->dev);
673 pm_runtime_enable(tas_priv->dev);
675 pm_runtime_put_autosuspend(tas_priv->dev);
677 tas2781_reset(tas_priv);
679 ret = component_add(tas_priv->dev, &tas2781_hda_comp_ops);
681 dev_err(tas_priv->dev, "Register component failed: %d\n", ret);
682 pm_runtime_disable(tas_priv->dev);
687 tas2781_hda_remove(&clt->dev);
691 static void tas2781_hda_i2c_remove(struct i2c_client *clt)
693 tas2781_hda_remove(&clt->dev);
696 static int tas2781_runtime_suspend(struct device *dev)
698 struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
701 dev_dbg(tas_priv->dev, "Runtime Suspend\n");
703 mutex_lock(&tas_priv->codec_lock);
705 if (tas_priv->playback_started) {
706 tasdevice_tuning_switch(tas_priv, 1);
707 tas_priv->playback_started = false;
710 for (i = 0; i < tas_priv->ndev; i++) {
711 tas_priv->tasdevice[i].cur_book = -1;
712 tas_priv->tasdevice[i].cur_prog = -1;
713 tas_priv->tasdevice[i].cur_conf = -1;
716 regcache_cache_only(tas_priv->regmap, true);
717 regcache_mark_dirty(tas_priv->regmap);
719 mutex_unlock(&tas_priv->codec_lock);
724 static int tas2781_runtime_resume(struct device *dev)
726 struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
727 unsigned long calib_data_sz =
728 tas_priv->ndev * TASDEVICE_SPEAKER_CALIBRATION_SIZE;
731 dev_dbg(tas_priv->dev, "Runtime Resume\n");
733 mutex_lock(&tas_priv->codec_lock);
735 regcache_cache_only(tas_priv->regmap, false);
736 ret = regcache_sync(tas_priv->regmap);
738 dev_err(tas_priv->dev,
739 "Failed to restore register cache: %d\n", ret);
743 tasdevice_prmg_load(tas_priv, tas_priv->cur_prog);
745 /* If calibrated data occurs error, dsp will still works with default
746 * calibrated data inside algo.
748 if (tas_priv->cali_data.total_sz > calib_data_sz)
749 tas2781_apply_calib(tas_priv);
752 mutex_unlock(&tas_priv->codec_lock);
757 static int tas2781_system_suspend(struct device *dev)
759 struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
762 dev_dbg(tas_priv->dev, "System Suspend\n");
764 ret = pm_runtime_force_suspend(dev);
768 /* Shutdown chip before system suspend */
769 regcache_cache_only(tas_priv->regmap, false);
770 tasdevice_tuning_switch(tas_priv, 1);
771 regcache_cache_only(tas_priv->regmap, true);
772 regcache_mark_dirty(tas_priv->regmap);
775 * Reset GPIO may be shared, so cannot reset here.
776 * However beyond this point, amps may be powered down.
781 static int tas2781_system_resume(struct device *dev)
783 struct tasdevice_priv *tas_priv = dev_get_drvdata(dev);
784 unsigned long calib_data_sz =
785 tas_priv->ndev * TASDEVICE_SPEAKER_CALIBRATION_SIZE;
788 dev_dbg(tas_priv->dev, "System Resume\n");
790 ret = pm_runtime_force_resume(dev);
794 mutex_lock(&tas_priv->codec_lock);
796 for (i = 0; i < tas_priv->ndev; i++) {
797 tas_priv->tasdevice[i].cur_book = -1;
798 tas_priv->tasdevice[i].cur_prog = -1;
799 tas_priv->tasdevice[i].cur_conf = -1;
801 tas2781_reset(tas_priv);
802 tasdevice_prmg_load(tas_priv, tas_priv->cur_prog);
804 /* If calibrated data occurs error, dsp will still work with default
805 * calibrated data inside algo.
807 if (tas_priv->cali_data.total_sz > calib_data_sz)
808 tas2781_apply_calib(tas_priv);
809 mutex_unlock(&tas_priv->codec_lock);
814 static const struct dev_pm_ops tas2781_hda_pm_ops = {
815 RUNTIME_PM_OPS(tas2781_runtime_suspend, tas2781_runtime_resume, NULL)
816 SYSTEM_SLEEP_PM_OPS(tas2781_system_suspend, tas2781_system_resume)
819 static const struct i2c_device_id tas2781_hda_i2c_id[] = {
820 { "tas2781-hda", 0 },
824 static const struct acpi_device_id tas2781_acpi_hda_match[] = {
828 MODULE_DEVICE_TABLE(acpi, tas2781_acpi_hda_match);
830 static struct i2c_driver tas2781_hda_i2c_driver = {
832 .name = "tas2781-hda",
833 .acpi_match_table = tas2781_acpi_hda_match,
834 .pm = &tas2781_hda_pm_ops,
836 .id_table = tas2781_hda_i2c_id,
837 .probe = tas2781_hda_i2c_probe,
838 .remove = tas2781_hda_i2c_remove,
840 module_i2c_driver(tas2781_hda_i2c_driver);
842 MODULE_DESCRIPTION("TAS2781 HDA Driver");
843 MODULE_AUTHOR("Shenghao Ding, TI, <shenghao-ding@ti.com>");
844 MODULE_LICENSE("GPL");
845 MODULE_IMPORT_NS(SND_SOC_TAS2781_FMWLIB);