Re: [PATCH 13/13] ALSA: hda/cs35l56: Add driver for Cirrus Logic CS35L56 amplifier

[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]

 



On 25.05.2023 18:06, Richard Fitzgerald wrote:
> EXTERNAL EMAIL: Do not click links or open attachments unless you know the content is safe
> 
> From: Simon Trimmer <simont@xxxxxxxxxxxxxxxxxxxxx>
> 
> Add a driver for the Cirrus Logic CS35L56 amplifier. This uses the same
> component binding API as the CS35L41 driver. This is not a standalone
> HDA device; it provides control of the CS35L56 for systems that use a
> combination of an HDA codec and CS35L56 amplifiers with audio routed
> through the HDA codec.
> 
> The CS35L56 combines a high-performance mono audio amplifier, Class-H
> tracking inductive boost converter, Halo Core(TM) DSP and a DC-DC boost
> converter supporting Class-H tracking.
> 
> Control interfaces are I2C or SPI through the standard Linux I2C or SPI
> bus framework.
> 
> Most chip functionality is controlled by on-board ROM firmware that is
> always running. Firmware patches can be applied by the driver in the form
> of a .wmfw file (firmware patch) and/or a .bin file (system tuning).
> 
> Signed-off-by: Simon Trimmer <simont@xxxxxxxxxxxxxxxxxxxxx>
> Signed-off-by: Richard Fitzgerald <rf@xxxxxxxxxxxxxxxxxxxxx>
> ---
>  sound/pci/hda/Kconfig           |  31 +
>  sound/pci/hda/Makefile          |   6 +
>  sound/pci/hda/cs35l56_hda.c     | 995 ++++++++++++++++++++++++++++++++
>  sound/pci/hda/cs35l56_hda.h     |  48 ++
>  sound/pci/hda/cs35l56_hda_i2c.c |  69 +++
>  sound/pci/hda/cs35l56_hda_spi.c |  68 +++
>  6 files changed, 1217 insertions(+)
>  create mode 100644 sound/pci/hda/cs35l56_hda.c
>  create mode 100644 sound/pci/hda/cs35l56_hda.h
>  create mode 100644 sound/pci/hda/cs35l56_hda_i2c.c
>  create mode 100644 sound/pci/hda/cs35l56_hda_spi.c
> 
> diff --git a/sound/pci/hda/Kconfig b/sound/pci/hda/Kconfig
> index 886255a03e8b..0f2e941ce646 100644
> --- a/sound/pci/hda/Kconfig
> +++ b/sound/pci/hda/Kconfig
> @@ -130,6 +130,37 @@ config SND_HDA_SCODEC_CS35L41_SPI
>  comment "Set to Y if you want auto-loading the side codec driver"
>         depends on SND_HDA=y && SND_HDA_SCODEC_CS35L41_SPI=m
> 
> +config SND_HDA_SCODEC_CS35L56
> +       tristate
> +
> +config SND_HDA_SCODEC_CS35L56_I2C
> +       tristate "Build CS35L56 HD-audio side codec support for I2C Bus"
> +       depends on I2C
> +       depends on ACPI || COMPILE_TEST
> +       depends on SND_SOC
> +       select CS_DSP
> +       select SND_HDA_GENERIC
> +       select SND_SOC_CS35L56_SHARED
> +       select SND_HDA_SCODEC_CS35L56
> +       select SND_HDA_CS_DSP_CONTROLS
> +       help
> +         Say Y or M here to include CS35L56 amplifier support with
> +         I2C control.
> +
> +config SND_HDA_SCODEC_CS35L56_SPI
> +       tristate "Build CS35L56 HD-audio codec support for SPI Bus"
> +       depends on SPI_MASTER
> +       depends on ACPI || COMPILE_TEST
> +       depends on SND_SOC
> +       select CS_DSP
> +       select SND_HDA_GENERIC
> +       select SND_SOC_CS35L56_SHARED
> +       select SND_HDA_SCODEC_CS35L56
> +       select SND_HDA_CS_DSP_CONTROLS
> +       help
> +         Say Y or M here to include CS35L56 amplifier support with
> +         SPI control.
> +
>  config SND_HDA_CODEC_REALTEK
>         tristate "Build Realtek HD-audio codec support"
>         select SND_HDA_GENERIC
> diff --git a/sound/pci/hda/Makefile b/sound/pci/hda/Makefile
> index 00d306104484..c6e6509e7b8e 100644
> --- a/sound/pci/hda/Makefile
> +++ b/sound/pci/hda/Makefile
> @@ -31,6 +31,9 @@ snd-hda-codec-hdmi-objs :=    patch_hdmi.o hda_eld.o
>  snd-hda-scodec-cs35l41-objs :=         cs35l41_hda.o
>  snd-hda-scodec-cs35l41-i2c-objs :=     cs35l41_hda_i2c.o
>  snd-hda-scodec-cs35l41-spi-objs :=     cs35l41_hda_spi.o
> +snd-hda-scodec-cs35l56-objs :=         cs35l56_hda.o
> +snd-hda-scodec-cs35l56-i2c-objs :=     cs35l56_hda_i2c.o
> +snd-hda-scodec-cs35l56-spi-objs :=     cs35l56_hda_spi.o
>  snd-hda-cs-dsp-ctls-objs :=            hda_cs_dsp_ctl.o
> 
>  # common driver
> @@ -55,6 +58,9 @@ obj-$(CONFIG_SND_HDA_CODEC_HDMI) += snd-hda-codec-hdmi.o
>  obj-$(CONFIG_SND_HDA_SCODEC_CS35L41) += snd-hda-scodec-cs35l41.o
>  obj-$(CONFIG_SND_HDA_SCODEC_CS35L41_I2C) += snd-hda-scodec-cs35l41-i2c.o
>  obj-$(CONFIG_SND_HDA_SCODEC_CS35L41_SPI) += snd-hda-scodec-cs35l41-spi.o
> +obj-$(CONFIG_SND_HDA_SCODEC_CS35L56) += snd-hda-scodec-cs35l56.o
> +obj-$(CONFIG_SND_HDA_SCODEC_CS35L56_I2C) += snd-hda-scodec-cs35l56-i2c.o
> +obj-$(CONFIG_SND_HDA_SCODEC_CS35L56_SPI) += snd-hda-scodec-cs35l56-spi.o
>  obj-$(CONFIG_SND_HDA_CS_DSP_CONTROLS) += snd-hda-cs-dsp-ctls.o
> 
>  # this must be the last entry after codec drivers;
> diff --git a/sound/pci/hda/cs35l56_hda.c b/sound/pci/hda/cs35l56_hda.c
> new file mode 100644
> index 000000000000..5189f1e89a87
> --- /dev/null
> +++ b/sound/pci/hda/cs35l56_hda.c
> @@ -0,0 +1,995 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +//
> +// HDA audio driver for Cirrus Logic CS35L56 smart amp
> +//
> +// Copyright (C) 2023 Cirrus Logic, Inc. and
> +//                    Cirrus Logic International Semiconductor Ltd.
> +//
> +
> +#include <linux/acpi.h>
> +#include <linux/debugfs.h>
> +#include <linux/gpio/consumer.h>
> +#include <linux/module.h>
> +#include <linux/pm_runtime.h>
> +#include <linux/regmap.h>
> +#include <linux/slab.h>
> +#include <sound/core.h>
> +#include <sound/hda_codec.h>
> +#include <sound/tlv.h>
> +#include "cs35l56_hda.h"
> +#include "hda_component.h"
> +#include "hda_cs_dsp_ctl.h"
> +#include "hda_generic.h"
> +
> + /*
> +  * The cs35l56_hda_dai_config[] reg sequence configures the device as
> +  *  ASP1_BCLK_FREQ = 3.072 MHz
> +  *  ASP1_RX_WIDTH = 32 cycles per slot, ASP1_TX_WIDTH = 32 cycles per slot, ASP1_FMT = I2S
> +  *  ASP1_DOUT_HIZ_CONTROL = Hi-Z during unused timeslots
> +  *  ASP1_RX_WL = 24 bits per sample
> +  *  ASP1_TX_WL = 24 bits per sample
> +  *  ASP1_RXn_EN 1..3 and ASP1_TXn_EN 1..4 disabled
> +  */
> +static const struct reg_sequence cs35l56_hda_dai_config[] = {
> +       { CS35L56_ASP1_CONTROL1,        0x00000021 },
> +       { CS35L56_ASP1_CONTROL2,        0x20200200 },
> +       { CS35L56_ASP1_CONTROL3,        0x00000003 },
> +       { CS35L56_ASP1_DATA_CONTROL5,   0x00000018 },
> +       { CS35L56_ASP1_DATA_CONTROL1,   0x00000018 },
> +       { CS35L56_ASP1_ENABLES1,        0x00000000 },
> +};
> +
> +static void cs35l56_hda_play(struct cs35l56_hda *cs35l56)
> +{
> +       unsigned int val;
> +       int ret;
> +
> +       pm_runtime_get_sync(cs35l56->base.dev);
> +       ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PLAY);
> +       if (ret == 0) {
> +               /* Wait for firmware to enter PS0 power state */
> +               ret = regmap_read_poll_timeout(cs35l56->base.regmap,
> +                                              CS35L56_TRANSDUCER_ACTUAL_PS,
> +                                              val, (val == CS35L56_PS0),
> +                                              CS35L56_PS0_POLL_US,
> +                                              CS35L56_PS0_TIMEOUT_US);
> +               if (ret)
> +                       dev_warn(cs35l56->base.dev, "PS0 wait failed: %d\n", ret);
> +       }
> +       regmap_set_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1,
> +                       BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) |
> +                       cs35l56->asp_tx_mask);
> +       cs35l56->playing = true;
> +}
> +
> +static void cs35l56_hda_pause(struct cs35l56_hda *cs35l56)
> +{
> +       cs35l56->playing = false;
> +       cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_PAUSE);
> +       regmap_clear_bits(cs35l56->base.regmap, CS35L56_ASP1_ENABLES1,
> +                         BIT(CS35L56_ASP_RX1_EN_SHIFT) | BIT(CS35L56_ASP_RX2_EN_SHIFT) |
> +                         BIT(CS35L56_ASP_TX1_EN_SHIFT) | BIT(CS35L56_ASP_TX2_EN_SHIFT) |
> +                         BIT(CS35L56_ASP_TX3_EN_SHIFT) | BIT(CS35L56_ASP_TX4_EN_SHIFT));
> +
> +       pm_runtime_mark_last_busy(cs35l56->base.dev);
> +       pm_runtime_put_autosuspend(cs35l56->base.dev);
> +}
> +
> +static void cs35l56_hda_playback_hook(struct device *dev, int action)
> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +
> +       dev_dbg(cs35l56->base.dev, "%s()%d: action: %d\n", __func__, __LINE__, action);
> +
> +       switch (action) {
> +       case HDA_GEN_PCM_ACT_PREPARE:
> +               if (cs35l56->playing)
> +                       break;
> +
> +               /* If we're suspended: flag that resume should start playback */
> +               if (cs35l56->suspended) {
> +                       cs35l56->playing = true;
> +                       break;
> +               }
> +
> +               cs35l56_hda_play(cs35l56);
> +               break;
> +       case HDA_GEN_PCM_ACT_CLEANUP:
> +               if (!cs35l56->playing)
> +                       break;
> +
> +               cs35l56_hda_pause(cs35l56);
> +               break;
> +       default:
> +               break;
> +       }
> +}
> +
> +static void cs35l56_hda_mute_hook(struct device *dev, bool mute)
> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +       unsigned int val;
> +
> +       if (mute)
> +               val = CS35L56_MAIN_RENDER_USER_MUTE_MASK;
> +       else
> +               val = 0;
> +
> +       regmap_write(cs35l56->base.regmap, CS35L56_MAIN_RENDER_USER_MUTE, val);
> +}
> +
> +static int cs35l56_hda_runtime_suspend(struct device *dev)
> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +
> +       if (cs35l56->cs_dsp.booted)
> +               cs_dsp_stop(&cs35l56->cs_dsp);
> +
> +       return cs35l56_runtime_suspend_common(&cs35l56->base);
> +}
> +
> +static int cs35l56_hda_runtime_resume(struct device *dev)
> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +       int ret;
> +
> +       ret = cs35l56_runtime_resume_common(&cs35l56->base, false);
> +       if (ret < 0)
> +               return ret;
> +
> +       if (cs35l56->cs_dsp.booted) {
> +               ret = cs_dsp_run(&cs35l56->cs_dsp);
> +               if (ret) {
> +                       dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
> +                       goto err;
> +               }
> +       }
> +
> +       return 0;
> +
> +err:
> +       cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_ALLOW_AUTO_HIBERNATE);
> +       regmap_write(cs35l56->base.regmap, CS35L56_DSP_VIRTUAL1_MBOX_1,
> +                    CS35L56_MBOX_CMD_HIBERNATE_NOW);
> +
> +       regcache_cache_only(cs35l56->base.regmap, true);
> +
> +       return ret;
> +}
> +
> +static int cs35l56_hda_mixer_info(struct snd_kcontrol *kcontrol,
> +                                 struct snd_ctl_elem_info *uinfo)
> +{
> +       uinfo->type = SNDRV_CTL_ELEM_TYPE_ENUMERATED;
> +       uinfo->count = 1;
> +       uinfo->value.enumerated.items = CS35L56_NUM_INPUT_SRC;
> +       if (uinfo->value.enumerated.item >= CS35L56_NUM_INPUT_SRC)
> +               uinfo->value.enumerated.item = CS35L56_NUM_INPUT_SRC - 1;
> +       strcpy(uinfo->value.enumerated.name, cs35l56_tx_input_texts[uinfo->value.enumerated.item]);
> +
> +       return 0;
> +}
> +
> +static int cs35l56_hda_mixer_get(struct snd_kcontrol *kcontrol,
> +                                struct snd_ctl_elem_value *ucontrol)
> +{
> +       struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
> +       unsigned int reg_val;
> +       int i;
> +
> +       regmap_read(cs35l56->base.regmap, kcontrol->private_value, &reg_val);
> +       reg_val &= CS35L56_ASP_TXn_SRC_MASK;
> +
> +       for (i = 0; i < CS35L56_NUM_INPUT_SRC; ++i) {
> +               if (cs35l56_tx_input_values[i] == reg_val) {
> +                       ucontrol->value.enumerated.item[0] = i;
> +                       break;
> +               }
> +       }
> +
> +       return 0;
> +}
> +
> +static int cs35l56_hda_mixer_put(struct snd_kcontrol *kcontrol,
> +                                struct snd_ctl_elem_value *ucontrol)
> +{
> +       struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
> +       unsigned int item = ucontrol->value.enumerated.item[0];
> +       bool changed;
> +
> +       if (item >= CS35L56_NUM_INPUT_SRC)
> +               return -EINVAL;
> +
> +       regmap_update_bits_check(cs35l56->base.regmap, kcontrol->private_value,
> +                                CS35L56_INPUT_MASK, cs35l56_tx_input_values[item],
> +                                &changed);
> +
> +       return changed;
> +}
> +
> +static int cs35l56_hda_posture_info(struct snd_kcontrol *kcontrol,
> +                                   struct snd_ctl_elem_info *uinfo)
> +{
> +       uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
> +       uinfo->count = 1;
> +       uinfo->value.integer.min = CS35L56_MAIN_POSTURE_MIN;
> +       uinfo->value.integer.max = CS35L56_MAIN_POSTURE_MAX;
> +       return 0;
> +}
> +
> +static int cs35l56_hda_posture_get(struct snd_kcontrol *kcontrol,
> +                                  struct snd_ctl_elem_value *ucontrol)
> +{
> +       struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
> +       unsigned int pos;
> +       int ret;
> +
> +       ret = regmap_read(cs35l56->base.regmap, CS35L56_MAIN_POSTURE_NUMBER, &pos);
> +       if (ret)
> +               return ret;
> +
> +       ucontrol->value.integer.value[0] = pos;
> +
> +       return ret;
> +}
> +
> +static int cs35l56_hda_posture_put(struct snd_kcontrol *kcontrol,
> +                                  struct snd_ctl_elem_value *ucontrol)
> +{
> +       struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
> +       unsigned long pos = ucontrol->value.integer.value[0];
> +       bool changed;
> +       int ret;
> +
> +       if ((pos < CS35L56_MAIN_POSTURE_MIN) ||
> +           (pos > CS35L56_MAIN_POSTURE_MAX))
> +               return -EINVAL;
> +
> +       ret = regmap_update_bits_check(cs35l56->base.regmap,
> +                                      CS35L56_MAIN_POSTURE_NUMBER,
> +                                      CS35L56_MAIN_POSTURE_MASK,
> +                                      pos, &changed);
> +       if (ret)
> +               return ret;
> +
> +       return changed;
> +}
> +
> +static const struct {
> +       const char *name;
> +       unsigned int reg;
> +} cs35l56_hda_mixer_controls[] = {
> +       { "ASP1 TX1 Source", CS35L56_ASP1TX1_INPUT },
> +       { "ASP1 TX2 Source", CS35L56_ASP1TX2_INPUT },
> +       { "ASP1 TX3 Source", CS35L56_ASP1TX3_INPUT },
> +       { "ASP1 TX4 Source", CS35L56_ASP1TX4_INPUT },
> +};
> +
> +static const DECLARE_TLV_DB_SCALE(cs35l56_hda_vol_tlv, -10000, 25, 0);
> +
> +static int cs35l56_hda_vol_info(struct snd_kcontrol *kcontrol,
> +                               struct snd_ctl_elem_info *uinfo)
> +{
> +       uinfo->type = SNDRV_CTL_ELEM_TYPE_INTEGER;
> +       uinfo->count = 1;
> +       uinfo->value.integer.step = 1;
> +       uinfo->value.integer.min = 0;
> +       uinfo->value.integer.max = CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
> +                                  CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
> +
> +       return 0;
> +}
> +
> +static int cs35l56_hda_vol_get(struct snd_kcontrol *kcontrol,
> +                              struct snd_ctl_elem_value *ucontrol)
> +{
> +       struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
> +       unsigned int raw_vol;
> +       int vol;
> +       int ret;
> +
> +       ret = regmap_read(cs35l56->base.regmap, CS35L56_MAIN_RENDER_USER_VOLUME, &raw_vol);
> +
> +       if (ret)
> +               return ret;
> +
> +       vol = (s16)(raw_vol & 0xFFFF);
> +       vol >>= CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
> +
> +       if (vol & BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT))
> +               vol |= ~((int)(BIT(CS35L56_MAIN_RENDER_USER_VOLUME_SIGNBIT) - 1));
> +
> +       ucontrol->value.integer.value[0] = vol - CS35L56_MAIN_RENDER_USER_VOLUME_MIN;
> +
> +       return 0;
> +}
> +
> +static int cs35l56_hda_vol_put(struct snd_kcontrol *kcontrol,
> +                              struct snd_ctl_elem_value *ucontrol)
> +{
> +       struct cs35l56_hda *cs35l56 = (struct cs35l56_hda *)kcontrol->private_data;
> +       long vol = ucontrol->value.integer.value[0];
> +       unsigned int raw_vol;
> +       bool changed;
> +       int ret;
> +
> +       if ((vol < 0) || (vol > (CS35L56_MAIN_RENDER_USER_VOLUME_MAX -
> +                                CS35L56_MAIN_RENDER_USER_VOLUME_MIN)))
> +               return -EINVAL;
> +
> +       raw_vol = (vol + CS35L56_MAIN_RENDER_USER_VOLUME_MIN) <<
> +                 CS35L56_MAIN_RENDER_USER_VOLUME_SHIFT;
> +
> +       ret = regmap_update_bits_check(cs35l56->base.regmap,
> +                                      CS35L56_MAIN_RENDER_USER_VOLUME,
> +                                      CS35L56_MAIN_RENDER_USER_VOLUME_MASK,
> +                                      raw_vol, &changed);
> +       if (ret)
> +               return ret;
> +
> +       return changed;
> +}
> +
> +static void cs35l56_hda_create_controls(struct cs35l56_hda *cs35l56)
> +{
> +       struct snd_kcontrol_new ctl_template = {
> +               .iface = SNDRV_CTL_ELEM_IFACE_MIXER,
> +               .access = SNDRV_CTL_ELEM_ACCESS_READWRITE,
> +               .info = cs35l56_hda_posture_info,
> +               .get = cs35l56_hda_posture_get,
> +               .put = cs35l56_hda_posture_put,
> +       };
> +       char name[64];
> +       int i;
> +
> +       snprintf(name, sizeof(name), "%s Posture Number", cs35l56->amp_name);
> +       ctl_template.name = name;
> +       cs35l56->posture_ctl = snd_ctl_new1(&ctl_template, cs35l56);
> +       if (snd_ctl_add(cs35l56->codec->card, cs35l56->posture_ctl)) {
> +               dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
> +               return;
> +       }
> +
> +       /* Mixer controls */
> +       ctl_template.info = cs35l56_hda_mixer_info;
> +       ctl_template.get = cs35l56_hda_mixer_get;
> +       ctl_template.put = cs35l56_hda_mixer_put;
> +
> +       BUILD_BUG_ON(ARRAY_SIZE(cs35l56->mixer_ctl) != ARRAY_SIZE(cs35l56_hda_mixer_controls));
> +
> +       for (i = 0; i < ARRAY_SIZE(cs35l56_hda_mixer_controls); ++i) {
> +               snprintf(name, sizeof(name), "%s %s", cs35l56->amp_name,
> +                        cs35l56_hda_mixer_controls[i].name);
> +               ctl_template.private_value = cs35l56_hda_mixer_controls[i].reg;
> +               cs35l56->mixer_ctl[i] = snd_ctl_new1(&ctl_template, cs35l56);
> +               if (snd_ctl_add(cs35l56->codec->card, cs35l56->mixer_ctl[i])) {
> +                       dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n",
> +                               ctl_template.name);
> +                       return;
> +               }
> +       }
> +
> +       ctl_template.info = cs35l56_hda_vol_info;
> +       ctl_template.get = cs35l56_hda_vol_get;
> +       ctl_template.put = cs35l56_hda_vol_put;
> +       ctl_template.access = (SNDRV_CTL_ELEM_ACCESS_READWRITE | SNDRV_CTL_ELEM_ACCESS_TLV_READ);
> +       ctl_template.tlv.p = cs35l56_hda_vol_tlv;
> +       snprintf(name, sizeof(name), "%s Speaker Playback Volume", cs35l56->amp_name);
> +       ctl_template.name = name;
> +       cs35l56->volume_ctl = snd_ctl_new1(&ctl_template, cs35l56);
> +       if (snd_ctl_add(cs35l56->codec->card, cs35l56->volume_ctl)) {
> +               dev_err(cs35l56->base.dev, "Failed to add KControl: %s\n", ctl_template.name);
> +               return;

No need for return here.

> +       }
> +}
> +
> +static void cs35l56_hda_remove_controls(struct cs35l56_hda *cs35l56)
> +{
> +       int i;
> +
> +       for (i = ARRAY_SIZE(cs35l56->mixer_ctl) - 1; i >= 0; i--)
> +               snd_ctl_remove(cs35l56->codec->card, cs35l56->mixer_ctl[i]);
> +
> +       snd_ctl_remove(cs35l56->codec->card, cs35l56->posture_ctl);
> +       snd_ctl_remove(cs35l56->codec->card, cs35l56->volume_ctl);
> +}
> +
> +static const struct cs_dsp_client_ops cs35l56_hda_client_ops = {
> +       .control_remove = hda_cs_dsp_control_remove,
> +};
> +
> +static int cs35l56_hda_request_firmware_file(struct cs35l56_hda *cs35l56,
> +                                            const struct firmware **firmware, char **filename,
> +                                            const char *dir, const char *system_name,
> +                                            const char *amp_name,
> +                                            const char *filetype)
> +{
> +       char *s, c;
> +       int ret = 0;
> +
> +       if (system_name && amp_name)
> +               *filename = kasprintf(GFP_KERNEL, "%scs35l56%s-%02x-dsp1-misc-%s-%s.%s", dir,
> +                                     cs35l56->base.secured ? "s" : "", cs35l56->base.rev,
> +                                     system_name, amp_name, filetype);
> +       else if (system_name)
> +               *filename = kasprintf(GFP_KERNEL, "%scs35l56%s-%02x-dsp1-misc-%s.%s", dir,
> +                                     cs35l56->base.secured ? "s" : "", cs35l56->base.rev,
> +                                     system_name, filetype);
> +       else
> +               *filename = kasprintf(GFP_KERNEL, "%scs35l56%s-%02x-dsp1-misc.%s", dir,
> +                                     cs35l56->base.secured ? "s" : "", cs35l56->base.rev,
> +                                     filetype);
> +
> +       if (!*filename)
> +               return -ENOMEM;
> +
> +       /*
> +        * Make sure that filename is lower-case and any non alpha-numeric
> +        * characters except full stop and forward slash are replaced with
> +        * hyphens.
> +        */
> +       s = *filename;
> +       while (*s) {
> +               c = *s;
> +               if (isalnum(c))
> +                       *s = tolower(c);
> +               else if (c != '.' && c != '/')
> +                       *s = '-';
> +               s++;
> +       }
> +
> +       ret = firmware_request_nowarn(firmware, *filename, cs35l56->base.dev);
> +       if (ret != 0) {

if (ret)

> +               dev_dbg(cs35l56->base.dev, "Failed to request '%s'\n", *filename);
> +               kfree(*filename);
> +               *filename = NULL;
> +       } else {
> +               dev_dbg(cs35l56->base.dev, "Found '%s'\n", *filename);
> +       }
> +
> +       return ret;
> +}
> +
> +static const char cirrus_dir[] = "cirrus/";
> +static int cs35l56_hda_request_firmware_files(struct cs35l56_hda *cs35l56,
> +                                             const struct firmware **wmfw_firmware,
> +                                             char **wmfw_filename,
> +                                             const struct firmware **coeff_firmware,
> +                                             char **coeff_filename)
> +{
> +       const char *system_name = cs35l56->system_name;
> +       const char *amp_name = cs35l56->amp_name;
> +       int ret;
> +
> +       if (system_name && amp_name) {
> +               if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
> +                                                      cirrus_dir, system_name, amp_name, "wmfw")) {
> +                       cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
> +                                                         cirrus_dir, system_name, amp_name, "bin");
> +                       return 0;
> +               }
> +       }
> +
> +       if (system_name) {
> +               if (!cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
> +                                                      cirrus_dir, system_name, NULL, "wmfw")) {
> +                       if (amp_name)
> +                               cs35l56_hda_request_firmware_file(cs35l56,
> +                                                                 coeff_firmware, coeff_filename,
> +                                                                 cirrus_dir, system_name,
> +                                                                 amp_name, "bin");
> +                       if (!*coeff_firmware)
> +                               cs35l56_hda_request_firmware_file(cs35l56,
> +                                                                 coeff_firmware, coeff_filename,
> +                                                                 cirrus_dir, system_name,
> +                                                                 NULL, "bin");
> +                       return 0;
> +               }
> +       }
> +
> +       ret = cs35l56_hda_request_firmware_file(cs35l56, wmfw_firmware, wmfw_filename,
> +                                               cirrus_dir, NULL, NULL, "wmfw");
> +       if (!ret) {
> +               cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
> +                                                 cirrus_dir, NULL, NULL, "bin");
> +               return 0;
> +       }
> +
> +       /* When a firmware file is not found must still search for the coeff files */
> +       if (system_name) {
> +               if (amp_name)
> +                       cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
> +                                                         cirrus_dir, system_name, amp_name, "bin");
> +               if (!*coeff_firmware)
> +                       cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
> +                                                         cirrus_dir, system_name, NULL, "bin");
> +       }
> +
> +       if (!*coeff_firmware)
> +               cs35l56_hda_request_firmware_file(cs35l56, coeff_firmware, coeff_filename,
> +                                                 cirrus_dir, NULL, NULL, "bin");
> +
> +       return 0;
> +}
> +
> +static void cs35l56_hda_add_dsp_controls(struct cs35l56_hda *cs35l56)
> +{
> +       struct hda_cs_dsp_ctl_info info;
> +
> +       info.device_name = cs35l56->amp_name;
> +       info.fw_type = HDA_CS_DSP_FW_MISC;
> +       info.card = cs35l56->codec->card;
> +
> +       hda_cs_dsp_add_controls(&cs35l56->cs_dsp, &info);
> +}
> +
> +static int cs35l56_hda_fw_load(struct cs35l56_hda *cs35l56)
> +{
> +       const struct firmware *coeff_firmware = NULL;
> +       const struct firmware *wmfw_firmware = NULL;
> +       char *coeff_filename = NULL;
> +       char *wmfw_filename = NULL;
> +       int ret = 0;
> +
> +       mutex_lock(&cs35l56->base.irq_lock);
> +       pm_runtime_get_sync(cs35l56->base.dev);
> +
> +       /*
> +        * When the device is running in secure mode the firmware files can
> +        * only contain insecure tunings and therefore we do not need to
> +        * shutdown the firmware to apply them and can use the lower cost
> +        * reinit sequence instead.
> +        */
> +       if (!cs35l56->base.secured) {
> +               ret = cs35l56_firmware_shutdown(&cs35l56->base);
> +               if (ret)
> +                       goto err;
> +       }
> +
> +       cs35l56_hda_request_firmware_files(cs35l56, &wmfw_firmware, &wmfw_filename,
> +                                          &coeff_firmware, &coeff_filename);
> +
> +       ret = cs_dsp_power_up(&cs35l56->cs_dsp, wmfw_firmware, wmfw_filename,
> +                             coeff_firmware, coeff_filename, "misc");
> +       if (ret) {
> +               dev_dbg(cs35l56->base.dev, "%s: cs_dsp_power_up ret %d\n", __func__, ret);
> +               goto err;
> +       }
> +
> +       if (wmfw_filename)
> +               dev_dbg(cs35l56->base.dev, "Loaded WMFW Firmware: %s\n", wmfw_filename);
> +
> +       if (coeff_filename)
> +               dev_dbg(cs35l56->base.dev, "Loaded Coefficients: %s\n", coeff_filename);
> +
> +       ret = cs_dsp_run(&cs35l56->cs_dsp);
> +       if (ret) {
> +               dev_dbg(cs35l56->base.dev, "%s: cs_dsp_run ret %d\n", __func__, ret);
> +               goto err;
> +       }
> +
> +       if (cs35l56->base.secured) {
> +               ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_AUDIO_REINIT);
> +               if (ret)
> +                       goto err;
> +       } else {
> +               /* Reset the device and wait for it to boot */
> +               cs35l56_system_reset(&cs35l56->base, false);
> +               ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
> +               if (ret)
> +                       goto err;
> +       }
> +
> +       /* Disable auto-hibernate so that runtime_pm has control */
> +       ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
> +       if (ret)
> +               goto err;
> +
> +       /* Re-read the values from the device after a firmware/cofficient download */
> +       cs35l56_reread_firmware_registers(&cs35l56->base);
> +
> +       regcache_mark_dirty(cs35l56->base.regmap);
> +       regcache_sync(cs35l56->base.regmap);
> +
> +       regmap_clear_bits(cs35l56->base.regmap, CS35L56_PROTECTION_STATUS,
> +                         CS35L56_FIRMWARE_MISSING);
> +       cs35l56->base.fw_patched = true;
> +err:
> +       pm_runtime_put(cs35l56->base.dev);
> +       mutex_unlock(&cs35l56->base.irq_lock);
> +
> +       return ret;
> +}
> +
> +static int cs35l56_hda_bind(struct device *dev, struct device *master, void *master_data)
> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +       struct hda_component *comps = master_data;
> +       int ret;
> +
> +       if (!comps || cs35l56->index < 0 || cs35l56->index >= HDA_MAX_COMPONENTS)
> +               return -EINVAL;
> +
> +       comps = &comps[cs35l56->index];
> +       if (comps->dev)
> +               return -EBUSY;
> +
> +       comps->dev = dev;
> +       cs35l56->codec = comps->codec;
> +       strscpy(comps->name, dev_name(dev), sizeof(comps->name));
> +       comps->playback_hook = cs35l56_hda_playback_hook;
> +       comps->mute_hook = cs35l56_hda_mute_hook;
> +
> +       ret = cs35l56_hda_fw_load(cs35l56);
> +       if (ret)
> +               return ret;
> +
> +       cs35l56_hda_create_controls(cs35l56);
> +       cs35l56_hda_add_dsp_controls(cs35l56);
> +
> +#if IS_ENABLED(CONFIG_SND_DEBUG)
> +       cs35l56->debugfs_root = debugfs_create_dir(dev_name(cs35l56->base.dev), sound_debugfs_root);
> +       cs_dsp_init_debugfs(&cs35l56->cs_dsp, cs35l56->debugfs_root);
> +#endif
> +
> +       dev_dbg(cs35l56->base.dev, "Bound\n");
> +
> +       return 0;
> +}
> +
> +static void cs35l56_hda_unbind(struct device *dev, struct device *master, void *master_data)
> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +       struct hda_component *comps = master_data;
> +
> +       cs35l56_hda_remove_controls(cs35l56);
> +
> +#if IS_ENABLED(CONFIG_SND_DEBUG)
> +       cs_dsp_cleanup_debugfs(&cs35l56->cs_dsp);
> +       debugfs_remove_recursive(cs35l56->debugfs_root);
> +#endif
> +
> +       cs_dsp_remove(&cs35l56->cs_dsp);
> +
> +       if (comps[cs35l56->index].dev == dev)
> +               memset(&comps[cs35l56->index], 0, sizeof(*comps));
> +
> +       dev_dbg(cs35l56->base.dev, "Unbound\n");
> +}
> +
> +static const struct component_ops cs35l56_hda_comp_ops = {
> +       .bind = cs35l56_hda_bind,
> +       .unbind = cs35l56_hda_unbind,
> +};
> +
> +static int __maybe_unused cs35l56_hda_system_suspend(struct device *dev)

