January 2022 - Alsa-devel - mailman.alsa-project.org

[PATCH] ASoC: mediatek: fix unmet dependency on GPIOLIB for SND_SOC_DMIC
by Julian Braha 19 Jan '22

19 Jan '22

When SND_SOC_MT8195_MT6359_RT1011_RT5682 is selected, and GPIOLIB is not selected, Kbuild gives the following warning: WARNING: unmet direct dependencies detected for SND_SOC_DMIC Depends on [n]: SOUND [=y] && !UML && SND [=y] && SND_SOC [=y] && GPIOLIB [=n] Selected by [y]: - SND_SOC_MT8195_MT6359_RT1011_RT5682 [=y] && SOUND [=y] && !UML && SND [=y] && SND_SOC [=y] && I2C [=y] && SND_SOC_MT8195 [=y] && MTK_PMIC_WRAP [=y] This is because SND_SOC_MT8195_MT6359_RT1011_RT5682 selects SND_SOC_DMIC without selecting or depending on GPIOLIB, depsite SND_SOC_DMIC depending on GPIOLIB. This unmet dependency bug was detected by Kismet, a static analysis tool for Kconfig. Please advise if this is not the appropriate solution. Signed-off-by: Julian Braha <julianbraha(a)gmail.com> --- sound/soc/mediatek/Kconfig | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sound/soc/mediatek/Kconfig b/sound/soc/mediatek/Kconfig index 9306b7ca2644..0d154350f180 100644 --- a/sound/soc/mediatek/Kconfig +++ b/sound/soc/mediatek/Kconfig @@ -216,7 +216,7 @@ config SND_SOC_MT8195_MT6359_RT1019_RT5682 config SND_SOC_MT8195_MT6359_RT1011_RT5682 tristate "ASoC Audio driver for MT8195 with MT6359 RT1011 RT5682 codec" - depends on I2C + depends on I2C && GPIOLIB depends on SND_SOC_MT8195 && MTK_PMIC_WRAP select SND_SOC_MT6359 select SND_SOC_RT1011 -- 2.32.0

3 2

[PATCH v2 0/2] SOF: Add compress support implementation
by Daniel Baluta 19 Jan '22

19 Jan '22

