ASoC: stm32: sai: Add support of S/PDIF playback (6eb17d70) · Commits · e / devices / android_kernel_teracube_emerald

sound/soc/stm/stm32_sai.c

+2 −0

Original line number	Diff line number	Diff line
		@@ -30,10 +30,12 @@

		static const struct stm32_sai_conf stm32_sai_conf_f4 = {
		.version = SAI_STM32F4,
		.has_spdif = false,
		};

		static const struct stm32_sai_conf stm32_sai_conf_h7 = {
		.version = SAI_STM32H7,
		.has_spdif = true,
		};

		static const struct of_device_id stm32_sai_ids[] = {

sound/soc/stm/stm32_sai.h

+2 −0

Original line number	Diff line number	Diff line
		@@ -248,9 +248,11 @@ enum stm32_sai_version {
		/**
		* struct stm32_sai_conf - SAI configuration
		* @version: SAI version
		* @has_spdif: SAI S/PDIF support flag
		*/
		struct stm32_sai_conf {
		int version;
		bool has_spdif;
		};

		/**

sound/soc/stm/stm32_sai_sub.c

+129 −24

Original line number	Diff line number	Diff line
		@@ -23,6 +23,7 @@
		#include <linux/of_platform.h>
		#include <linux/regmap.h>

		#include <sound/asoundef.h>
		#include <sound/core.h>
		#include <sound/dmaengine_pcm.h>
		#include <sound/pcm_params.h>
		@@ -30,6 +31,7 @@
		#include "stm32_sai.h"

		#define SAI_FREE_PROTOCOL 0x0
		#define SAI_SPDIF_PROTOCOL 0x1

		#define SAI_SLOT_SIZE_AUTO 0x0
		#define SAI_SLOT_SIZE_16 0x1
		@@ -59,8 +61,13 @@
		#define SAI_SYNC_INTERNAL 0x1
		#define SAI_SYNC_EXTERNAL 0x2

		#define STM_SAI_PROTOCOL_IS_SPDIF(ip) ((ip)->spdif)
		#define STM_SAI_HAS_SPDIF(x) ((x)->pdata->conf->has_spdif)
		#define STM_SAI_HAS_EXT_SYNC(x) (!STM_SAI_IS_F4(sai->pdata))

		#define SAI_IEC60958_BLOCK_FRAMES 192
		#define SAI_IEC60958_STATUS_BYTES 24

		/**
		* struct stm32_sai_sub_data - private data of SAI sub block (block A or B)
		* @pdev: device data pointer
		@@ -78,6 +85,7 @@
		* @id: SAI sub block id corresponding to sub-block A or B
		* @dir: SAI block direction (playback or capture). set at init
		* @master: SAI block mode flag. (true=master, false=slave) set at init
		* @spdif: SAI S/PDIF iec60958 mode flag. set at init
		* @fmt: SAI block format. relevant only for custom protocols. set at init
		* @sync: SAI block synchronization mode. (none, internal or external)
		* @synco: SAI block ext sync source (provider setting). (none, sub-block A/B)
		@@ -87,6 +95,8 @@
		* @slot_width: rx or tx slot width in bits
		* @slot_mask: rx or tx active slots mask. set at init or at runtime
		* @data_size: PCM data width. corresponds to PCM substream width.
		* @spdif_frm_cnt: S/PDIF playback frame counter
		* @spdif_status_bits: S/PDIF status bits
		*/
		struct stm32_sai_sub_data {
		struct platform_device *pdev;
		@@ -104,6 +114,7 @@ struct stm32_sai_sub_data {
		unsigned int id;
		int dir;
		bool master;
		bool spdif;
		int fmt;
		int sync;
		int synco;
		@@ -113,6 +124,8 @@ struct stm32_sai_sub_data {
		int slot_width;
		int slot_mask;
		int data_size;
		unsigned int spdif_frm_cnt;
		unsigned char spdif_status_bits[SAI_IEC60958_STATUS_BYTES];
		};

		enum stm32_sai_fifo_th {
		@@ -171,6 +184,10 @@ static bool stm32_sai_sub_writeable_reg(struct device *dev, unsigned int reg)
		}
		}

		static const unsigned char default_status_bits[SAI_IEC60958_STATUS_BYTES] = {
		0, 0, 0, IEC958_AES3_CON_FS_48000,
		};

		static const struct regmap_config stm32_sai_sub_regmap_config_f4 = {
		.reg_bits = 32,
		.reg_stride = 4,
		@@ -277,6 +294,11 @@ static int stm32_sai_set_dai_tdm_slot(struct snd_soc_dai *cpu_dai, u32 tx_mask,
		struct stm32_sai_sub_data *sai = snd_soc_dai_get_drvdata(cpu_dai);
		int slotr, slotr_mask, slot_size;

		if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
		dev_warn(cpu_dai->dev, "Slot setting relevant only for TDM\n");
		return 0;
		}

		dev_dbg(cpu_dai->dev, "Masks tx/rx:%#x/%#x, slots:%d, width:%d\n",
		tx_mask, rx_mask, slots, slot_width);

		@@ -326,8 +348,17 @@ static int stm32_sai_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)

		dev_dbg(cpu_dai->dev, "fmt %x\n", fmt);

		cr1_mask = SAI_XCR1_PRTCFG_MASK;
		cr1 = SAI_XCR1_PRTCFG_SET(SAI_FREE_PROTOCOL);
		/* Do not generate master by default */
		cr1 = SAI_XCR1_NODIV;
		cr1_mask = SAI_XCR1_NODIV;

		cr1_mask \|= SAI_XCR1_PRTCFG_MASK;
		if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
		cr1 \|= SAI_XCR1_PRTCFG_SET(SAI_SPDIF_PROTOCOL);
		goto conf_update;
		}

		cr1 \|= SAI_XCR1_PRTCFG_SET(SAI_FREE_PROTOCOL);

		switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
		/* SCK active high for all protocols */
		@@ -409,10 +440,7 @@ static int stm32_sai_set_dai_fmt(struct snd_soc_dai *cpu_dai, unsigned int fmt)

		cr1_mask \|= SAI_XCR1_SLAVE;

		/* do not generate master by default */
		cr1 \|= SAI_XCR1_NODIV;
		cr1_mask \|= SAI_XCR1_NODIV;

		conf_update:
		ret = regmap_update_bits(sai->regmap, STM_SAI_CR1_REGX, cr1_mask, cr1);
		if (ret < 0) {
		dev_err(cpu_dai->dev, "Failed to update CR1 register\n");
		@@ -478,6 +506,12 @@ static int stm32_sai_set_config(struct snd_soc_dai *cpu_dai,
		SAI_XCR2_FFLUSH \|
		SAI_XCR2_FTH_SET(STM_SAI_FIFO_TH_HALF));

		/* DS bits in CR1 not set for SPDIF (size forced to 24 bits).*/
		if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
		sai->spdif_frm_cnt = 0;
		return 0;
		}

		/* Mode, data format and channel config */
		cr1_mask = SAI_XCR1_DS_MASK;
		switch (params_format(params)) {
		@@ -592,13 +626,14 @@ static int stm32_sai_configure_clock(struct snd_soc_dai *cpu_dai,
		int cr1, mask, div = 0;
		int sai_clk_rate, mclk_ratio, den, ret;
		int version = sai->pdata->conf->version;
		unsigned int rate = params_rate(params);

		if (!sai->mclk_rate) {
		dev_err(cpu_dai->dev, "Mclk rate is null\n");
		return -EINVAL;
		}

		if (!(params_rate(params) % 11025))
		if (!(rate % 11025))
		clk_set_parent(sai->sai_ck, sai->pdata->clk_x11k);
		else
		clk_set_parent(sai->sai_ck, sai->pdata->clk_x8k);
		@@ -623,26 +658,30 @@ static int stm32_sai_configure_clock(struct snd_soc_dai *cpu_dai,
		* MCKDIV = sai_ck / (frl x ws) (NOMCK=1)
		* Note: NOMCK/NODIV correspond to same bit.
		*/
		if (STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
		div = DIV_ROUND_CLOSEST(sai_clk_rate,
		(params_rate(params) * 128));
		} else {
		if (sai->mclk_rate) {
		mclk_ratio = sai->mclk_rate / params_rate(params);
		if (mclk_ratio != 256) {
		mclk_ratio = sai->mclk_rate / rate;
		if (mclk_ratio == 512) {
		mask = SAI_XCR1_OSR;
		cr1 = SAI_XCR1_OSR;
		} else {
		} else if (mclk_ratio != 256) {
		dev_err(cpu_dai->dev,
		"Wrong mclk ratio %d\n",
		mclk_ratio);
		return -EINVAL;
		}
		}
		div = DIV_ROUND_CLOSEST(sai_clk_rate, sai->mclk_rate);
		div = DIV_ROUND_CLOSEST(sai_clk_rate,
		sai->mclk_rate);
		} else {
		/* mclk-fs not set, master clock not active. NOMCK=1 */
		/* mclk-fs not set, master clock not active */
		den = sai->fs_length * params_rate(params);
		div = DIV_ROUND_CLOSEST(sai_clk_rate, den);
		}
		}
		}

		if (div > SAI_XCR1_MCKDIV_MAX(version)) {
		dev_err(cpu_dai->dev, "Divider %d out of range\n", div);
		@@ -670,10 +709,12 @@ static int stm32_sai_hw_params(struct snd_pcm_substream *substream,

		sai->data_size = params_width(params);

		if (!STM_SAI_PROTOCOL_IS_SPDIF(sai)) {
		ret = stm32_sai_set_slots(cpu_dai);
		if (ret < 0)
		return ret;
		stm32_sai_set_frame(cpu_dai);
		}

		ret = stm32_sai_set_config(cpu_dai, substream, params);
		if (ret)
		@@ -723,6 +764,9 @@ static int stm32_sai_trigger(struct snd_pcm_substream *substream, int cmd,
		(unsigned int)~SAI_XCR1_DMAEN);
		if (ret < 0)
		dev_err(cpu_dai->dev, "Failed to update CR1 register\n");

		if (STM_SAI_PROTOCOL_IS_SPDIF(sai))
		sai->spdif_frm_cnt = 0;
		break;
		default:
		return -EINVAL;
		@@ -776,6 +820,10 @@ static int stm32_sai_dai_probe(struct snd_soc_dai *cpu_dai)
		sai->synco, sai->synci);
		}

		if (STM_SAI_PROTOCOL_IS_SPDIF(sai))
		memcpy(sai->spdif_status_bits, default_status_bits,
		sizeof(default_status_bits));

		cr1_mask \|= SAI_XCR1_SYNCEN_MASK;
		cr1 \|= SAI_XCR1_SYNCEN_SET(sai->sync);

		@@ -792,6 +840,42 @@ static const struct snd_soc_dai_ops stm32_sai_pcm_dai_ops = {
		.shutdown = stm32_sai_shutdown,
		};

		static int stm32_sai_pcm_process_spdif(struct snd_pcm_substream *substream,
		int channel, unsigned long hwoff,
		void *buf, unsigned long bytes)
		{
		struct snd_pcm_runtime *runtime = substream->runtime;
		struct snd_soc_pcm_runtime *rtd = substream->private_data;
		struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
		struct stm32_sai_sub_data *sai = dev_get_drvdata(cpu_dai->dev);
		int ptr = (int )(runtime->dma_area + hwoff +
		channel * (runtime->dma_bytes / runtime->channels));
		ssize_t cnt = bytes_to_samples(runtime, bytes);
		unsigned int frm_cnt = sai->spdif_frm_cnt;
		unsigned int byte;
		unsigned int mask;

		do {
		ptr = ((ptr >> 8) & 0x00ffffff);

		/* Set channel status bit */
		byte = frm_cnt >> 3;
		mask = 1 << (frm_cnt - (byte << 3));
		if (sai->spdif_status_bits[byte] & mask)
		*ptr \|= 0x04000000;
		ptr++;

		if (!(cnt % 2))
		frm_cnt++;

		if (frm_cnt == SAI_IEC60958_BLOCK_FRAMES)
		frm_cnt = 0;
		} while (--cnt);
		sai->spdif_frm_cnt = frm_cnt;

		return 0;
		}

		static const struct snd_pcm_hardware stm32_sai_pcm_hw = {
		.info = SNDRV_PCM_INFO_INTERLEAVED \| SNDRV_PCM_INFO_MMAP,
		.buffer_bytes_max = 8 * PAGE_SIZE,
		@@ -846,6 +930,12 @@ static const struct snd_dmaengine_pcm_config stm32_sai_pcm_config = {
		.prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
		};

		static const struct snd_dmaengine_pcm_config stm32_sai_pcm_config_spdif = {
		.pcm_hardware = &stm32_sai_pcm_hw,
		.prepare_slave_config = snd_dmaengine_pcm_prepare_slave_config,
		.process = stm32_sai_pcm_process_spdif,
		};

		static const struct snd_soc_component_driver stm32_component = {
		.name = "stm32-sai",
		};
		@@ -900,6 +990,18 @@ static int stm32_sai_sub_parse_of(struct platform_device *pdev,
		return -EINVAL;
		}

		/* Get spdif iec60958 property */
		sai->spdif = false;
		if (of_get_property(np, "st,iec60958", NULL)) {
		if (!STM_SAI_HAS_SPDIF(sai) \|\|
		sai->dir == SNDRV_PCM_STREAM_CAPTURE) {
		dev_err(&pdev->dev, "S/PDIF IEC60958 not supported\n");
		return -EINVAL;
		}
		sai->spdif = true;
		sai->master = true;
		}

		/* Get synchronization property */
		args.np = NULL;
		ret = of_parse_phandle_with_fixed_args(np, "st,sync", 1, 0, &args);
		@@ -999,6 +1101,7 @@ static int stm32_sai_sub_probe(struct platform_device *pdev)
		{
		struct stm32_sai_sub_data *sai;
		const struct of_device_id *of_id;
		const struct snd_dmaengine_pcm_config *conf = &stm32_sai_pcm_config;
		int ret;

		sai = devm_kzalloc(&pdev->dev, sizeof(*sai), GFP_KERNEL);
		@@ -1039,8 +1142,10 @@ static int stm32_sai_sub_probe(struct platform_device *pdev)
		if (ret)
		return ret;

		ret = devm_snd_dmaengine_pcm_register(&pdev->dev,
		&stm32_sai_pcm_config, 0);
		if (STM_SAI_PROTOCOL_IS_SPDIF(sai))
		conf = &stm32_sai_pcm_config_spdif;

		ret = devm_snd_dmaengine_pcm_register(&pdev->dev, conf, 0);
		if (ret) {
		dev_err(&pdev->dev, "Could not register pcm dma\n");
		return ret;