Lines Matching +full:codec +full:- +full:reset
1 // SPDX-License-Identifier: GPL-2.0
5 // Copyright 2024 - 2025 Texas Instruments, Inc.
32 #include <sound/tas2781-tlv.h>
48 /* System Reset Check Register */
73 .reg_shift = -1,
100 dev_err(tas_priv->dev, "%s, E=%d\n", __func__, ret);
126 dev_err(tas_priv->dev, "%s, E=%d\n", __func__, ret);
143 dev_err(tas_priv->dev, "%s, E=%d\n", __func__, ret);
150 dev_err(tas_priv->dev, "%s, E=%d\n", __func__, ret);
160 if (chn == p->index) {
161 struct tasdevice *tasdev = &p->tasdevice[chn];
162 struct regmap *map = p->regmap;
164 if (tasdev->cur_book != book) {
167 dev_err(p->dev, "%s, E=%d\n", __func__, ret);
169 tasdev->cur_book = book;
172 ret = -EXDEV;
173 dev_dbg(p->dev, "Not error, %s ignore channel(%d)\n",
184 if (tas_dev->reset) {
185 gpiod_set_value_cansleep(tas_dev->reset, 0);
187 gpiod_set_value_cansleep(tas_dev->reset, 1);
189 ret = tasdevice_dev_write(tas_dev, tas_dev->index,
192 dev_err(tas_dev->dev, "dev sw-reset fail, %d\n", ret);
200 void *codec, struct module *module,
206 * Codec Lock Hold to ensure that codec_probe and firmware parsing and
209 guard(mutex)(&tas_priv->codec_lock);
211 scnprintf(tas_priv->rca_binaryname,
212 sizeof(tas_priv->rca_binaryname), "%sRCA%d.bin",
213 tas_priv->dev_name, tas_priv->ndev);
214 crc8_populate_msb(tas_priv->crc8_lkp_tbl, TASDEVICE_CRC8_POLYNOMIAL);
215 tas_priv->codec = codec;
217 tas_priv->rca_binaryname, tas_priv->dev, GFP_KERNEL, tas_priv,
220 dev_err(tas_priv->dev, "request_firmware_nowait err:0x%08x\n",
228 tas_priv->tasdevice[tas_priv->index].cur_book = -1;
229 tas_priv->tasdevice[tas_priv->index].cur_conf = -1;
230 tas_priv->tasdevice[tas_priv->index].cur_prog = -1;
232 tas_priv->isspi = true;
234 tas_priv->update_bits = tasdevice_spi_dev_update_bits;
235 tas_priv->change_chn_book = tasdevice_spi_change_chn_book;
236 tas_priv->dev_read = tasdevice_spi_dev_read;
237 tas_priv->dev_bulk_read = tasdevice_spi_dev_bulk_read;
239 mutex_init(&tas_priv->codec_lock);
245 unsigned int invert = mc->invert;
247 int max = mc->max;
251 mask <<= mc->shift;
252 val = clamp(invert ? max - ucontrol->value.integer.value[0] :
253 ucontrol->value.integer.value[0], 0, max);
255 ret = tasdevice_spi_dev_update_bits(tas_priv, tas_priv->index,
256 mc->reg, mask, (unsigned int)(val << mc->shift));
258 dev_err(tas_priv->dev, "set AMP vol error in dev %d\n",
259 tas_priv->index);
267 unsigned int invert = mc->invert;
269 int max = mc->max;
272 ret = tasdevice_spi_dev_read(tas_priv, tas_priv->index, mc->reg, &val);
274 dev_err(tas_priv->dev, "%s, get AMP vol error\n", __func__);
279 mask <<= mc->shift;
280 val = (val & mask) >> mc->shift;
281 val = clamp(invert ? max - val : val, 0, max);
282 ucontrol->value.integer.value[0] = val;
290 unsigned int invert = mc->invert;
291 int max = mc->max;
294 val = clamp(invert ? max - ucontrol->value.integer.value[0] :
295 ucontrol->value.integer.value[0], 0, max);
296 ret = tasdevice_dev_write(p, p->index, mc->reg, (unsigned int)val);
298 dev_err(p->dev, "set digital vol err in dev %d\n", p->index);
306 unsigned int invert = mc->invert;
307 int max = mc->max;
310 ret = tasdevice_spi_dev_read(p, p->index, mc->reg, &val);
312 dev_err(p->dev, "%s, get digital vol err\n", __func__);
316 val = clamp(invert ? max - val : val, 0, max);
317 ucontrol->value.integer.value[0] = val;
325 struct tasdevice_priv *p = tas_hda->priv;
333 adev = acpi_dev_get_first_match_dev(hid, NULL, -1);
335 dev_err(p->dev, "Failed to find ACPI device: %s\n", hid);
336 return -ENODEV;
339 strscpy(p->dev_name, hid, sizeof(p->dev_name));
343 property = "ti,dev-index";
346 ret = -EINVAL;
349 p->ndev = nval = ret;
355 p->index = U8_MAX;
358 p->index = i;
362 if (p->index == U8_MAX) {
363 dev_dbg(p->dev, "No index found in %s\n", property);
364 ret = -ENODEV;
368 if (p->index == 0) {
369 /* All of amps share same RESET pin. */
370 p->reset = devm_gpiod_get_index_optional(physdev, "reset",
371 p->index, GPIOD_OUT_LOW);
372 if (IS_ERR(p->reset)) {
373 ret = PTR_ERR(p->reset);
374 dev_err_probe(p->dev, ret, "Failed on reset GPIO\n");
382 dev_err(p->dev, "read acpi error, ret: %d\n", ret);
392 struct tasdevice_priv *tas_priv = tas_hda->priv;
396 guard(mutex)(&tas_priv->codec_lock);
397 if (tas_priv->fw_state == TASDEVICE_DSP_FW_ALL_OK)
398 tasdevice_tuning_switch(tas_hda->priv, 0);
400 guard(mutex)(&tas_priv->codec_lock);
401 if (tas_priv->fw_state == TASDEVICE_DSP_FW_ALL_OK)
408 * tas2781_digital_getvol - get the volum control
414 * tas2781 contains book and page two-level register map, especially
426 (struct soc_mixer_control *)kcontrol->private_value;
428 guard(mutex)(&tas_priv->codec_lock);
437 (struct soc_mixer_control *)kcontrol->private_value;
439 guard(mutex)(&tas_priv->codec_lock);
448 (struct soc_mixer_control *)kcontrol->private_value;
450 guard(mutex)(&tas_priv->codec_lock);
459 (struct soc_mixer_control *)kcontrol->private_value;
461 guard(mutex)(&tas_priv->codec_lock);
470 ucontrol->value.integer.value[0] = (int)tas_priv->force_fwload_status;
471 dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__,
472 str_on_off(tas_priv->force_fwload_status));
481 bool change, val = (bool)ucontrol->value.integer.value[0];
483 if (tas_priv->force_fwload_status == val) {
487 tas_priv->force_fwload_status = val;
489 dev_dbg(tas_priv->dev, "%s : Force FWload %s\n", __func__,
490 str_on_off(tas_priv->force_fwload_status));
532 struct hda_codec *codec = tas_hda->priv->codec;
533 struct tas2781_hda_spi_priv *h_priv = tas_hda->hda_priv;
535 snd_ctl_remove(codec->card, tas_hda->dsp_prog_ctl);
537 snd_ctl_remove(codec->card, tas_hda->dsp_conf_ctl);
539 for (int i = ARRAY_SIZE(h_priv->snd_ctls) - 1; i >= 0; i--)
540 snd_ctl_remove(codec->card, h_priv->snd_ctls[i]);
542 snd_ctl_remove(codec->card, tas_hda->prof_ctl);
547 struct tasdevice_priv *p = h->priv;
548 struct hda_codec *c = p->codec;
552 snprintf(name, sizeof(name), "Speaker-%d Profile Id", p->index);
554 h->prof_ctl = snd_ctl_new1(&tas2781_prof_ctl, p);
555 rc = snd_ctl_add(c->card, h->prof_ctl);
557 dev_err(p->dev, "Failed to add KControl: %s, rc = %d\n",
564 struct tas2781_hda_spi_priv *h_priv = h->hda_priv;
565 struct tasdevice_priv *p = h->priv;
566 struct hda_codec *c = p->codec;
571 snprintf(name, sizeof(name), "Speaker-%d Analog Volume", p->index);
573 h_priv->snd_ctls[i] = snd_ctl_new1(&tas2781_snd_ctls[i], p);
574 rc = snd_ctl_add(c->card, h_priv->snd_ctls[i]);
576 dev_err(p->dev, "Failed to add KControl: %s, rc = %d\n",
581 snprintf(name, sizeof(name), "Speaker-%d Digital Volume", p->index);
583 h_priv->snd_ctls[i] = snd_ctl_new1(&tas2781_snd_ctls[i], p);
584 rc = snd_ctl_add(c->card, h_priv->snd_ctls[i]);
586 dev_err(p->dev, "Failed to add KControl: %s, rc = %d\n",
591 snprintf(name, sizeof(name), "Froce Speaker-%d FW Load", p->index);
593 h_priv->snd_ctls[i] = snd_ctl_new1(&tas2781_snd_ctls[i], p);
594 rc = snd_ctl_add(c->card, h_priv->snd_ctls[i]);
596 dev_err(p->dev, "Failed to add KControl: %s, rc = %d\n",
604 struct tasdevice_priv *p = h->priv;
605 struct hda_codec *c = p->codec;
610 snprintf(name, sizeof(name), "Speaker-%d Program Id", p->index);
612 h->dsp_prog_ctl = snd_ctl_new1(&tas2781_dsp_ctls[i], p);
613 rc = snd_ctl_add(c->card, h->dsp_prog_ctl);
615 dev_err(p->dev, "Failed to add KControl: %s, rc = %d\n",
620 snprintf(name, sizeof(name), "Speaker-%d Config Id", p->index);
622 h->dsp_conf_ctl = snd_ctl_new1(&tas2781_dsp_ctls[i], p);
623 rc = snd_ctl_add(c->card, h->dsp_conf_ctl);
625 dev_err(p->dev, "Failed to add KControl: %s, rc = %d\n",
635 struct tas2781_hda *tas_hda = dev_get_drvdata(tas_priv->dev);
636 struct hda_codec *codec = tas_priv->codec;
639 pm_runtime_get_sync(tas_priv->dev);
640 guard(mutex)(&tas_priv->codec_lock);
657 tas_priv->fw_state = TASDEVICE_DSP_FW_PENDING;
658 scnprintf(tas_priv->coef_binaryname, 64, "TAS2XXX%04X-%01d.bin",
659 lower_16_bits(codec->core.subsystem_id), tas_priv->index);
662 dev_err(tas_priv->dev, "dspfw load %s error\n",
663 tas_priv->coef_binaryname);
664 tas_priv->fw_state = TASDEVICE_DSP_FW_FAIL;
671 /* Perform AMP reset before firmware download. */
673 tas_priv->rcabin.profile_cfg_id = 0;
675 tas_priv->fw_state = TASDEVICE_DSP_FW_ALL_OK;
676 ret = tasdevice_spi_dev_read(tas_priv, tas_priv->index,
684 dev_err(tas_priv->dev, "FW download failed = %d\n",
688 tas_priv->fw_state = TASDEVICE_DSP_FW_ALL_OK;
690 if (tas_priv->fmw->nr_programs > 0)
691 tas_priv->tasdevice[tas_priv->index].cur_prog = 0;
692 if (tas_priv->fmw->nr_configurations > 0)
693 tas_priv->tasdevice[tas_priv->index].cur_conf = 0;
702 pm_runtime_put_autosuspend(tas_hda->priv->dev);
711 struct hda_codec *codec;
714 comp = hda_component_from_index(parent, tas_hda->priv->index);
716 return -EINVAL;
718 if (comp->dev)
719 return -EBUSY;
721 codec = parent->codec;
725 comp->dev = dev;
727 strscpy(comp->name, dev_name(dev), sizeof(comp->name));
729 ret = tascodec_spi_init(tas_hda->priv, codec, THIS_MODULE,
732 comp->playback_hook = tas2781_hda_playback_hook;
744 struct tasdevice_priv *tas_priv = tas_hda->priv;
747 comp = hda_component_from_index(parent, tas_priv->index);
748 if (comp && (comp->dev == dev)) {
749 comp->dev = NULL;
750 memset(comp->name, 0, sizeof(comp->name));
751 comp->playback_hook = NULL;
759 tas_hda->priv->fw_state = TASDEVICE_DSP_FW_PENDING;
775 tas_hda = devm_kzalloc(&spi->dev, sizeof(*tas_hda), GFP_KERNEL);
777 return -ENOMEM;
779 hda_priv = devm_kzalloc(&spi->dev, sizeof(*hda_priv), GFP_KERNEL);
781 return -ENOMEM;
783 tas_hda->hda_priv = hda_priv;
784 spi->max_speed_hz = TAS2781_SPI_MAX_FREQ;
786 tas_priv = devm_kzalloc(&spi->dev, sizeof(*tas_priv), GFP_KERNEL);
788 return -ENOMEM;
789 tas_priv->dev = &spi->dev;
790 tas_hda->priv = tas_priv;
791 tas_priv->regmap = devm_regmap_init_spi(spi, &tasdevice_regmap);
792 if (IS_ERR(tas_priv->regmap)) {
793 ret = PTR_ERR(tas_priv->regmap);
794 dev_err(tas_priv->dev, "Failed to allocate regmap: %d\n",
798 if (strstr(dev_name(&spi->dev), "TXNW2781")) {
801 dev_err(tas_priv->dev, "Unmatched spi dev %s\n",
802 dev_name(&spi->dev));
803 return -ENODEV;
806 tas_priv->irq = spi->irq;
807 dev_set_drvdata(&spi->dev, tas_hda);
811 return dev_err_probe(tas_priv->dev, ret,
816 pm_runtime_set_autosuspend_delay(tas_priv->dev, 3000);
817 pm_runtime_use_autosuspend(tas_priv->dev);
818 pm_runtime_set_active(tas_priv->dev);
819 pm_runtime_get_noresume(tas_priv->dev);
820 pm_runtime_enable(tas_priv->dev);
822 pm_runtime_put_autosuspend(tas_priv->dev);
824 ret = component_add(tas_priv->dev, &tas2781_hda_comp_ops);
826 dev_err(tas_priv->dev, "Register component fail: %d\n", ret);
827 pm_runtime_disable(tas_priv->dev);
828 tas2781_hda_remove(&spi->dev, &tas2781_hda_comp_ops);
836 tas2781_hda_remove(&spi->dev, &tas2781_hda_comp_ops);
842 struct tasdevice_priv *tas_priv = tas_hda->priv;
844 guard(mutex)(&tas_priv->codec_lock);
846 if (tas_priv->fw_state == TASDEVICE_DSP_FW_ALL_OK
847 && tas_priv->playback_started)
850 tas_priv->tasdevice[tas_priv->index].cur_book = -1;
851 tas_priv->tasdevice[tas_priv->index].cur_conf = -1;
859 struct tasdevice_priv *tas_priv = tas_hda->priv;
861 guard(mutex)(&tas_priv->codec_lock);
863 if (tas_priv->fw_state == TASDEVICE_DSP_FW_ALL_OK
864 && tas_priv->playback_started)
873 struct tasdevice_priv *tas_priv = tas_hda->priv;
881 if (tas_priv->fw_state == TASDEVICE_DSP_FW_ALL_OK
882 && tas_priv->playback_started)
891 struct tasdevice_priv *tas_priv = tas_hda->priv;
898 guard(mutex)(&tas_priv->codec_lock);
899 ret = tas_priv->dev_read(tas_priv, tas_priv->index,
905 tas_priv->tasdevice[tas_priv->index].cur_book = -1;
906 tas_priv->tasdevice[tas_priv->index].cur_conf = -1;
907 tas_priv->tasdevice[tas_priv->index].cur_prog = -1;
911 dev_err(tas_priv->dev,
915 tas_priv->fw_state = TASDEVICE_DSP_FW_ALL_OK;
917 if (tas_priv->playback_started)
930 { "tas2781-hda", },
942 .name = "tas2781-hda",