From: Daniel Baluta <daniel.baluta(a)nxp.com> This patch series adds compress operations support. This is tested with SOF (codec_adapter component enabled) and i.MX8/8X/8M boards. Changes since v1: (https://lore.kernel.org/lkml/20220113161341.371345-1-daniel.baluta@oss.nxp.…) - Addressed review from Cezary and Pierre - fixed layout of declaration blocks to be more consistent - avoid using rtd and runtime simultaneously inside a function (always used rtd and crtd) - check return code for create_page_table - completely remove sof_compr_stream and use snd_compr_tstmap instead to keep compress stream related info.· - add get_caps and get_codec_caps implementations (in patch 2) Daniel Baluta (1): ASoC: SOF: compr: Add compress ops implementation Paul Olaru (1): ASoC: SOF: compress: Implement get_caps and get_codec_caps sound/soc/sof/compress.c | 347 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 345 insertions(+), 2 deletions(-) -- 2.27.0

3 5

[PATCH v3] ASoC: adds component driver for TAS575xM digital amplifiers
by Joerg Schambacher 19 Jan '22

19 Jan '22

Adds a minimum component driver to run the amplifier in I2S master mode only from standard audio clocks. Therefore, it only allows 44.1, 88.2, 176.4, 48, 96 and 192ksps with 16, 20, 24 and 32 bits sample size. Digital volume control and the -6dB and +0.8dB switches are supported. Signed-off-by: Joerg Schambacher <joerg(a)hifiberry.com> --- sound/soc/codecs/Kconfig | 8 + sound/soc/codecs/Makefile | 2 + sound/soc/codecs/tas5754m.c | 700 ++++++++++++++++++++++++++++++++++++ sound/soc/codecs/tas5754m.h | 260 ++++++++++++++ 4 files changed, 970 insertions(+) create mode 100644 sound/soc/codecs/tas5754m.c create mode 100644 sound/soc/codecs/tas5754m.h diff --git a/sound/soc/codecs/Kconfig b/sound/soc/codecs/Kconfig index 82ee233a269d..cf0584948fcf 100644 --- a/sound/soc/codecs/Kconfig +++ b/sound/soc/codecs/Kconfig @@ -210,6 +210,7 @@ config SND_SOC_ALL_CODECS imply SND_SOC_TAS5086 imply SND_SOC_TAS571X imply SND_SOC_TAS5720 + imply SND_SOC_TAS5754M imply SND_SOC_TAS6424 imply SND_SOC_TDA7419 imply SND_SOC_TFA9879 @@ -1419,6 +1420,13 @@ config SND_SOC_TAS5720 Enable support for Texas Instruments TAS5720L/M high-efficiency mono Class-D audio power amplifiers. +config SND_SOC_TAS5754M + tristate "Texas Instruments TAS5754M Digital Input Audio amplifier" + depends on I2C + help + Enable support for Texas Instruments TAS5754M digital input + Class-D audio power amplifiers. + config SND_SOC_TAS6424 tristate "Texas Instruments TAS6424 Quad-Channel Audio amplifier" depends on I2C diff --git a/sound/soc/codecs/Makefile b/sound/soc/codecs/Makefile index 8dcea2c4604a..39984900258a 100644 --- a/sound/soc/codecs/Makefile +++ b/sound/soc/codecs/Makefile @@ -227,6 +227,7 @@ snd-soc-sti-sas-objs := sti-sas.o snd-soc-tas5086-objs := tas5086.o snd-soc-tas571x-objs := tas571x.o snd-soc-tas5720-objs := tas5720.o +snd-soc-tas5754m-objs := tas5754m.o snd-soc-tas6424-objs := tas6424.o snd-soc-tda7419-objs := tda7419.o snd-soc-tas2770-objs := tas2770.o @@ -555,6 +556,7 @@ obj-$(CONFIG_SND_SOC_TAS2764) += snd-soc-tas2764.o obj-$(CONFIG_SND_SOC_TAS5086) += snd-soc-tas5086.o obj-$(CONFIG_SND_SOC_TAS571X) += snd-soc-tas571x.o obj-$(CONFIG_SND_SOC_TAS5720) += snd-soc-tas5720.o +obj-$(CONFIG_SND_SOC_TAS5754M) += snd-soc-tas5754m.o obj-$(CONFIG_SND_SOC_TAS6424) += snd-soc-tas6424.o obj-$(CONFIG_SND_SOC_TDA7419) += snd-soc-tda7419.o obj-$(CONFIG_SND_SOC_TAS2770) += snd-soc-tas2770.o diff --git a/sound/soc/codecs/tas5754m.c b/sound/soc/codecs/tas5754m.c new file mode 100644 index 000000000000..7aab9d29c46d --- /dev/null +++ b/sound/soc/codecs/tas5754m.c @@ -0,0 +1,700 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Driver for the TAS5754M Audio Amplifier + * + * Author: Joerg Schambacher <joerg(a)hifiberry.com> + * with fragments from Andy Liu <andy-liu(a)ti.com> + * + * The driver supports I2S master mode only with standard audio + * frequencies 44.1 to 192 ksps from a 24.576/22.2592MHz master + * clock input + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * version 2 as published by the Free Software Foundation. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + */ + +#include <linux/module.h> +#include <linux/moduleparam.h> +#include <linux/clk.h> +#include <linux/slab.h> +#include <linux/of.h> +#include <linux/init.h> +#include <linux/i2c.h> +#include <linux/regmap.h> +#include <linux/delay.h> + +#include <sound/tlv.h> +#include <sound/soc.h> +#include <sound/pcm.h> +#include <sound/pcm_params.h> +#include <sound/initval.h> + +#include "tas5754m.h" + +#define TAS5754M_RATES (SNDRV_PCM_RATE_48000 | \ + SNDRV_PCM_RATE_96000 | \ + SNDRV_PCM_RATE_192000 | \ + SNDRV_PCM_RATE_44100 | \ + SNDRV_PCM_RATE_88200 | \ + SNDRV_PCM_RATE_176400) +#define TAS5754M_FORMATS (SNDRV_PCM_FMTBIT_S16_LE | \ + SNDRV_PCM_FMTBIT_S20_LE | \ + SNDRV_PCM_FMTBIT_S24_LE | \ + SNDRV_PCM_FMTBIT_S32_LE) + + +static const struct reg_default tas5754m_reg_defaults[] = { + { TAS5754M_RESET, 0x00 }, + { TAS5754M_POWER, 0x00 }, + { TAS5754M_MUTE, 0x00 }, + { TAS5754M_DSP, 0x00 }, + { TAS5754M_PLL_REF, 0x00 }, + { TAS5754M_DAC_REF, 0x00 }, + { TAS5754M_DAC_ROUTING, 0x11 }, + { TAS5754M_DSP_PROGRAM, 0x01 }, + { TAS5754M_CLKDET, 0x00 }, + { TAS5754M_AUTO_MUTE, 0x00 }, + { TAS5754M_ERROR_DETECT, 0x00 }, + { TAS5754M_DIGITAL_VOLUME_1, 0x00 }, + { TAS5754M_DIGITAL_VOLUME_2, 0x30 }, + { TAS5754M_DIGITAL_VOLUME_3, 0x30 }, + { TAS5754M_DIGITAL_MUTE_1, 0x22 }, + { TAS5754M_DIGITAL_MUTE_2, 0x00 }, + { TAS5754M_DIGITAL_MUTE_3, 0x07 }, + { TAS5754M_OUTPUT_AMPLITUDE, 0x00 }, + { TAS5754M_ANALOG_GAIN_CTRL, 0x00 }, + { TAS5754M_UNDERVOLTAGE_PROT, 0x00 }, + { TAS5754M_ANALOG_MUTE_CTRL, 0x00 }, + { TAS5754M_ANALOG_GAIN_BOOST, 0x00 }, + { TAS5754M_VCOM_CTRL_1, 0x00 }, + { TAS5754M_VCOM_CTRL_2, 0x01 }, + { TAS5754M_BCLK_LRCLK_CFG, 0x00 }, + { TAS5754M_MASTER_MODE, 0x7c }, + { TAS5754M_GPIO_PLLIN, 0x00 }, + { TAS5754M_SYNCHRONIZE, 0x10 }, + { TAS5754M_PLL_COEFF_P, 0x00 }, + { TAS5754M_PLL_COEFF_J, 0x00 }, + { TAS5754M_PLL_COEFF_DH, 0x00 }, + { TAS5754M_PLL_COEFF_DL, 0x00 }, + { TAS5754M_PLL_COEFF_R, 0x00 }, + { TAS5754M_DSP_CLKDIV, 0x00 }, + { TAS5754M_DAC_CLKDIV, 0x00 }, + { TAS5754M_NCP_CLKDIV, 0x00 }, + { TAS5754M_OSR_CLKDIV, 0x00 }, + { TAS5754M_MASTER_SCLKDIV, 0x00 }, + { TAS5754M_MASTER_LRCLKDIV, 0x00 }, + { TAS5754M_FS_SPEED_MODE, 0x00 }, + { TAS5754M_IDAC_1, 0x01 }, + { TAS5754M_IDAC_2, 0x00 }, +}; + +static bool tas5754m_readable(struct device *dev, unsigned int reg) +{ + switch (reg) { + case TAS5754M_RESET: + case TAS5754M_POWER: + case TAS5754M_MUTE: + case TAS5754M_PLL_EN: + case TAS5754M_DSP: + case TAS5754M_GPIO_EN: + case TAS5754M_BCLK_LRCLK_CFG: + case TAS5754M_DSP_GPIO_INPUT: + case TAS5754M_MASTER_MODE: + case TAS5754M_PLL_REF: + case TAS5754M_DAC_REF: + case TAS5754M_GPIO_PLLIN: + case TAS5754M_SYNCHRONIZE: + case TAS5754M_PLL_COEFF_P: + case TAS5754M_PLL_COEFF_J: + case TAS5754M_PLL_COEFF_DH: + case TAS5754M_PLL_COEFF_DL: + case TAS5754M_PLL_COEFF_R: + case TAS5754M_DSP_CLKDIV: + case TAS5754M_DAC_CLKDIV: + case TAS5754M_NCP_CLKDIV: + case TAS5754M_OSR_CLKDIV: + case TAS5754M_MASTER_SCLKDIV: + case TAS5754M_MASTER_LRCLKDIV: + case TAS5754M_FS_SPEED_MODE: + case TAS5754M_IDAC_1: + case TAS5754M_IDAC_2: + case TAS5754M_ERROR_DETECT: + case TAS5754M_I2S_1: + case TAS5754M_I2S_2: + case TAS5754M_DAC_ROUTING: + case TAS5754M_DSP_PROGRAM: + case TAS5754M_CLKDET: + case TAS5754M_AUTO_MUTE: + case TAS5754M_DIGITAL_VOLUME_1: + case TAS5754M_DIGITAL_VOLUME_2: + case TAS5754M_DIGITAL_VOLUME_3: + case TAS5754M_DIGITAL_MUTE_1: + case TAS5754M_DIGITAL_MUTE_2: + case TAS5754M_DIGITAL_MUTE_3: + case TAS5754M_GPIO_OUTPUT_0: + case TAS5754M_GPIO_OUTPUT_1: + case TAS5754M_GPIO_OUTPUT_2: + case TAS5754M_GPIO_CONTROL_1: + case TAS5754M_GPIO_CONTROL_2: + case TAS5754M_OVERFLOW: + case TAS5754M_RATE_DET_1: + case TAS5754M_RATE_DET_2: + case TAS5754M_RATE_DET_3: + case TAS5754M_RATE_DET_4: + case TAS5754M_CLOCK_STATUS: + case TAS5754M_ANALOG_MUTE_DET: + case TAS5754M_GPIN: + case TAS5754M_DIGITAL_MUTE_DET: + case TAS5754M_OUTPUT_AMPLITUDE: + case TAS5754M_ANALOG_GAIN_CTRL: + case TAS5754M_UNDERVOLTAGE_PROT: + case TAS5754M_ANALOG_MUTE_CTRL: + case TAS5754M_ANALOG_GAIN_BOOST: + case TAS5754M_VCOM_CTRL_1: + case TAS5754M_VCOM_CTRL_2: + case TAS5754M_CRAM_CTRL: + case TAS5754M_FLEX_A: + case TAS5754M_FLEX_B: + return true; + default: + return reg < 0x7f; + } +} + +static bool tas5754m_volatile(struct device *dev, unsigned int reg) +{ + switch (reg) { + case TAS5754M_PLL_EN: + case TAS5754M_OVERFLOW: + case TAS5754M_RATE_DET_1: + case TAS5754M_RATE_DET_2: + case TAS5754M_RATE_DET_3: + case TAS5754M_RATE_DET_4: + case TAS5754M_CLOCK_STATUS: + case TAS5754M_ANALOG_MUTE_DET: + case TAS5754M_GPIN: + case TAS5754M_DIGITAL_MUTE_DET: + case TAS5754M_CRAM_CTRL: + return true; + default: + return reg < 0x7f; + } +} + +struct tas5754m_priv { + struct regmap *regmap; + struct clk *sclk; + int sample_len; + int fmt; + int mode; +}; + +static const struct regmap_range_cfg tas5754m_range = { + .name = "Pages", + .range_min = TAS5754M_VIRT_BASE, + .range_max = TAS5754M_MAX_REGISTER, + .selector_reg = TAS5754M_PAGE, + .selector_mask = 0x7f, + .window_start = 0, + .window_len = 128, +}; + +const struct regmap_config tas5754m_regmap = { + .reg_bits = 8, + .val_bits = 8, + + .ranges = &tas5754m_range, + .num_ranges = 1, + .max_register = TAS5754M_MAX_REGISTER, + + .reg_defaults = tas5754m_reg_defaults, + .num_reg_defaults = ARRAY_SIZE(tas5754m_reg_defaults), + .readable_reg = tas5754m_readable, + .volatile_reg = tas5754m_volatile, + + .cache_type = REGCACHE_RBTREE, +}; + +static const DECLARE_TLV_DB_SCALE(digital_tlv, -10350, 50, 1); +static const DECLARE_TLV_DB_SCALE(analog_tlv, -600, 600, 0); +static const DECLARE_TLV_DB_SCALE(boost_tlv, 0, 80, 0); + +static const struct snd_kcontrol_new tas5754m_controls[] = { +SOC_DOUBLE_R_TLV("Digital Playback Volume", TAS5754M_DIGITAL_VOLUME_2, + TAS5754M_DIGITAL_VOLUME_3, 0, 255, 1, digital_tlv), +SOC_DOUBLE_TLV("Analog Playback Volume", TAS5754M_ANALOG_GAIN_CTRL, + TAS5754M_LAGN_SHIFT, TAS5754M_RAGN_SHIFT, 1, 1, analog_tlv), +SOC_DOUBLE_TLV("Analogue Playback Boost Volume", TAS5754M_ANALOG_GAIN_BOOST, + TAS5754M_AGBL_SHIFT, TAS5754M_AGBR_SHIFT, 1, 0, boost_tlv), +}; + +static int tas5754m_set_bias_level(struct snd_soc_component *component, + enum snd_soc_bias_level level) +{ + struct tas5754m_priv *tas5754m = + snd_soc_component_get_drvdata(component); + int ret; + + switch (level) { + case SND_SOC_BIAS_ON: + case SND_SOC_BIAS_PREPARE: + break; + + case SND_SOC_BIAS_STANDBY: + ret = regmap_update_bits(tas5754m->regmap, + TAS5754M_POWER, TAS5754M_RQST, 0); + if (ret != 0) { + dev_err(component->dev, + "Failed to remove standby: %d\n", ret); + return ret; + } + break; + + case SND_SOC_BIAS_OFF: + ret = regmap_update_bits(tas5754m->regmap, + TAS5754M_POWER, TAS5754M_RQST, TAS5754M_RQST); + if (ret != 0) { + dev_err(component->dev, + "Failed to request standby: %d\n", ret); + return ret; + } + break; + } + + return 0; +} + +int tas5754m_set_clock_tree_master(struct snd_soc_dai *dai, + struct snd_pcm_hw_params *params) +{ + struct snd_soc_component *component = dai->component; + struct tas5754m_priv *tas5754m = + snd_soc_component_get_drvdata(component); + static const struct reg_sequence pll_settings[] = { + { TAS5754M_PLL_COEFF_P, 0x01 }, // P=2 + { TAS5754M_PLL_COEFF_J, 0x08 }, // J=8 + { TAS5754M_PLL_COEFF_DL, 0x00 }, // D12-8 = 0 + { TAS5754M_PLL_COEFF_DH, 0x00 }, // D7-0 = 0 + { TAS5754M_PLL_COEFF_R, 0x00 }, // R=1 + }; + int ret; + + /* disable PLL before any clock tree change */ + ret = regmap_update_bits(tas5754m->regmap, TAS5754M_PLL_EN, + TAS5754M_PLLE, 0); + if (ret != 0) { + dev_err(component->dev, "Failed to disable PLL: %d\n", ret); + return ret; + } + + /* set DAC clock source to MCLK */ + ret = regmap_write(tas5754m->regmap, TAS5754M_DAC_REF, 0x30); + if (ret != 0) { + dev_err(component->dev, "Failed to set DAC ref\n"); + return ret; + } + + /* run PLL at fixed ratio to MCLK */ + ret = regmap_multi_reg_write(tas5754m->regmap, pll_settings, + ARRAY_SIZE(pll_settings)); + if (ret != 0) { + dev_err(component->dev, "Failed to set PLL ratio\n"); + return ret; + } + + /* set DSP divider to 2 => reg 0x01 */ + ret = regmap_write(tas5754m->regmap, TAS5754M_DSP_CLKDIV, 1); + if (ret != 0) { + dev_err(component->dev, "Failed to set DSP divider\n"); + return ret; + } + /* set DAC divider to 4 => reg 0x03*/ + ret = regmap_write(tas5754m->regmap, TAS5754M_DAC_CLKDIV, 3); + if (ret != 0) { + dev_err(component->dev, "Failed to set OSDACR divider\n"); + return ret; + } + /* set OSR divider to 1 */ + ret = regmap_write(tas5754m->regmap, TAS5754M_OSR_CLKDIV, 0); + if (ret != 0) { + dev_err(component->dev, "Failed to set OSR divider\n"); + return ret; + } + /* set CP divider to 4 => reg 0x03*/ + ret = regmap_write(tas5754m->regmap, TAS5754M_NCP_CLKDIV, 3); + if (ret != 0) { + dev_err(component->dev, "Failed to set CP divider\n"); + return ret; + } + /* finally enable PLL */ + ret = regmap_update_bits(tas5754m->regmap, TAS5754M_PLL_EN, + TAS5754M_PLLE, 1); + if (ret != 0) { + dev_err(component->dev, "Failed to enable PLL: %d\n", ret); + return ret; + } + + return 0; +} + +int tas5754m_set_dai_mode(struct snd_soc_dai *dai) +{ + struct snd_soc_component *component = dai->component; + struct tas5754m_priv *tas5754m = + snd_soc_component_get_drvdata(component); + int fmt = tas5754m->fmt; + + /* only I2S MASTER mode implemented */ + if (((fmt & SND_SOC_DAIFMT_FORMAT_MASK) != SND_SOC_DAIFMT_I2S)) { + dev_err(component->dev, + "DAI format not supported (I2S master only)\n"); + return -EINVAL; + } + /* TAS5754/6m do not support inverted clocks in MASTER mode */ + if (((fmt & SND_SOC_DAIFMT_CLOCK_MASK) != SND_SOC_DAIFMT_NB_NF)) { + dev_err(component->dev, "Inverted clocks not supported\n"); + return -EINVAL; + } + + switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) { + case SND_SOC_DAIFMT_CBM_CFM: + regmap_update_bits(tas5754m->regmap, + TAS5754M_BCLK_LRCLK_CFG, + TAS5754M_LRKO | TAS5754M_BCKO, + TAS5754M_LRKO | TAS5754M_BCKO); + /* reset CLK dividers */ + regmap_update_bits(tas5754m->regmap, + TAS5754M_MASTER_MODE, + 0x00, + TAS5754M_RLRK | TAS5754M_RBCK); + /* ignore all clock error detection but MCLK */ + regmap_update_bits(tas5754m->regmap, + TAS5754M_ERROR_DETECT, + TAS5754M_IPLK | TAS5754M_DCAS | + TAS5754M_IDCM | TAS5754M_IDSK | + TAS5754M_IDBK | TAS5754M_IDFS, + TAS5754M_IPLK | TAS5754M_DCAS | + TAS5754M_IDCM | TAS5754M_IDSK | + TAS5754M_IDBK | TAS5754M_IDFS); + break; + case SND_SOC_DAIFMT_CBS_CFS: + case SND_SOC_DAIFMT_CBM_CFS: + default: + return -EINVAL; + } + + return 0; +} + +int tas5754m_set_dividers_master(struct snd_soc_dai *dai, + struct snd_pcm_hw_params *params) +{ + struct snd_soc_component *component = dai->component; + struct tas5754m_priv *tas5754m = + snd_soc_component_get_drvdata(component); + unsigned long bclk; + unsigned long mclk; + int bclk_div; + int lrclk_div; + int osr; + int ret; + + mclk = clk_get_rate(tas5754m->sclk); + bclk = tas5754m->sample_len * 2 * params_rate(params); + bclk_div = mclk / bclk; + lrclk_div = tas5754m->sample_len * 2; + osr = mclk / 4 / params_rate(params) / 16; + + // stop LR / SCLK clocks + ret = regmap_update_bits(tas5754m->regmap, + TAS5754M_MASTER_MODE, + !TAS5754M_RLRK | !TAS5754M_RBCK, + TAS5754M_RLRK | TAS5754M_RBCK); + if (ret != 0) { + dev_err(component->dev, "Failed to stop PLL\n"); + return ret; + } + + // set SCLK divider + ret = regmap_write(tas5754m->regmap, TAS5754M_MASTER_SCLKDIV, + bclk_div - 1); + if (ret != 0) { + dev_err(component->dev, "Failed to set SCLK divider\n"); + return ret; + } + + // set LRCLK divider + ret = regmap_write(tas5754m->regmap, TAS5754M_MASTER_LRCLKDIV, + lrclk_div - 1); + if (ret != 0) { + dev_err(component->dev, "Failed to set LRCLK divider\n"); + return ret; + } + + ret = regmap_write(tas5754m->regmap, + TAS5754M_OSR_CLKDIV, osr - 1); + if (ret != 0) { + dev_err(component->dev, "Failed to set OSR divider\n"); + return ret; + } + + // restart LR / SCLK clocks + ret = regmap_update_bits(tas5754m->regmap, + TAS5754M_MASTER_MODE, + TAS5754M_RLRK | TAS5754M_RBCK, + TAS5754M_RLRK | TAS5754M_RBCK); + if (ret != 0) { + dev_err(component->dev, "Failed to restart PLL\n"); + return ret; + } + + return 0; +} + +static int tas5754m_hw_params(struct snd_pcm_substream *substream, + struct snd_pcm_hw_params *params, + struct snd_soc_dai *dai) +{ + struct snd_soc_component *component = dai->component; + struct tas5754m_priv *tas5754m = + snd_soc_component_get_drvdata(component); + int alen; + int ret; + + switch (params_width(params)) { + case 16: + tas5754m->sample_len = 16; + alen = TAS5754M_ALEN_16; + break; + case 20: + tas5754m->sample_len = 32; + alen = TAS5754M_ALEN_20; + break; + case 24: + tas5754m->sample_len = 32; + alen = TAS5754M_ALEN_24; + break; + case 32: + tas5754m->sample_len = 32; + alen = TAS5754M_ALEN_32; + break; + default: + dev_err(component->dev, "Unsupported sample size: %d\n", + params_width(params)); + return -EINVAL; + } + ret = regmap_update_bits(tas5754m->regmap, TAS5754M_I2S_1, alen, alen); + if (ret != 0) { + dev_err(component->dev, + "Cannot set sample size: %d\n", ret); + return ret; + } + + ret = tas5754m_set_dai_mode(dai); + if (ret != 0) { + dev_err(component->dev, + "DAI mode not supported: %d\n", ret); + return ret; + } + + ret = tas5754m_set_clock_tree_master(dai, params); + if (ret != 0) + return ret; + + switch (params_rate(params)) { + case 44100: + case 48000: + ret = regmap_write(tas5754m->regmap, + TAS5754M_FS_SPEED_MODE, TAS5754M_FSSP_48KHZ); + break; + case 88200: + case 96000: + ret = regmap_write(tas5754m->regmap, + TAS5754M_FS_SPEED_MODE, TAS5754M_FSSP_96KHZ); + break; + case 176400: + case 192000: + ret = regmap_write(tas5754m->regmap, + TAS5754M_FS_SPEED_MODE, TAS5754M_FSSP_192KHZ); + break; + default: + dev_err(component->dev, "Sample rate not supported: %d\n", + params_rate(params)); + return -EINVAL; + } + if (ret != 0) { + dev_err(component->dev, "Failed to config PLL\n"); + return ret; + } + + ret = tas5754m_set_dividers_master(dai, params); + if (ret != 0) + return ret; + + return 0; +} + +static int tas5754m_set_fmt(struct snd_soc_dai *dai, unsigned int fmt) +{ + struct snd_soc_component *component = dai->component; + struct tas5754m_priv *tas5754m = + snd_soc_component_get_drvdata(component); + + tas5754m->fmt = fmt; + + return 0; +} + + +static const struct snd_soc_component_driver tas5754m_soc_component = { + .set_bias_level = tas5754m_set_bias_level, + .idle_bias_on = true, + .controls = tas5754m_controls, + .num_controls = ARRAY_SIZE(tas5754m_controls), +}; + +static int tas5754m_mute(struct snd_soc_dai *dai, int mute, int stream) +{ + struct snd_soc_component *component = dai->component; + + if (mute) { + snd_soc_component_write(component, TAS5754M_MUTE, 0x11); + } else { + /* wait for stable operation before unmute */ + usleep_range(1000, 2000); + snd_soc_component_write(component, TAS5754M_MUTE, 0x00); + } + return 0; +} + +static const struct snd_soc_dai_ops tas5754m_dai_ops = { + .mute_stream = tas5754m_mute, + .hw_params = tas5754m_hw_params, + .set_fmt = tas5754m_set_fmt, +}; + +static struct snd_soc_dai_driver tas5754m_dai = { + .name = "tas5754m-amplifier", + .playback = { + .stream_name = "Playback", + .channels_min = 2, + .channels_max = 2, + .rates = TAS5754M_RATES, + .formats = TAS5754M_FORMATS, + }, + .ops = &tas5754m_dai_ops, +}; + +static int tas5754m_probe(struct device *dev, struct regmap *regmap) +{ + struct tas5754m_priv *tas5754m; + int ret; + + tas5754m = devm_kzalloc(dev, sizeof(struct tas5754m_priv), GFP_KERNEL); + if (!tas5754m) + return -ENOMEM; + + dev_set_drvdata(dev, tas5754m); + tas5754m->regmap = regmap; + + regmap_write(regmap, TAS5754M_RESET, TAS5754M_RSTR | TAS5754M_RSTM); + + if (ret != 0) { + dev_err(dev, "Failed to initialize TAS5754M: %d\n", ret); + goto err; + } + + tas5754m->sclk = devm_clk_get(dev, NULL); + if (PTR_ERR(tas5754m->sclk) == -EPROBE_DEFER) { + ret = -EPROBE_DEFER; + goto err; + } + if (!IS_ERR(tas5754m->sclk)) { + ret = clk_prepare_enable(tas5754m->sclk); + if (ret != 0) { + dev_err(dev, "Failed to enable SCLK: %d\n", ret); + goto err; + } + } + + ret = devm_snd_soc_register_component(dev, + &tas5754m_soc_component, &tas5754m_dai, 1); + if (ret != 0) { + dev_err(dev, "Failed to register CODEC: %d\n", ret); + goto err; + } + + return 0; + +err: + return ret; + +} + +static int tas5754m_i2c_probe(struct i2c_client *i2c, const struct i2c_device_id *id) +{ + struct regmap *regmap; + struct regmap_config config = tas5754m_regmap; + + /* enable auto-increment mode */ + config.read_flag_mask = 0x80; + config.write_flag_mask = 0x80; + + regmap = devm_regmap_init_i2c(i2c, &config); + if (IS_ERR(regmap)) + return PTR_ERR(regmap); + + return tas5754m_probe(&i2c->dev, regmap); +} + +static int tas5754m_remove(struct device *dev) +{ + snd_soc_unregister_component(dev); + + return 0; +} + +static int tas5754m_i2c_remove(struct i2c_client *i2c) +{ + tas5754m_remove(&i2c->dev); + + return 0; +} + +static const struct i2c_device_id tas5754m_i2c_id[] = { + { "tas5754m", }, + { "tas5756m", }, + { } +}; +MODULE_DEVICE_TABLE(i2c, tas5754m_i2c_id); + +#ifdef CONFIG_OF +static const struct of_device_id tas5754m_of_match[] = { + { .compatible = "ti,tas5754m", }, + { .compatible = "ti,tas5756m", }, + { } +}; +MODULE_DEVICE_TABLE(of, tas5754m_of_match); +#endif + +static struct i2c_driver tas5754m_i2c_driver = { + .probe = tas5754m_i2c_probe, + .remove = tas5754m_i2c_remove, + .id_table = tas5754m_i2c_id, + .driver = { + .name = "tas5754m", + .of_match_table = of_match_ptr(tas5754m_of_match), + }, +}; + +module_i2c_driver(tas5754m_i2c_driver); + +MODULE_AUTHOR("Joerg Schambacher <joerg(a)hifiberry.com>"); +MODULE_DESCRIPTION("TAS5754M Audio Amplifier Driver - Master mode only"); +MODULE_LICENSE("GPL"); diff --git a/sound/soc/codecs/tas5754m.h b/sound/soc/codecs/tas5754m.h new file mode 100644 index 000000000000..c6e26dba169f --- /dev/null +++ b/sound/soc/codecs/tas5754m.h @@ -0,0 +1,260 @@ +/* SPDX-License-Identifier: GPL-2.0-only */ +/* + * Driver for the TAS575xM DAC+amplifier combo devices + * + * Author: (copied from pcm512x.h) + * Mark Brown <broonie(a)kernel.org> + * Copyright 2014 Linaro Ltd + * + * Register names adapted and non available + * register definitions removed according + + to TAS5754M specification + * Joerg Schambacher <joerg(a)hifiberry.com> + */ + +#ifndef _SND_SOC_TAS5754M +#define _SND_SOC_TAS5754M + +#include <linux/pm.h> +#include <linux/regmap.h> + +#define TAS5754M_VIRT_BASE 0x000 +#define TAS5754M_PAGE_LEN 0x80 +#define TAS5754M_PAGE_BASE(n) (TAS5754M_VIRT_BASE + (TAS5754M_PAGE_LEN * n)) + +#define TAS5754M_PAGE 0 + +#define TAS5754M_RESET (TAS5754M_PAGE_BASE(0) + 1) +#define TAS5754M_POWER (TAS5754M_PAGE_BASE(0) + 2) +#define TAS5754M_MUTE (TAS5754M_PAGE_BASE(0) + 3) +#define TAS5754M_PLL_EN (TAS5754M_PAGE_BASE(0) + 4) +#define TAS5754M_DSP (TAS5754M_PAGE_BASE(0) + 7) +#define TAS5754M_GPIO_EN (TAS5754M_PAGE_BASE(0) + 8) +#define TAS5754M_BCLK_LRCLK_CFG (TAS5754M_PAGE_BASE(0) + 9) +#define TAS5754M_DSP_GPIO_INPUT (TAS5754M_PAGE_BASE(0) + 10) +#define TAS5754M_MASTER_MODE (TAS5754M_PAGE_BASE(0) + 12) +#define TAS5754M_PLL_REF (TAS5754M_PAGE_BASE(0) + 13) +#define TAS5754M_DAC_REF (TAS5754M_PAGE_BASE(0) + 14) +#define TAS5754M_GPIO_PLLIN (TAS5754M_PAGE_BASE(0) + 18) +#define TAS5754M_SYNCHRONIZE (TAS5754M_PAGE_BASE(0) + 19) +#define TAS5754M_PLL_COEFF_P (TAS5754M_PAGE_BASE(0) + 20) +#define TAS5754M_PLL_COEFF_J (TAS5754M_PAGE_BASE(0) + 21) +#define TAS5754M_PLL_COEFF_DH (TAS5754M_PAGE_BASE(0) + 22) +#define TAS5754M_PLL_COEFF_DL (TAS5754M_PAGE_BASE(0) + 23) +#define TAS5754M_PLL_COEFF_R (TAS5754M_PAGE_BASE(0) + 24) +#define TAS5754M_DSP_CLKDIV (TAS5754M_PAGE_BASE(0) + 27) +#define TAS5754M_DAC_CLKDIV (TAS5754M_PAGE_BASE(0) + 28) +#define TAS5754M_NCP_CLKDIV (TAS5754M_PAGE_BASE(0) + 29) +#define TAS5754M_OSR_CLKDIV (TAS5754M_PAGE_BASE(0) + 30) +#define TAS5754M_MASTER_SCLKDIV (TAS5754M_PAGE_BASE(0) + 32) +#define TAS5754M_MASTER_LRCLKDIV (TAS5754M_PAGE_BASE(0) + 33) +#define TAS5754M_FS_SPEED_MODE (TAS5754M_PAGE_BASE(0) + 34) +#define TAS5754M_IDAC_1 (TAS5754M_PAGE_BASE(0) + 35) +#define TAS5754M_IDAC_2 (TAS5754M_PAGE_BASE(0) + 36) +#define TAS5754M_ERROR_DETECT (TAS5754M_PAGE_BASE(0) + 37) +#define TAS5754M_I2S_1 (TAS5754M_PAGE_BASE(0) + 40) +#define TAS5754M_I2S_2 (TAS5754M_PAGE_BASE(0) + 41) +#define TAS5754M_DAC_ROUTING (TAS5754M_PAGE_BASE(0) + 42) +#define TAS5754M_DSP_PROGRAM (TAS5754M_PAGE_BASE(0) + 43) +#define TAS5754M_CLKDET (TAS5754M_PAGE_BASE(0) + 44) +#define TAS5754M_AUTO_MUTE (TAS5754M_PAGE_BASE(0) + 59) +#define TAS5754M_DIGITAL_VOLUME_1 (TAS5754M_PAGE_BASE(0) + 60) +#define TAS5754M_DIGITAL_VOLUME_2 (TAS5754M_PAGE_BASE(0) + 61) +#define TAS5754M_DIGITAL_VOLUME_3 (TAS5754M_PAGE_BASE(0) + 62) +#define TAS5754M_DIGITAL_MUTE_1 (TAS5754M_PAGE_BASE(0) + 63) +#define TAS5754M_DIGITAL_MUTE_2 (TAS5754M_PAGE_BASE(0) + 64) +#define TAS5754M_DIGITAL_MUTE_3 (TAS5754M_PAGE_BASE(0) + 65) +#define TAS5754M_GPIO_OUTPUT_1 (TAS5754M_PAGE_BASE(0) + 82) +#define TAS5754M_GPIO_OUTPUT_0 (TAS5754M_PAGE_BASE(0) + 83) +#define TAS5754M_GPIO_OUTPUT_2 (TAS5754M_PAGE_BASE(0) + 85) +#define TAS5754M_GPIO_CONTROL_1 (TAS5754M_PAGE_BASE(0) + 86) +#define TAS5754M_GPIO_CONTROL_2 (TAS5754M_PAGE_BASE(0) + 87) +#define TAS5754M_OVERFLOW (TAS5754M_PAGE_BASE(0) + 90) +#define TAS5754M_RATE_DET_1 (TAS5754M_PAGE_BASE(0) + 91) +#define TAS5754M_RATE_DET_2 (TAS5754M_PAGE_BASE(0) + 92) +#define TAS5754M_RATE_DET_3 (TAS5754M_PAGE_BASE(0) + 93) +#define TAS5754M_RATE_DET_4 (TAS5754M_PAGE_BASE(0) + 94) +#define TAS5754M_CLOCK_STATUS (TAS5754M_PAGE_BASE(0) + 95) +#define TAS5754M_ANALOG_MUTE_DET (TAS5754M_PAGE_BASE(0) + 108) +#define TAS5754M_FS_MODE_MON (TAS5754M_PAGE_BASE(0) + 115) +#define TAS5754M_GPIN (TAS5754M_PAGE_BASE(0) + 119) +#define TAS5754M_DIGITAL_MUTE_DET (TAS5754M_PAGE_BASE(0) + 120) + +#define TAS5754M_OUTPUT_AMPLITUDE (TAS5754M_PAGE_BASE(1) + 1) +#define TAS5754M_ANALOG_GAIN_CTRL (TAS5754M_PAGE_BASE(1) + 2) +#define TAS5754M_UNDERVOLTAGE_PROT (TAS5754M_PAGE_BASE(1) + 5) +#define TAS5754M_ANALOG_MUTE_CTRL (TAS5754M_PAGE_BASE(1) + 6) +#define TAS5754M_ANALOG_GAIN_BOOST (TAS5754M_PAGE_BASE(1) + 7) +#define TAS5754M_VCOM_CTRL_1 (TAS5754M_PAGE_BASE(1) + 8) +#define TAS5754M_VCOM_CTRL_2 (TAS5754M_PAGE_BASE(1) + 9) + +#define TAS5754M_CRAM_CTRL (TAS5754M_PAGE_BASE(44) + 1) + +#define TAS5754M_FLEX_A (TAS5754M_PAGE_BASE(253) + 63) +#define TAS5754M_FLEX_B (TAS5754M_PAGE_BASE(253) + 64) + +#define TAS5754M_MAX_REGISTER (TAS5754M_PAGE_BASE(253) + 64) + +/* Page 0, Register 1 - reset */ +#define TAS5754M_RSTR (1 << 0) +#define TAS5754M_RSTM (1 << 4) + +/* Page 0, Register 2 - power */ +#define TAS5754M_RQPD (1 << 0) +#define TAS5754M_RQPD_SHIFT 0 +#define TAS5754M_RQST (1 << 4) +#define TAS5754M_RQST_SHIFT 4 + +/* Page 0, Register 3 - mute */ +#define TAS5754M_RQMR (1 << 0) +#define TAS5754M_RQMR_SHIFT 0 +#define TAS5754M_RQML (1 << 4) +#define TAS5754M_RQML_SHIFT 4 + +/* Page 0, Register 4 - PLL */ +#define TAS5754M_PLLE (1 << 0) +#define TAS5754M_PLLE_SHIFT 0 +#define TAS5754M_PLCK (1 << 4) +#define TAS5754M_PLCK_SHIFT 4 + +/* Page 0, Register 7 - DSP */ +#define TAS5754M_SDSL (1 << 0) +#define TAS5754M_SDSL_SHIFT 0 +#define TAS5754M_DEMP (1 << 4) +#define TAS5754M_DEMP_SHIFT 4 + +/* Page 0, Register 8 - GPIO output enable */ +#define TAS5754M_G1OE (1 << 0) +#define TAS5754M_G2OE (1 << 1) +#define TAS5754M_G3OE (1 << 2) +#define TAS5754M_G4OE (1 << 3) +#define TAS5754M_G5OE (1 << 4) +#define TAS5754M_G6OE (1 << 5) + +/* Page 0, Register 9 - BCK, LRCLK configuration */ +#define TAS5754M_LRKO (1 << 0) +#define TAS5754M_LRKO_SHIFT 0 +#define TAS5754M_BCKO (1 << 4) +#define TAS5754M_BCKO_SHIFT 4 +#define TAS5754M_BCKP (1 << 5) +#define TAS5754M_BCKP_SHIFT 5 + +/* Page 0, Register 12 - Master mode BCK, LRCLK reset */ +#define TAS5754M_RLRK (1 << 0) +#define TAS5754M_RLRK_SHIFT 0 +#define TAS5754M_RBCK (1 << 1) +#define TAS5754M_RBCK_SHIFT 1 + +/* Page 0, Register 13 - PLL reference */ +#define TAS5754M_SREF (7 << 4) +#define TAS5754M_SREF_SHIFT 4 +#define TAS5754M_SREF_SCK (0 << 4) +#define TAS5754M_SREF_BCK (1 << 4) +#define TAS5754M_SREF_GPIO (3 << 4) + +/* Page 0, Register 14 - DAC reference */ +#define TAS5754M_SDAC (7 << 4) +#define TAS5754M_SDAC_SHIFT 4 +#define TAS5754M_SDAC_MCK (0 << 4) +#define TAS5754M_SDAC_PLL (1 << 4) +#define TAS5754M_SDAC_SCK (3 << 4) +#define TAS5754M_SDAC_BCK (4 << 4) +#define TAS5754M_SDAC_GPIO (5 << 4) + +/* Page 0, Register 16, 18 - GPIO source for DAC, PLL */ +#define TAS5754M_GREF (7 << 0) +#define TAS5754M_GREF_SHIFT 0 +#define TAS5754M_GREF_GPIO1 (0 << 0) +#define TAS5754M_GREF_GPIO2 (1 << 0) +#define TAS5754M_GREF_GPIO3 (2 << 0) +#define TAS5754M_GREF_GPIO4 (3 << 0) +#define TAS5754M_GREF_GPIO5 (4 << 0) +#define TAS5754M_GREF_GPIO6 (5 << 0) + +/* Page 0, Register 19 - synchronize */ +#define TAS5754M_RQSY (1 << 0) +#define TAS5754M_RQSY_RESUME (0 << 0) +#define TAS5754M_RQSY_HALT (1 << 0) + +/* Page 0, Register 34 - fs speed mode */ +#define TAS5754M_FSSP (3 << 0) +#define TAS5754M_FSSP_SHIFT 0 +#define TAS5754M_FSSP_48KHZ (0 << 0) +#define TAS5754M_FSSP_96KHZ (1 << 0) +#define TAS5754M_FSSP_192KHZ (2 << 0) +#define TAS5754M_FSSP_384KHZ (3 << 0) + +/* Page 0, Register 37 - Error detection */ +#define TAS5754M_IPLK (1 << 0) +#define TAS5754M_DCAS (1 << 1) +#define TAS5754M_IDCM (1 << 2) +#define TAS5754M_IDCH (1 << 3) +#define TAS5754M_IDSK (1 << 4) +#define TAS5754M_IDBK (1 << 5) +#define TAS5754M_IDFS (1 << 6) + +/* Page 0, Register 40 - I2S configuration */ +#define TAS5754M_ALEN (3 << 0) +#define TAS5754M_ALEN_SHIFT 0 +#define TAS5754M_ALEN_16 (0 << 0) +#define TAS5754M_ALEN_20 (1 << 0) +#define TAS5754M_ALEN_24 (2 << 0) +#define TAS5754M_ALEN_32 (3 << 0) +#define TAS5754M_AFMT (3 << 4) +#define TAS5754M_AFMT_SHIFT 4 +#define TAS5754M_AFMT_I2S (0 << 4) +#define TAS5754M_AFMT_DSP (1 << 4) +#define TAS5754M_AFMT_RTJ (2 << 4) +#define TAS5754M_AFMT_LTJ (3 << 4) + +/* Page 0, Register 42 - DAC routing */ +#define TAS5754M_AUPR_SHIFT 0 +#define TAS5754M_AUPL_SHIFT 4 + +/* Page 0, Register 59 - auto mute */ +#define TAS5754M_ATMR_SHIFT 0 +#define TAS5754M_ATML_SHIFT 4 + +/* Page 0, Register 63 - ramp rates */ +#define TAS5754M_VNDF_SHIFT 6 +#define TAS5754M_VNDS_SHIFT 4 +#define TAS5754M_VNUF_SHIFT 2 +#define TAS5754M_VNUS_SHIFT 0 + +/* Page 0, Register 64 - emergency ramp rates */ +#define TAS5754M_VEDF_SHIFT 6 +#define TAS5754M_VEDS_SHIFT 4 + +/* Page 0, Register 65 - Digital mute enables */ +#define TAS5754M_ACTL_SHIFT 2 +#define TAS5754M_AMLE_SHIFT 1 +#define TAS5754M_AMRE_SHIFT 0 + +/* Page 0, Register 80-85, GPIO output selection */ +#define TAS5754M_GxSL (31 << 0) +#define TAS5754M_GxSL_SHIFT 0 +#define TAS5754M_GxSL_OFF (0 << 0) +#define TAS5754M_GxSL_DSP (1 << 0) +#define TAS5754M_GxSL_REG (2 << 0) +#define TAS5754M_GxSL_AMUTB (3 << 0) +#define TAS5754M_GxSL_AMUTL (4 << 0) +#define TAS5754M_GxSL_AMUTR (5 << 0) +#define TAS5754M_GxSL_CLKI (6 << 0) +#define TAS5754M_GxSL_SDOUT (7 << 0) +#define TAS5754M_GxSL_ANMUL (8 << 0) +#define TAS5754M_GxSL_ANMUR (9 << 0) +#define TAS5754M_GxSL_PLLLK (10 << 0) +#define TAS5754M_GxSL_CPCLK (11 << 0) +#define TAS5754M_GxSL_UV0_7 (14 << 0) +#define TAS5754M_GxSL_UV0_3 (15 << 0) +#define TAS5754M_GxSL_PLLCK (16 << 0) + +/* Page 1, Register 2 - analog volume control */ +#define TAS5754M_RAGN_SHIFT 0 +#define TAS5754M_LAGN_SHIFT 4 + +/* Page 1, Register 7 - analog boost control */ +#define TAS5754M_AGBR_SHIFT 0 +#define TAS5754M_AGBL_SHIFT 4 + +#endif -- 2.25.1

3 4

[PATCH] ALSA: core: Simplify snd_power_ref_and_wait() with the standard macro
by Takashi Iwai 19 Jan '22

19 Jan '22

Use wait_event_cmd() macro and simplify snd_power_ref_wait() implementation. This may also cover possible races in the current open code, too. Signed-off-by: Takashi Iwai <tiwai(a)suse.de> --- sound/core/init.c | 25 +++++-------------------- 1 file changed, 5 insertions(+), 20 deletions(-) diff --git a/sound/core/init.c b/sound/core/init.c index ac335f5906c6..31ba7024e3ad 100644 --- a/sound/core/init.c +++ b/sound/core/init.c @@ -1111,29 +1111,14 @@ EXPORT_SYMBOL(snd_card_file_remove); */ int snd_power_ref_and_wait(struct snd_card *card) { - wait_queue_entry_t wait; - int result = 0; - snd_power_ref(card); - /* fastpath */ if (snd_power_get_state(card) == SNDRV_CTL_POWER_D0) return 0; - init_waitqueue_entry(&wait, current); - add_wait_queue(&card->power_sleep, &wait); - while (1) { - if (card->shutdown) { - result = -ENODEV; - break; - } - if (snd_power_get_state(card) == SNDRV_CTL_POWER_D0) - break; - snd_power_unref(card); - set_current_state(TASK_UNINTERRUPTIBLE); - schedule_timeout(30 * HZ); - snd_power_ref(card); - } - remove_wait_queue(&card->power_sleep, &wait); - return result; + wait_event_cmd(card->power_sleep, + card->shutdown || + snd_power_get_state(card) == SNDRV_CTL_POWER_D0, + snd_power_unref(card), snd_power_ref(card)); + return card->shutdown ? -ENODEV : 0; } EXPORT_SYMBOL_GPL(snd_power_ref_and_wait); -- 2.31.1

2 1

[PATCH] ASoC: Intel: sof_rt5682: add 512FS MCLK clock configuration
by Mac Chiang 19 Jan '22

19 Jan '22

codec system clock source support 512FS MCLK synchronous directly, so no need to set PLL configuration when MCLK 24.576MHz. Suggested-by: Shuming Fan <shumingf(a)realtek.com> Signed-off-by: Mac Chiang <mac.chiang(a)intel.com> --- sound/soc/intel/boards/sof_rt5682.c | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) diff --git a/sound/soc/intel/boards/sof_rt5682.c b/sound/soc/intel/boards/sof_rt5682.c index bd6d2e7dea53..a6efffc14cad 100644 --- a/sound/soc/intel/boards/sof_rt5682.c +++ b/sound/soc/intel/boards/sof_rt5682.c @@ -61,7 +61,6 @@ #define SOF_MAX98390_SPEAKER_AMP_PRESENT BIT(24) #define SOF_MAX98390_TWEETER_SPEAKER_PRESENT BIT(25) - /* Default: MCLK on, MCLK 19.2M, SSP0 */ static unsigned long sof_rt5682_quirk = SOF_RT5682_MCLK_EN | SOF_RT5682_SSP_CODEC(0); @@ -362,6 +361,9 @@ static int sof_rt5682_hw_params(struct snd_pcm_substream *substream, if (sof_rt5682_quirk & SOF_RT5682S_HEADPHONE_CODEC_PRESENT) { pll_id = RT5682S_PLL2; clk_id = RT5682S_SCLK_S_PLL2; + + if (pll_in == 24576000) + clk_id = RT5682S_SCLK_S_MCLK; } else { pll_id = RT5682_PLL1; clk_id = RT5682_SCLK_S_PLL1; @@ -369,11 +371,14 @@ static int sof_rt5682_hw_params(struct snd_pcm_substream *substream, pll_out = params_rate(params) * 512; - /* Configure pll for codec */ - ret = snd_soc_dai_set_pll(codec_dai, pll_id, pll_source, pll_in, - pll_out); - if (ret < 0) - dev_err(rtd->dev, "snd_soc_dai_set_pll err = %d\n", ret); + /* when MCLK is 512FS, no need to set PLL configuration additionally. */ + if (pll_in != 24576000) { + /* Configure pll for codec */ + ret = snd_soc_dai_set_pll(codec_dai, pll_id, pll_source, pll_in, + pll_out); + if (ret < 0) + dev_err(rtd->dev, "snd_soc_dai_set_pll err = %d\n", ret); + } /* Configure sysclk for codec */ ret = snd_soc_dai_set_sysclk(codec_dai, clk_id, -- 2.20.1