You can get rid of __maybe_unused here if using SYSTEM_SLEEP_PM_OPS(). Same
for the resume counterpart function.

> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +
> +       if (cs35l56->playing)
> +               cs35l56_hda_pause(cs35l56);
> +
> +       cs35l56->suspended = true;
> +
> +       /*
> +        * The interrupt line is normally shared, but after we start suspending
> +        * we can't check if our device is the source of an interrupt, and can't
> +        * clear it. Prevent this race by temporarily disabling the parent irq
> +        * until we reach _no_irq.
> +        */
> +       if (cs35l56->base.irq)
> +               disable_irq(cs35l56->base.irq);
> +
> +       return pm_runtime_force_suspend(dev);
> +}
> +
> +static int __maybe_unused cs35l56_hda_system_suspend_late(struct device *dev)

There shoud be no need of __maybe_unused here. Same for the resume
counterpart function.

> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +
> +       /*
> +        * RESET is usually shared by all amps so it must not be asserted until
> +        * all driver instances have done their suspend() stage.
> +        */
> +       if (cs35l56->base.reset_gpio) {
> +               gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
> +               cs35l56_wait_min_reset_pulse();
> +       }
> +
> +       return 0;
> +}
> +
> +static int __maybe_unused cs35l56_hda_system_suspend_no_irq(struct device *dev)

