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, ®_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 >