4 3

[PATCH] ASoC: soc-pcm: use GFP_ATOMIC in dpcm_create_debugfs_state()
by Christophe JAILLET 19 Jan '22

19 Jan '22

The commit below states that dpcm_be_connect() may be called from atomic context. It changes a GFP_KERNEL into a GFP_ATOMIC to deal with it. Another memory allocation is done in dpcm_create_debugfs_state() which is called by dpcm_be_connect(). Also use GFP_ATOMIC there to be consistent and be compliant with atomic context. Fixes: d8a9c6e1f676 ("ASoC: soc-pcm: use GFP_ATOMIC for dpcm structure") Signed-off-by: Christophe JAILLET <christophe.jaillet(a)wanadoo.fr> --- Not clear to me how dpcm_be_connect() can be called from an atomic context, though. But better safe than sorry. --- sound/soc/soc-pcm.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c index 7abfc48b26ca..1a536a2b9dc3 100644 --- a/sound/soc/soc-pcm.c +++ b/sound/soc/soc-pcm.c @@ -212,7 +212,7 @@ static void dpcm_create_debugfs_state(struct snd_soc_dpcm *dpcm, int stream) { char *name; - name = kasprintf(GFP_KERNEL, "%s:%s", dpcm->be->dai_link->name, + name = kasprintf(GFP_ATOMIC, "%s:%s", dpcm->be->dai_link->name, stream ? "capture" : "playback"); if (name) { dpcm->debugfs_state = debugfs_create_dir( -- 2.32.0

4 4

[PATCH v2 0/1] ALSA: hda/realtek: fix speakers and micmute on HP 855
by Alexander Sergeyev 19 Jan '22

19 Jan '22

Rebased and re-tested on the latest sound.git tree. Alexander Sergeyev (1): ALSA: hda/realtek: fix speakers and micmute on HP 855 G8 sound/pci/hda/patch_realtek.c | 12 ++++++++++++ 1 file changed, 12 insertions(+) -- 2.34.1

3 7

[PATCH, RFC] Enable S/PDIF output on Intel Hades Canyon NUC
by Dag B 18 Jan '22

18 Jan '22

Hi. The current snd-hda-intel/snd_hda_codec_realtek combo in the Linux kernel does not appear to enable the S/PDIF (toslink, iec958) port on Intel's Hades Canyon NUC. None of the current models/quirks changes this. To my knowledge. (The physical port in question is a minijack/mini toslink combo port.) I have found a number of people having the same issue with S/PDIF under Linux, on this particular hardware. None of these people reporting being able to find a solution, apart from a warm reboot into Linux from Windows. Until ... https://www.insanelymac.com/?app=core&module=system&controller=content&do=f… So. cyber4o claims the BIOS is wrong, and came up with the patch= solution first, then a modification to sound/pci/hda/patch_realtek.c to avoid having to boot to windows first. (IIUIC). I have been able to employ this solution and get the optical output enabled. I have (until now) used model=dell-headset-multi to enable my headphones with (on-wire) microphone in the front jack. (Kudos to arch-linux docs) The suggested fix for the missing optical out didn't cover headset config, so some modifications were needed. I'll freely admit to have very limited knowledge of what I am doing. Monkey see, monkey do. Anyways: I took cyber4o's solution and chained in the dell-headset-multi fixup. I now have optical output, my headset and on-wire microphone works. My current patch is below, and is purely intended as an illustration of how to make this work. I would be very happy if someone with an actual clue took the patch below and beat it into shape acceptable for inclusion in the kernel. Reading the forum post above may be wise, in case I have missed something. Some things which still make me scratch my head: - There is a slider named 'Digital' in the 'Capture' tab of alsamixer. Not sure what it does. - 'Headset Mic Boost', 'Headphone Mic Boost', 'Internal Mic Boost', 'Internal Mic Boost 1' all appear in *both* the 'Playback' *and* 'Capture' tabs of alsamixer. Is this on purpose? Bug in alsamixer? - There is no 'Headset' output slider in the 'Playback' tab. I do have 'Headphone' and 'Line out', though. And Mic boost for both headset and headphone. Not a problem, just ... 'asymmetrical'? - Marketing materials name the jack in the rear as 'Stereo headphones/TOSLINK combo rear jack'. Can we pretend it doesn't support a microphone (no idea...), and just name it (the copper bits) Line-Out? Less confusion? Again, really no clue about where these strings come from or what the 'correct' action is. - Inserting the jack in the front does not automatically mute the (optical) output in the back. Independent of the Auto-Mute state. Unsure if this is a corner case not covered by current code or not. Auto-mute only offers Enabled/Disabled here. (And not 'Disabled', 'Speaker Only' and 'Line-Out+Speaker'. I propose to mute S/PDIF together with Line Out.) /lib/firmware/nuc.patch: (loaded by patch= parameter to snd-hda-intel) [codec] 0x10ec0700 0x80862073 0 [pincfg] 0x1e 0x03441060 --- patch_realtek.c.orig 2021-12-10 21:07:29.324951606 -0000 +++ patch_realtek.c 2021-12-14 10:23:18.452173524 -0000 @@ -4669,6 +4669,12 @@ } } +static void alc700_fixup_nuc_spdif(struct hda_codec *codec, + const struct hda_fixup *fix, int action) +{ + snd_hda_override_wcaps(codec, 0x6, 0x611); +} + /* Line2 = mic mute hotkey * GPIO2 = mic mute LED */ @@ -6667,6 +6673,7 @@ ALC225_FIXUP_DELL_WYSE_MIC_NO_PRESENCE, ALC225_FIXUP_S3_POP_NOISE, ALC700_FIXUP_INTEL_REFERENCE, + ALC700_FIXUP_NUC_SPDIF, ALC274_FIXUP_DELL_BIND_DACS, ALC274_FIXUP_DELL_AIO_LINEOUT_VERB, ALC298_FIXUP_TPT470_DOCK_FIX, @@ -6975,6 +6982,12 @@ .chained = true, .chain_id = ALC269_FIXUP_THINKPAD_ACPI, }, + [ALC700_FIXUP_NUC_SPDIF] = { + .type = HDA_FIXUP_FUNC, + .v.func = alc700_fixup_nuc_spdif, + .chained = true, + .chain_id = ALC269_FIXUP_DELL1_MIC_NO_PRESENCE, + }, [ALC269_FIXUP_DELL1_MIC_NO_PRESENCE] = { .type = HDA_FIXUP_PINS, .v.pins = (const struct hda_pintbl[]) { @@ -8761,6 +8774,7 @@ SND_PCI_QUIRK(0x10cf, 0x1757, "Lifebook E752", ALC269_FIXUP_LIFEBOOK_HP_PIN), SND_PCI_QUIRK(0x10cf, 0x1845, "Lifebook U904", ALC269_FIXUP_LIFEBOOK_EXTMIC), SND_PCI_QUIRK(0x10ec, 0x10f2, "Intel Reference board", ALC700_FIXUP_INTEL_REFERENCE), + SND_PCI_QUIRK(0x10ec, 0x2073, "Intel NUC8 Hades Canyon", ALC700_FIXUP_NUC_SPDIF), SND_PCI_QUIRK(0x10ec, 0x118c, "Medion EE4254 MD62100", ALC256_FIXUP_MEDION_HEADSET_NO_PRESENCE), SND_PCI_QUIRK(0x10ec, 0x1230, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), SND_PCI_QUIRK(0x10ec, 0x1252, "Intel Reference board", ALC295_FIXUP_CHROME_BOOK), @@ -9024,6 +9038,7 @@ {.id = ALC298_FIXUP_TPT470_DOCK, .name = "tpt470-dock"}, {.id = ALC233_FIXUP_LENOVO_MULTI_CODECS, .name = "dual-codecs"}, {.id = ALC700_FIXUP_INTEL_REFERENCE, .name = "alc700-ref"}, + {.id = ALC700_FIXUP_NUC_SPDIF, .name = "nuc-hc"}, {.id = ALC269_FIXUP_SONY_VAIO, .name = "vaio"}, {.id = ALC269_FIXUP_DELL_M101Z, .name = "dell-m101z"}, {.id = ALC269_FIXUP_ASUS_G73JW, .name = "asus-g73jw"},

1 0

Re: Behringer UMC202HD issues and a partial solution
by Geraldo Nascimento 18 Jan '22

18 Jan '22

On Sat, Jan 15, 2022 at 12:29:18PM +0530, Nandakumar Edamana wrote: > Could compile and reload the module successfully, but the stuttering is > still there. Hi Nandakumar, OK, my mistake, scratch that patch. The codepath that activates Implicit Feedback when implicit_fb=1 is passed to the module as an option is the same that should activate when the quirk is in place. Like I said, it's very strange that your device skips implicit feedback when the quirk is in place, but can pick implicit feedback when implicit_fb=1 is passed to the module as an option. I've prepared some printk's hooked up to every codepath I can think of that will skip implicit feedback. Please test and share your results, always with dyndbg on. --- implicit.c 2022-01-14 16:41:53.946606013 -0300 +++ implicit.c 2022-01-15 21:45:15.108655890 -0300 @@ -90,8 +90,10 @@ static int add_implicit_fb_sync_ep(struc if (!alts) { iface = usb_ifnum_to_if(chip->dev, ifnum); - if (!iface || iface->num_altsetting < 2) + if (!iface || iface->num_altsetting < 2) { + printk(KERN_WARNING "implicit: add_implicit_fb_sync_ep(): not a usb_host_interface or less than 2 altsettings"); return 0; + } alts = &iface->altsetting[1]; } @@ -242,17 +244,23 @@ static int __add_generic_implicit_fb(str struct usb_endpoint_descriptor *epd; alts = snd_usb_get_host_interface(chip, iface, altset); - if (!alts) + if (!alts) { + printk(KERN_WARNING "implicit: __add_generic_implicit_fb(): not a usb_host_interface"); return 0; + } if ((alts->desc.bInterfaceClass != USB_CLASS_VENDOR_SPEC && alts->desc.bInterfaceClass != USB_CLASS_AUDIO) || - alts->desc.bNumEndpoints < 1) + alts->desc.bNumEndpoints < 1) { + printk(KERN_WARNING "implicit: __add_generic_implicit_fb(): no endpoints or wrong Interface Class"); return 0; + } epd = get_endpoint(alts, 0); if (!usb_endpoint_is_isoc_in(epd) || - (epd->bmAttributes & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC) + (epd->bmAttributes & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC) { + printk(KERN_WARNING "implicit: __add_generic_implicit_fb(): not Isochronous IN or not Asynchronous"); return 0; + } return add_implicit_fb_sync_ep(chip, fmt, epd->bEndpointAddress, 0, iface, alts); } @@ -262,8 +270,10 @@ static int add_generic_implicit_fb(struc struct audioformat *fmt, struct usb_host_interface *alts) { - if ((fmt->ep_attr & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC) + if ((fmt->ep_attr & USB_ENDPOINT_SYNCTYPE) != USB_ENDPOINT_SYNC_ASYNC) { + printk(KERN_WARNING "implicit: add_generic_implicit_fb(): not Asynchronous"); return 0; + } if (__add_generic_implicit_fb(chip, fmt, alts->desc.bInterfaceNumber + 1, @@ -302,8 +312,10 @@ static int audioformat_implicit_fb_quirk if (p) { switch (p->type) { case IMPLICIT_FB_GENERIC: + printk(KERN_WARNING "implicit: audioformat_implicit_fb_quirk(): matched GENERIC inside playback_implicit_fb_quirks[]"); return add_generic_implicit_fb(chip, fmt, alts); case IMPLICIT_FB_NONE: + printk(KERN_WARNING "implicit: audioformat_implicit_fb_quirk(): matched SKIP_DEV inside playback_implicit_fb_quirks[]"); return 0; /* No quirk */ case IMPLICIT_FB_FIXED: return add_implicit_fb_sync_ep(chip, fmt, p->ep_num, 0, @@ -311,6 +323,10 @@ static int audioformat_implicit_fb_quirk } } + else { + printk(KERN_WARNING "implicit: audioformat_implicit_fb_quirk(): no matches found inside playback_implicit_fb_quirks[]"); + } + /* Special handling for devices with capture quirks */ p = find_implicit_fb_entry(chip, capture_implicit_fb_quirks, alts); if (p) { @@ -354,6 +370,7 @@ static int audioformat_implicit_fb_quirk return add_generic_implicit_fb(chip, fmt, alts); /* No quirk */ + printk(KERN_WARNING "implicit: audioformat_implicit_fb_quirk(): returning 0 because no quirk was found"); return 0; }

2 2

[PATCH] ASoC: SOF: compr: Add compress ops implementation
by Daniel Baluta 18 Jan '22

18 Jan '22

From: Daniel Baluta <daniel.baluta(a)nxp.com> Implement snd_compress_ops. There are a lot of similarities with PCM implementation. For now we use sof_ipc_pcm_params to transfer compress parameters to SOF firmware. This will be changed in the future once we either add new compress parameters to SOF or enhance existing sof_ipc_pcm_params structure to support all native compress params. Signed-off-by: Daniel Baluta <daniel.baluta(a)nxp.com> --- sound/soc/sof/compress.c | 270 ++++++++++++++++++++++++++++++++++++++- sound/soc/sof/sof-priv.h | 6 + 2 files changed, 271 insertions(+), 5 deletions(-) diff --git a/sound/soc/sof/compress.c b/sound/soc/sof/compress.c index 01ca85f0b87f..2db1517d906d 100644 --- a/sound/soc/sof/compress.c +++ b/sound/soc/sof/compress.c @@ -10,6 +10,22 @@ #include "sof-audio.h" #include "sof-priv.h" +static void sof_set_transferred_bytes(struct sof_compr_stream *sstream, + u64 host_pos, u64 buffer_size) +{ + u64 prev_pos; + unsigned int copied; + + div64_u64_rem(sstream->copied_total, buffer_size, &prev_pos); + + if (host_pos < prev_pos) + copied = (buffer_size - prev_pos) + host_pos; + else + copied = host_pos - prev_pos; + + sstream->copied_total += copied; +} + static void snd_sof_compr_fragment_elapsed_work(struct work_struct *work) { struct snd_sof_pcm_stream *sps = @@ -29,16 +45,16 @@ void snd_sof_compr_init_elapsed_work(struct work_struct *work) */ void snd_sof_compr_fragment_elapsed(struct snd_compr_stream *cstream) { - struct snd_soc_component *component; - struct snd_soc_pcm_runtime *rtd; + struct snd_soc_pcm_runtime *rtd = cstream->private_data; + struct snd_compr_runtime *runtime = cstream->runtime; + struct sof_compr_stream *sstream = runtime->private_data; + struct snd_soc_component *component = + snd_soc_rtdcom_lookup(rtd, SOF_AUDIO_PCM_DRV_NAME); struct snd_sof_pcm *spcm; if (!cstream) return; - rtd = cstream->private_data; - component = snd_soc_rtdcom_lookup(rtd, SOF_AUDIO_PCM_DRV_NAME); - spcm = snd_sof_find_spcm_dai(component, rtd); if (!spcm) { dev_err(component->dev, @@ -46,6 +62,250 @@ void snd_sof_compr_fragment_elapsed(struct snd_compr_stream *cstream) return; } + sof_set_transferred_bytes(sstream, spcm->stream[cstream->direction].posn.host_posn, + runtime->buffer_size); + /* use the same workqueue-based solution as for PCM, cf. snd_sof_pcm_elapsed */ schedule_work(&spcm->stream[cstream->direction].period_elapsed_work); } + +static int create_page_table(struct snd_soc_component *component, + struct snd_compr_stream *cstream, + unsigned char *dma_area, size_t size) +{ + struct snd_soc_pcm_runtime *rtd = cstream->private_data; + struct snd_dma_buffer *dmab = cstream->runtime->dma_buffer_p; + int dir = cstream->direction; + struct snd_sof_pcm *spcm; + + spcm = snd_sof_find_spcm_dai(component, rtd); + if (!spcm) + return -EINVAL; + + return snd_sof_create_page_table(component->dev, dmab, + spcm->stream[dir].page_table.area, size); +} + +int sof_compr_open(struct snd_soc_component *component, + struct snd_compr_stream *cstream) +{ + struct snd_soc_pcm_runtime *rtd = cstream->private_data; + struct snd_compr_runtime *runtime = cstream->runtime; + struct sof_compr_stream *sstream; + struct snd_sof_pcm *spcm; + int dir; + + sstream = kzalloc(sizeof(*sstream), GFP_KERNEL); + if (!sstream) + return -ENOMEM; + + spcm = snd_sof_find_spcm_dai(component, rtd); + if (!spcm) { + kfree(sstream); + return -EINVAL; + } + + dir = cstream->direction; + + if (spcm->stream[dir].cstream) { + kfree(sstream); + return -EBUSY; + } + + spcm->stream[dir].cstream = cstream; + spcm->stream[dir].posn.host_posn = 0; + spcm->stream[dir].posn.dai_posn = 0; + spcm->prepared[dir] = false; + + runtime->private_data = sstream; + + return 0; +} + +int sof_compr_free(struct snd_soc_component *component, + struct snd_compr_stream *cstream) +{ + struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(component); + struct snd_soc_pcm_runtime *rtd = cstream->private_data; + struct snd_compr_runtime *runtime = cstream->runtime; + struct sof_compr_stream *sstream = runtime->private_data; + struct sof_ipc_stream stream; + struct sof_ipc_reply reply; + struct snd_sof_pcm *spcm; + int ret = 0; + + spcm = snd_sof_find_spcm_dai(component, rtd); + if (!spcm) + return -EINVAL; + + stream.hdr.size = sizeof(stream); + stream.hdr.cmd = SOF_IPC_GLB_STREAM_MSG | SOF_IPC_STREAM_PCM_FREE; + stream.comp_id = spcm->stream[cstream->direction].comp_id; + + if (spcm->prepared[cstream->direction]) { + ret = sof_ipc_tx_message(sdev->ipc, stream.hdr.cmd, + &stream, sizeof(stream), + &reply, sizeof(reply)); + if (!ret) + spcm->prepared[cstream->direction] = false; + } + + cancel_work_sync(&spcm->stream[cstream->direction].period_elapsed_work); + spcm->stream[cstream->direction].cstream = NULL; + kfree(sstream); + + return ret; +} + +int sof_compr_set_params(struct snd_soc_component *component, + struct snd_compr_stream *cstream, struct snd_compr_params *params) +{ + struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(component); + struct snd_soc_pcm_runtime *rtd_pcm = cstream->private_data; + struct snd_compr_runtime *rtd = cstream->runtime; + struct sof_compr_stream *sstream = rtd->private_data; + struct sof_ipc_pcm_params_reply ipc_params_reply; + struct sof_ipc_pcm_params pcm; + struct snd_sof_pcm *spcm; + int ret; + + spcm = snd_sof_find_spcm_dai(component, rtd_pcm); + if (!spcm) + return -EINVAL; + + cstream->dma_buffer.dev.type = SNDRV_DMA_TYPE_DEV_SG; + cstream->dma_buffer.dev.dev = sdev->dev; + ret = snd_compr_malloc_pages(cstream, rtd->buffer_size); + if (ret < 0) + return ret; + + create_page_table(component, cstream, rtd->dma_area, rtd->dma_bytes); + + memset(&pcm, 0, sizeof(pcm)); + + pcm.params.buffer.pages = PFN_UP(rtd->dma_bytes); + pcm.hdr.size = sizeof(pcm); + pcm.hdr.cmd = SOF_IPC_GLB_STREAM_MSG | SOF_IPC_STREAM_PCM_PARAMS; + + pcm.comp_id = spcm->stream[cstream->direction].comp_id; + pcm.params.hdr.size = sizeof(pcm.params); + pcm.params.buffer.phy_addr = spcm->stream[cstream->direction].page_table.addr; + pcm.params.buffer.size = rtd->dma_bytes; + pcm.params.direction = cstream->direction; + pcm.params.channels = params->codec.ch_out; + pcm.params.rate = params->codec.sample_rate; + pcm.params.buffer_fmt = SOF_IPC_BUFFER_INTERLEAVED; + pcm.params.frame_fmt = SOF_IPC_FRAME_S32_LE; + pcm.params.sample_container_bytes = + snd_pcm_format_physical_width(SNDRV_PCM_FORMAT_S32) >> 3; + pcm.params.host_period_bytes = params->buffer.fragment_size; + + ret = sof_ipc_tx_message(sdev->ipc, pcm.hdr.cmd, &pcm, sizeof(pcm), + &ipc_params_reply, sizeof(ipc_params_reply)); + if (ret < 0) { + dev_err(component->dev, "error ipc failed\n"); + return ret; + } + + sstream->posn_offset = sdev->stream_box.offset + ipc_params_reply.posn_offset; + sstream->sample_rate = params->codec.sample_rate; + spcm->prepared[cstream->direction] = true; + + return 0; +} + +int sof_compr_get_params(struct snd_soc_component *component, + struct snd_compr_stream *cstream, struct snd_codec *params) +{ + return 0; +} + +int sof_compr_trigger(struct snd_soc_component *component, + struct snd_compr_stream *cstream, int cmd) +{ + struct sof_ipc_stream stream; + struct sof_ipc_reply reply; + struct snd_soc_pcm_runtime *rtd = cstream->private_data; + struct snd_sof_dev *sdev = snd_soc_component_get_drvdata(component); + struct snd_sof_pcm *spcm; + + spcm = snd_sof_find_spcm_dai(component, rtd); + if (!spcm) + return -EINVAL; + + stream.hdr.size = sizeof(stream); + stream.hdr.cmd = SOF_IPC_GLB_STREAM_MSG; + stream.comp_id = spcm->stream[cstream->direction].comp_id; + + switch (cmd) { + case SNDRV_PCM_TRIGGER_START: + stream.hdr.cmd |= SOF_IPC_STREAM_TRIG_START; + break; + case SNDRV_PCM_TRIGGER_STOP: + stream.hdr.cmd |= SOF_IPC_STREAM_TRIG_STOP; + break; + case SNDRV_PCM_TRIGGER_PAUSE_PUSH: + stream.hdr.cmd |= SOF_IPC_STREAM_TRIG_PAUSE; + break; + case SNDRV_PCM_TRIGGER_PAUSE_RELEASE: + stream.hdr.cmd |= SOF_IPC_STREAM_TRIG_RELEASE; + break; + default: + dev_err(component->dev, "error: unhandled trigger cmd %d\n", cmd); + break; + } + + return sof_ipc_tx_message(sdev->ipc, stream.hdr.cmd, + &stream, sizeof(stream), + &reply, sizeof(reply)); +} + +int sof_compr_copy(struct snd_soc_component *component, + struct snd_compr_stream *cstream, + char __user *buf, size_t count) +{ + struct snd_compr_runtime *rtd = cstream->runtime; + unsigned int offset, n; + void *ptr; + int ret; + + if (count > rtd->buffer_size) + count = rtd->buffer_size; + + div_u64_rem(rtd->total_bytes_available, rtd->buffer_size, &offset); + ptr = rtd->dma_area + offset; + n = rtd->buffer_size - offset; + + if (count < n) { + ret = copy_from_user(ptr, buf, count); + } else { + ret = copy_from_user(ptr, buf, n); + ret += copy_from_user(rtd->dma_area, buf + n, count - n); + } + + return count - ret; +} + +static int sof_compr_pointer(struct snd_soc_component *component, + struct snd_compr_stream *cstream, + struct snd_compr_tstamp *tstamp) +{ + struct snd_compr_runtime *runtime = cstream->runtime; + struct sof_compr_stream *sstream = runtime->private_data; + + tstamp->sampling_rate = sstream->sample_rate; + tstamp->copied_total = sstream->copied_total; + + return 0; +} + +struct snd_compress_ops sof_compressed_ops = { + .open = sof_compr_open, + .free = sof_compr_free, + .set_params = sof_compr_set_params, + .get_params = sof_compr_get_params, + .trigger = sof_compr_trigger, + .pointer = sof_compr_pointer, + .copy = sof_compr_copy, +}; +EXPORT_SYMBOL(sof_compressed_ops); diff --git a/sound/soc/sof/sof-priv.h b/sound/soc/sof/sof-priv.h index 087935192ce8..d001a762a866 100644 --- a/sound/soc/sof/sof-priv.h +++ b/sound/soc/sof/sof-priv.h @@ -108,6 +108,12 @@ enum sof_debugfs_access_type { SOF_DEBUGFS_ACCESS_D0_ONLY, }; +struct sof_compr_stream { + unsigned int copied_total; + unsigned int sample_rate; + size_t posn_offset; +}; + struct snd_sof_dev; struct snd_sof_ipc_msg; struct snd_sof_ipc; -- 2.27.0

4 4