Same here.

> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +
> +       /* Handlers are now disabled so the parent IRQ can safely be re-enabled. */
> +       if (cs35l56->base.irq)
> +               enable_irq(cs35l56->base.irq);
> +
> +       return 0;
> +}
> +
> +static int __maybe_unused cs35l56_hda_system_resume_no_irq(struct device *dev)
> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +
> +       /*
> +        * WAKE interrupts unmask if the CS35L56 hibernates, which can cause
> +        * spurious interrupts, and the interrupt line is normally shared.
> +        * We can't check if our device is the source of an interrupt, and can't
> +        * clear it, until it has fully resumed. Prevent this race by temporarily
> +        * disabling the parent irq until we complete resume().
> +        */
> +       if (cs35l56->base.irq)
> +               disable_irq(cs35l56->base.irq);
> +
> +       return 0;
> +}
> +
> +static int __maybe_unused cs35l56_hda_system_resume_early(struct device *dev)
> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +
> +       /* Ensure a spec-compliant RESET pulse. */
> +       if (cs35l56->base.reset_gpio) {
> +               gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
> +               cs35l56_wait_min_reset_pulse();
> +
> +               /* Release shared RESET before drivers start resume(). */
> +               gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
> +               cs35l56_wait_control_port_ready();
> +       }
> +
> +       return 0;
> +}
> +
> +static int __maybe_unused cs35l56_hda_system_resume(struct device *dev)
> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +       int ret;
> +
> +       /* Undo pm_runtime_force_suspend() before re-enabling the irq */
> +       ret = pm_runtime_force_resume(dev);
> +       if (cs35l56->base.irq)
> +               enable_irq(cs35l56->base.irq);
> +
> +       if (ret)
> +               return ret;
> +
> +       cs35l56->suspended = false;
> +
> +       ret = cs35l56_is_fw_reload_needed(&cs35l56->base);
> +       dev_dbg(cs35l56->base.dev, "fw_reload_needed: %d\n", ret);
> +       if (ret > 0) {
> +               ret = cs35l56_hda_fw_load(cs35l56);
> +               if (ret)
> +                       return ret;
> +       }
> +
> +       if (cs35l56->playing)
> +               cs35l56_hda_play(cs35l56);
> +
> +       return 0;
> +}
> +
> +static int cs35l56_hda_read_acpi(struct cs35l56_hda *cs35l56, int id)
> +{
> +       u32 values[HDA_MAX_COMPONENTS];
> +       struct acpi_device *adev;
> +       const char *property, *sub;
> +       size_t nval;
> +       int i, ret;
> +
> +       /*
> +        * ACPI_COMPANION isn't available when this driver was instantiated by
> +        * the serial-multi-instantiate driver, so lookup the node by HID
> +        */
> +       if (!ACPI_COMPANION(cs35l56->base.dev)) {
> +               adev = acpi_dev_get_first_match_dev("CSC3556", NULL, -1);
> +               if (!adev) {
> +                       dev_err(cs35l56->base.dev, "Failed to find an ACPI device for %s\n",
> +                               dev_name(cs35l56->base.dev));
> +                       return -ENODEV;
> +               }
> +               ACPI_COMPANION_SET(cs35l56->base.dev, adev);
> +       }
> +
> +       property = "cirrus,dev-index";
> +       ret = device_property_count_u32(cs35l56->base.dev, property);
> +       if (ret <= 0)
> +               goto err;
> +
> +       if (ret > ARRAY_SIZE(values)) {
> +               ret = -EINVAL;
> +               goto err;
> +       }
> +       nval = ret;
> +
> +       ret = device_property_read_u32_array(cs35l56->base.dev, property, values, nval);
> +       if (ret)
> +               goto err;
> +
> +       cs35l56->index = -1;
> +       for (i = 0; i < nval; i++) {
> +               if (values[i] == id) {
> +                       cs35l56->index = i;
> +                       break;
> +               }
> +       }
> +       if (cs35l56->index == -1) {
> +               dev_err(cs35l56->base.dev, "No index found in %s\n", property);
> +               ret = -ENODEV;
> +               goto err;
> +       }
> +
> +       sub = acpi_get_subsystem_id(ACPI_HANDLE(cs35l56->base.dev));
> +
> +       if (IS_ERR(sub)) {
> +               /* If no ACPI SUB, return 0 and fallback to legacy firmware path, otherwise fail */
> +               if (PTR_ERR(sub) == -ENODATA)
> +                       return 0;
> +               else
> +                       return PTR_ERR(sub);
> +       }
> +
> +       cs35l56->system_name = sub;
> +
> +       cs35l56->base.reset_gpio = devm_gpiod_get_index_optional(cs35l56->base.dev,
> +                                                                "reset",
> +                                                                cs35l56->index,
> +                                                                GPIOD_OUT_LOW);
> +       if (IS_ERR(cs35l56->base.reset_gpio)) {

devm_gpiod_get_index_optional() can also return NULL.

> +               ret = PTR_ERR(cs35l56->base.reset_gpio);
> +
> +               /*
> +                * If RESET is shared the first amp to probe will grab the reset
> +                * line and reset all the amps
> +                */
> +               if (ret != -EBUSY)
> +                       return dev_err_probe(cs35l56->base.dev, ret, "Failed to get reset GPIO\n");
> +
> +               dev_info(cs35l56->base.dev, "Reset GPIO busy, assume shared reset\n");
> +               cs35l56->base.reset_gpio = NULL;
> +       }
> +
> +       return 0;
> +
> +err:
> +       dev_err(cs35l56->base.dev, "Failed property %s: %d\n", property, ret);
> +
> +       return ret;
> +}
> +
> +int cs35l56_hda_common_probe(struct cs35l56_hda *cs35l56, int id)
> +{
> +       int ret;
> +
> +       mutex_init(&cs35l56->base.irq_lock);
> +       dev_set_drvdata(cs35l56->base.dev, cs35l56);
> +
> +       ret = cs35l56_hda_read_acpi(cs35l56, id);
> +       if (ret) {
> +               dev_err_probe(cs35l56->base.dev, ret, "Platform not supported\n");
> +               goto err;
> +       }
> +
> +       cs35l56->amp_name = devm_kasprintf(cs35l56->base.dev, GFP_KERNEL, "AMP%d",
> +                                          cs35l56->index + 1);
> +       if (!cs35l56->amp_name) {
> +               ret = -ENOMEM;
> +               goto err;
> +       }
> +
> +       cs35l56_init_cs_dsp(&cs35l56->base, &cs35l56->cs_dsp);
> +       cs35l56->cs_dsp.client_ops = &cs35l56_hda_client_ops;
> +
> +       if (cs35l56->base.reset_gpio) {
> +               dev_dbg(cs35l56->base.dev, "Hard reset\n");
> +
> +               /*
> +                * The GPIOD_OUT_LOW to *_gpiod_get_*() will be ignored if the
> +                * ACPI defines a different default state. So explicitly set low.
> +                */
> +               gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
> +               cs35l56_wait_min_reset_pulse();
> +               gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 1);
> +       }
> +
> +       ret = cs35l56_hw_init(&cs35l56->base);
> +       if (ret < 0)
> +               goto err;
> +
> +       /* Reset the device and wait for it to boot */
> +       cs35l56_system_reset(&cs35l56->base, false);
> +       ret = cs35l56_wait_for_firmware_boot(&cs35l56->base);
> +       if (ret)
> +               goto err;
> +
> +       regcache_mark_dirty(cs35l56->base.regmap);
> +       regcache_sync(cs35l56->base.regmap);
> +
> +       /* Disable auto-hibernate so that runtime_pm has control */
> +       ret = cs35l56_mbox_send(&cs35l56->base, CS35L56_MBOX_CMD_PREVENT_AUTO_HIBERNATE);
> +       if (ret)
> +               goto err;
> +
> +       ret = cs_dsp_halo_init(&cs35l56->cs_dsp);
> +       if (ret != 0) {

if (ret)

> +               dev_err_probe(cs35l56->base.dev, ret, "cs_dsp_halo_init failed\n");
> +               goto err;
> +       }
> +
> +       dev_dbg(cs35l56->base.dev, "DSP system name: '%s', amp name: '%s'\n",
> +               cs35l56->system_name, cs35l56->amp_name);
> +
> +       /* Populate soft registers in the regmap cache */
> +       cs35l56_reread_firmware_registers(&cs35l56->base);
> +
> +       regmap_multi_reg_write(cs35l56->base.regmap, cs35l56_hda_dai_config,
> +                              ARRAY_SIZE(cs35l56_hda_dai_config));
> +
> +       /*
> +        * By default only enable one ASP1TXn, where n=amplifier index,
> +        * This prevents multiple amps trying to drive the same slot.
> +        */
> +       cs35l56->asp_tx_mask = BIT(cs35l56->index);
> +
> +       pm_runtime_set_autosuspend_delay(cs35l56->base.dev, 3000);
> +       pm_runtime_use_autosuspend(cs35l56->base.dev);
> +       pm_runtime_set_active(cs35l56->base.dev);
> +       pm_runtime_mark_last_busy(cs35l56->base.dev);
> +       pm_runtime_enable(cs35l56->base.dev);
> +
> +       ret = component_add(cs35l56->base.dev, &cs35l56_hda_comp_ops);
> +       if (ret) {
> +               dev_err(cs35l56->base.dev, "Register component failed: %d\n", ret);
> +               goto pm_err;
> +       }
> +
> +       cs35l56->base.init_done = true;
> +
> +       return 0;
> +
> +pm_err:
> +       pm_runtime_disable(cs35l56->base.dev);
> +err:
> +       gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
> +
> +       return ret;
> +}
> +EXPORT_SYMBOL_NS_GPL(cs35l56_hda_common_probe, SND_HDA_SCODEC_CS35L56);
> +
> +void cs35l56_hda_remove(struct device *dev)
> +{
> +       struct cs35l56_hda *cs35l56 = dev_get_drvdata(dev);
> +
> +       pm_runtime_get_sync(cs35l56->base.dev);
> +       pm_runtime_disable(cs35l56->base.dev);
> +
> +       component_del(cs35l56->base.dev, &cs35l56_hda_comp_ops);
> +
> +       kfree(cs35l56->system_name);
> +       pm_runtime_put_noidle(cs35l56->base.dev);
> +
> +       gpiod_set_value_cansleep(cs35l56->base.reset_gpio, 0);
> +}
> +EXPORT_SYMBOL_NS_GPL(cs35l56_hda_remove, SND_HDA_SCODEC_CS35L56);
> +
> +const struct dev_pm_ops cs35l56_hda_pm_ops = {
> +       SET_RUNTIME_PM_OPS(cs35l56_hda_runtime_suspend, cs35l56_hda_runtime_resume, NULL)
> +       SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend, cs35l56_hda_system_resume)
> +       LATE_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_late,
> +                                cs35l56_hda_system_resume_early)
> +       NOIRQ_SYSTEM_SLEEP_PM_OPS(cs35l56_hda_system_suspend_no_irq,
> +                                 cs35l56_hda_system_resume_no_irq)
> +};
> +EXPORT_SYMBOL_NS_GPL(cs35l56_hda_pm_ops, SND_HDA_SCODEC_CS35L56);
> +
> +MODULE_DESCRIPTION("CS35L56 HDA Driver");
> +MODULE_IMPORT_NS(SND_HDA_CS_DSP_CONTROLS);
> +MODULE_IMPORT_NS(SND_SOC_CS35L56_SHARED);
> +MODULE_AUTHOR("Richard Fitzgerald <rf@xxxxxxxxxxxxxxxxxxxxx>");
> +MODULE_AUTHOR("Simon Trimmer <simont@xxxxxxxxxxxxxxxxxxxxx>");
> +MODULE_LICENSE("GPL");
> +MODULE_IMPORT_NS(FW_CS_DSP);
> diff --git a/sound/pci/hda/cs35l56_hda.h b/sound/pci/hda/cs35l56_hda.h
> new file mode 100644
> index 000000000000..6e5bc5397db5
> --- /dev/null
> +++ b/sound/pci/hda/cs35l56_hda.h
> @@ -0,0 +1,48 @@
> +/* SPDX-License-Identifier: GPL-2.0-only
> + *
> + * HDA audio driver for Cirrus Logic CS35L56 smart amp
> + *
> + * Copyright (C) 2023 Cirrus Logic, Inc. and
> + *                    Cirrus Logic International Semiconductor Ltd.
> + */
> +
> +#ifndef __CS35L56_HDA_H__
> +#define __CS35L56_HDA_H__
> +
> +#include <linux/device.h>
> +#include <linux/gpio/consumer.h>
> +#include <linux/firmware/cirrus/cs_dsp.h>
> +#include <linux/firmware/cirrus/wmfw.h>
> +#include <linux/regulator/consumer.h>
> +#include <sound/cs35l56.h>
> +
> +struct dentry;
> +
> +struct cs35l56_hda {
> +       struct cs35l56_base base;
> +       struct hda_codec *codec;
> +
> +       int index;
> +       const char *system_name;
> +       const char *amp_name;
> +
> +       struct cs_dsp cs_dsp;
> +       bool playing;
> +       bool suspended;
> +       u8 asp_tx_mask;
> +
> +       struct snd_kcontrol *posture_ctl;
> +       struct snd_kcontrol *volume_ctl;
> +       struct snd_kcontrol *mixer_ctl[4];
> +
> +#if IS_ENABLED(CONFIG_SND_DEBUG)
> +       struct dentry *debugfs_root;
> +#endif
> +};
> +
> +extern const struct dev_pm_ops cs35l56_hda_pm_ops;
> +
> +int cs35l56_hda_common_probe(struct cs35l56_hda *cs35l56, int id);
> +void cs35l56_hda_remove(struct device *dev);
> +
> +#endif /*__CS35L56_HDA_H__*/
> diff --git a/sound/pci/hda/cs35l56_hda_i2c.c b/sound/pci/hda/cs35l56_hda_i2c.c
> new file mode 100644
> index 000000000000..5dfe79554d0b
> --- /dev/null
> +++ b/sound/pci/hda/cs35l56_hda_i2c.c
> @@ -0,0 +1,69 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +//
> +// CS35L56 HDA audio driver I2C binding
> +//
> +// Copyright (C) 2023 Cirrus Logic, Inc. and
> +//                    Cirrus Logic International Semiconductor Ltd.
> +
> +#include <linux/i2c.h>
> +#include <linux/module.h>
> +#include <linux/regmap.h>
> +
> +#include "cs35l56_hda.h"
> +
> +static int cs35l56_hda_i2c_probe(struct i2c_client *clt)
> +{
> +       struct cs35l56_hda *cs35l56;
> +       int ret;
> +
> +       cs35l56 = devm_kzalloc(&clt->dev, sizeof(*cs35l56), GFP_KERNEL);
> +       if (!cs35l56)
> +               return -ENOMEM;
> +
> +       cs35l56->base.dev = &clt->dev;
> +       cs35l56->base.can_hibernate = true;
> +       cs35l56->base.regmap = devm_regmap_init_i2c(clt, &cs35l56_regmap_i2c);
> +       if (IS_ERR(cs35l56->base.regmap)) {
> +               ret = PTR_ERR(cs35l56->base.regmap);
> +               dev_err(cs35l56->base.dev, "Failed to allocate register map: %d\n",
> +                       ret);
> +               return ret;
> +       }
> +
> +       ret = cs35l56_hda_common_probe(cs35l56, clt->addr);
> +       if (ret != 0)

if (ret)

> +               return ret;
> +       ret = cs35l56_irq_request(&cs35l56->base, clt->irq);
> +       if (ret < 0)
> +               cs35l56_hda_remove(cs35l56->base.dev);
> +
> +       return ret;
> +}
> +
> +static void cs35l56_hda_i2c_remove(struct i2c_client *clt)
> +{
> +       cs35l56_hda_remove(&clt->dev);
> +}
> +
> +static const struct i2c_device_id cs35l56_hda_i2c_id[] = {
> +       { "cs35l56-hda", 0 },
> +       {}
> +};
> +
> +static struct i2c_driver cs35l56_hda_i2c_driver = {
> +       .driver = {
> +               .name           = "cs35l56-hda",
> +               .pm             = &cs35l56_hda_pm_ops,
> +       },
> +       .id_table       = cs35l56_hda_i2c_id,
> +       .probe_new      = cs35l56_hda_i2c_probe,
> +       .remove         = cs35l56_hda_i2c_remove,
> +};
> +module_i2c_driver(cs35l56_hda_i2c_driver);
> +
> +MODULE_DESCRIPTION("HDA CS35L56 I2C driver");
> +MODULE_IMPORT_NS(SND_HDA_SCODEC_CS35L56);
> +MODULE_IMPORT_NS(SND_SOC_CS35L56_SHARED);
> +MODULE_AUTHOR("Richard Fitzgerald <rf@xxxxxxxxxxxxxxxxxxxxx>");
> +MODULE_AUTHOR("Simon Trimmer <simont@xxxxxxxxxxxxxxxxxxxxx>");
> +MODULE_LICENSE("GPL");
> diff --git a/sound/pci/hda/cs35l56_hda_spi.c b/sound/pci/hda/cs35l56_hda_spi.c
> new file mode 100644
> index 000000000000..bd572ce796d8
> --- /dev/null
> +++ b/sound/pci/hda/cs35l56_hda_spi.c
> @@ -0,0 +1,68 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +//
> +// CS35L56 HDA audio driver SPI binding
> +//
> +// Copyright (C) 2023 Cirrus Logic, Inc. and
> +//                    Cirrus Logic International Semiconductor Ltd.
> +
> +#include <linux/module.h>
> +#include <linux/regmap.h>
> +#include <linux/spi/spi.h>
> +
> +#include "cs35l56_hda.h"
> +
> +static int cs35l56_hda_spi_probe(struct spi_device *spi)
> +{
> +       struct cs35l56_hda *cs35l56;
> +       int ret;
> +
> +       cs35l56 = devm_kzalloc(&spi->dev, sizeof(*cs35l56), GFP_KERNEL);
> +       if (!cs35l56)
> +               return -ENOMEM;
> +
> +       cs35l56->base.dev = &spi->dev;
> +       cs35l56->base.regmap = devm_regmap_init_spi(spi, &cs35l56_regmap_spi);
> +       if (IS_ERR(cs35l56->base.regmap)) {
> +               ret = PTR_ERR(cs35l56->base.regmap);
> +               dev_err(cs35l56->base.dev, "Failed to allocate register map: %d\n",
> +                       ret);
> +               return ret;
> +       }
> +
> +       ret = cs35l56_hda_common_probe(cs35l56, spi->chip_select);
> +       if (ret != 0)

if (ret)

> +               return ret;
> +       ret = cs35l56_irq_request(&cs35l56->base, spi->irq);
> +       if (ret < 0)
> +               cs35l56_hda_remove(cs35l56->base.dev);
> +
> +       return ret;
> +}
> +
> +static void cs35l56_hda_spi_remove(struct spi_device *spi)
> +{
> +       cs35l56_hda_remove(&spi->dev);
> +}
> +
> +static const struct spi_device_id cs35l56_hda_spi_id[] = {
> +       { "cs35l56-hda", 0 },
> +       {}
> +};
> +
> +static struct spi_driver cs35l56_hda_spi_driver = {
> +       .driver = {
> +               .name           = "cs35l56-hda",
> +               .pm             = &cs35l56_hda_pm_ops,
> +       },
> +       .id_table       = cs35l56_hda_spi_id,
> +       .probe          = cs35l56_hda_spi_probe,
> +       .remove         = cs35l56_hda_spi_remove,
> +};
> +module_spi_driver(cs35l56_hda_spi_driver);
> +
> +MODULE_DESCRIPTION("HDA CS35L56 SPI driver");
> +MODULE_IMPORT_NS(SND_HDA_SCODEC_CS35L56);
> +MODULE_IMPORT_NS(SND_SOC_CS35L56_SHARED);
> +MODULE_AUTHOR("Richard Fitzgerald <rf@xxxxxxxxxxxxxxxxxxxxx>");
> +MODULE_AUTHOR("Simon Trimmer <simont@xxxxxxxxxxxxxxxxxxxxx>");
> +MODULE_LICENSE("GPL");
> --
> 2.30.2
> 





[Index of Archives]     [ALSA User]     [Linux Audio Users]     [Pulse Audio]     [Kernel Archive]     [Asterisk PBX]     [Photo Sharing]     [Linux Sound]     [Video 4 Linux]     [Gimp]     [Yosemite News]

  Powered by Linux