ark1668ed-bsp/linux/sound/soc/arkmicro/ark1668ed_i2s.c

/*
 * ark1668ed_i2s.c -- ALSA SoC Audio Layer
 */
#include <linux/module.h>
#include <linux/platform_device.h>
#include <linux/dmaengine.h>
#include <linux/slab.h>
#include <sound/core.h>
#include <sound/pcm.h>
#include <sound/pcm_params.h>
#include <sound/soc.h>
#include <sound/dmaengine_pcm.h>
#include <linux/clk.h>
#include <linux/dma-mapping.h>

#include "ark1668ed_i2s.h"

#define DRV_NAME "ark1668ed-i2s"


/* 平台私有数据结构 */
struct ark1668ed_i2s_priv {
	struct device *dev;
	struct	clk		*clk;
	void __iomem	*base;
	int irq;
	u32 nco_reg;
	u32 adc_nco_reg;
	int master;
	u32 fmt;
	int full_duplex_en;
	u32 index;					// I2S控制器索引
	struct dma_chan *tx_chan;
	struct dma_chan *rx_chan;
	dma_addr_t dma_addr;
	struct snd_dmaengine_dai_dma_data playback_dma_data;
	struct snd_dmaengine_dai_dma_data capture_dma_data;
	bool has_capture;
	bool has_playback;
	//struct snd_soc_component_driver component_driver;
};

//static void i2s_enable(struct ark1668ed_i2s_priv *priv)
//{
//	dev_info(priv->dev, "I2S-%d enabled\n", priv->index);
//}

//static void i2s_disable(struct ark1668ed_i2s_priv *priv)
//{
//	dev_info(priv->dev, "I2S-%d disabled\n", priv->index);
//}

static irqreturn_t ark1668ed_irq_handler(int irq, void *dev_id)
{
	struct ark1668ed_i2s_priv *i2s = dev_id;
	//uint32_t val;
	u32 status;

	status = readl(i2s->base + I2S_SASR0);

	writel(0xFF, i2s->base + I2S_SAICR);
	//writel(status, i2s->base + I2S_SAICR);
	writel(0, i2s->base + I2S_SAICR);

//	/* interrupt clear */
//	writel(0xFFFFFFFF, i2s->base + I2S_SAICR);
//	writel(0, i2s->base + I2S_SAICR);

//	/* interrupt enable */
//	val = readl(i2s->base + I2S_SAIMR);
//	val |= (SAIMR_TFS | SAIMR_TUR | SAIMR_ROR | SAIMR_RFS);
//	printk("+++++++%s,%d:val = 0x%x\n",__func__,__LINE__,val);
//	writel(val, i2s->base + I2S_SAIMR);

	return IRQ_HANDLED;
}

static int ark1668ed_i2s_probe(struct snd_soc_dai *dai)
{
	struct ark1668ed_i2s_priv *i2s = snd_soc_dai_get_drvdata(dai);

	snd_soc_dai_init_dma_data(dai,
		i2s->has_playback ? &i2s->playback_dma_data : NULL,
		i2s->has_capture  ? &i2s->capture_dma_data  : NULL);

//	dai->capture_dma_data = &i2s->capture_dma_data;
//	dai->playback_dma_data = &i2s->playback_dma_data;

	return 0;
}

static int ark1668ed_i2s_startup(
	struct snd_pcm_substream *substream, struct snd_soc_dai *dai)
{
	struct ark1668ed_i2s_priv *i2s = snd_soc_dai_get_drvdata(dai);
	//struct snd_dmaengine_dai_dma_data *dma_data;
	uint32_t val = 0;

	if (readl(i2s->base + I2S_SACR0) & SACR0_ENB)
		return 0;

	/* reset */
	writel(SACR0_RST, i2s->base + I2S_SACR0);
	udelay(1);
	writel(0, i2s->base + I2S_SACR0);

	if (i2s->full_duplex_en) {
		val = SACR0_TFIFOFIRSTBIT | SACR0_CHANLOCK | SACR0_TFTH(14) | SACR0_TDMAEN;
		val |= SACR0_RFIFIFIRSTBIT | SACR0_CHANLOCK | SACR0_RFTH(17) | SACR0_RDMAEN;

		//printk("####################i2s->master = %d\n",i2s->master);
		if (i2s->master)
			val |= SACR0_BCKD | SACR0_SYNCD;
		else
			val &= ~(SACR0_BCKD | SACR0_SYNCD);
		writel(val, i2s->base + I2S_SACR0);

		val = readl(i2s->base + I2S_SACR1);
		val &= ~(SACR1_DRPL_DAT | SACR1_DREC_DAT | SACR1_TDMENB);
		writel(val, i2s->base + I2S_SACR1);

		writel(0x7f, i2s->base + I2S_SAICR);
		writel(0, i2s->base + I2S_SAICR);

	} else {
		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
			val = SACR0_TFIFOFIRSTBIT | SACR0_CHANLOCK | SACR0_TFTH(14) | SACR0_TDMAEN;
			//printk("PLAYBACK####################i2s->master = %d\n",i2s->master);
			if (i2s->master)
				val |= SACR0_BCKD | SACR0_SYNCD;
			else
				val &= ~(SACR0_BCKD | SACR0_SYNCD);
			writel(val, i2s->base + I2S_SACR0);

			val = readl(i2s->base + I2S_SACR1);
			val &= ~(SACR1_DRPL_DAT | SACR1_TDMENB);
			writel(val, i2s->base + I2S_SACR1);

			writel(0x7f, i2s->base + I2S_SAICR);
			writel(0, i2s->base + I2S_SAICR);

		} else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
			val = SACR0_RFIFIFIRSTBIT | SACR0_CHANLOCK | SACR0_RFTH(17) | SACR0_RDMAEN;
			//printk("CAPTURE####################i2s->master = %d\n",i2s->master);
			if (i2s->master)
				val |= SACR0_BCKD | SACR0_SYNCD;
			else
				val &= ~(SACR0_BCKD | SACR0_SYNCD);
			writel(val, i2s->base + I2S_SACR0);

			val = readl(i2s->base + I2S_SACR1);
			val &= ~(SACR1_DREC_DAT | SACR1_TDMENB);
			writel(val, i2s->base + I2S_SACR1);

			writel(0x7f, i2s->base + I2S_SAICR);
			writel(0, i2s->base + I2S_SAICR);
		}
	}

	udelay(1);
//	val = readl(i2s->base + I2S_SACR0);
//	val &= ~SACR0_CHANLOCK;
//	writel(val, i2s->base + I2S_SACR0);

	//snd_soc_dai_set_dma_data(dai, substream, dma_data);

	return 0;
}

static int ark1668ed_hw_params(struct snd_pcm_substream *substream,
			       struct snd_pcm_hw_params *params,
			       struct snd_soc_dai *dai)
{
	//struct snd_soc_pcm_runtime *rtd = snd_soc_substream_to_rtd(substream);
	struct ark1668ed_i2s_priv *i2s = snd_soc_dai_get_drvdata(dai);
	//struct dma_chan *chan = snd_dmaengine_pcm_get_chan(substream);

	u32 rate = params_rate(params);
	u32 step = 256 * 2, modulo;
	u32 freq;
	u32 val;
	void *sysreg;
	//int ret;

	int channels = params_channels(params);
	int width = snd_pcm_format_physical_width(params_format(params));

	dev_info(i2s->dev, "Configuring stream: %s, %d channels, %d-bit\n",
	     substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? "Playback" : "Capture",
	     channels, width);

	if ((!i2s->nco_reg) || (!i2s->adc_nco_reg))
		return 0;

	/* mclk = rate * 256, mclk = freq * step / (2 * modulo) */
	freq = clk_get_rate(i2s->clk);
	modulo = freq / rate;
	val = (step << 16) | modulo;
	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
		//printk("##############i2s->nco_reg = 0x%x\n",i2s->nco_reg);
		sysreg = ioremap(i2s->nco_reg, 0x10);
	} else if (substream->stream == SNDRV_PCM_STREAM_CAPTURE) {
		//printk("##############i2s->adc_nco_reg = 0x%x\n",i2s->adc_nco_reg);
		sysreg = ioremap(i2s->adc_nco_reg, 0x10);
	}
	if (sysreg) {
		writel(val, sysreg);
		iounmap(sysreg);
	}
	//mdelay(1);

	// 设置采样率、位深、通道数等
	val = readl(i2s->base + I2S_SACR0);
	switch (params_format(params)) {
	case SNDRV_PCM_FORMAT_S16_LE:
		//printk("##############SNDRV_PCM_FORMAT_S16_LE\n");
		val &= ~SACR0_32BIT_MODE;
		//val &= ~(SACR0_RFTH_MASK | SACR0_TFTH_MASK);
		//val |= SACR0_TFTH(7) | SACR0_RFTH(8);
		break;
	case SNDRV_PCM_FORMAT_S24_LE:
	case SNDRV_PCM_FORMAT_S32_LE:
		//printk("##############SNDRV_PCM_FORMAT_S32_LE\n");
		val |= SACR0_32BIT_MODE;
		val &= ~(SACR0_RFTH_MASK | SACR0_TFTH_MASK);
		val |= SACR0_TFTH(7) | SACR0_RFTH(8);
		break;
	default:
		return -EINVAL;
	}

	if ((channels > 0) && (channels <= 2)) {
		val |= (1 << 29);
	} else if ((channels > 2) && (channels <= 4)) {
		val |= (2 << 29);
	} else if ((channels > 4) && (channels <= 6)) {
		val |= (3 << 29);
	}

	//if (channels % 2)
	if (params_channels(params) == 1)
		val |= SACR0_SCBIT;
	else
		val &= ~SACR0_SCBIT;

	val &= ~SACR0_SAMERATE_ENB;
	writel(val, i2s->base + I2S_SACR0);

	val = readl(i2s->base + I2S_WRCTL);
	val &= ~(0xffffffff);
	val |= ((1 << 0) | (2 << 8) | (3 << 16));
	writel((1 << 0) | (2 << 8) | (3 << 16), i2s->base + I2S_WRCTL);

	val = readl(i2s->base + I2S_RDCTL);
	val &= ~(0xffffffff);
	val |= ((1 << 0) | (2 << 8) | (3 << 16));
	writel((1 << 0) | (2 << 8) | (3 << 16), i2s->base + I2S_RDCTL);
	//printk("################\n");
	return 0;
}

static int ark1668ed_trigger(struct snd_pcm_substream *substream,
			     int cmd, struct snd_soc_dai *dai)
{
	struct ark1668ed_i2s_priv *i2s = snd_soc_dai_get_drvdata(dai);

	//pr_info("DMA buffer req size: %zu,align=%d\n", substream->runtime->dma_bytes, dma_get_cache_alignment());

	if (!substream->runtime->dma_area) {
		printk("DMA buffer not allocated!");
		return -ENOMEM;
	}

	switch (cmd) {
	case SNDRV_PCM_TRIGGER_START:
	case SNDRV_PCM_TRIGGER_RESUME:
	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
		dev_info(i2s->dev, "Start stream: %s\n",
			substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? "Playback" : "Capture");

		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
			writel(readl(i2s->base + I2S_SACR1) & ~SACR1_DRPL, i2s->base + I2S_SACR1);
		} else {
			writel(readl(i2s->base + I2S_SACR1) & ~SACR1_DREC, i2s->base + I2S_SACR1);
		}
		writel(readl(i2s->base + I2S_SACR0) | SACR0_ENB, i2s->base + I2S_SACR0);
		break;

	case SNDRV_PCM_TRIGGER_STOP:
	case SNDRV_PCM_TRIGGER_SUSPEND:
	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
//		dev_info(i2s->dev, "Stop stream: %s\n",
//			substream->stream == SNDRV_PCM_STREAM_PLAYBACK ? "Playback" : "Capture");

//		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
//			writel(readl(i2s->base + I2S_SACR1) | SACR1_DRPL, i2s->base + I2S_SACR1);
//		else
//			writel(readl(i2s->base + I2S_SACR1) | SACR1_DREC, i2s->base + I2S_SACR1);
//		writel(readl(i2s->base + I2S_SACR0) & ~SACR0_ENB, i2s->base + I2S_SACR0);
		break;

	default:
		return -EINVAL;
	}

	return 0;
}

static int ark1668ed_i2s_set_fmt(
	struct snd_soc_dai *dai, unsigned int fmt)
{//printk("#########%s(%d)\n", __func__, __LINE__);
	struct ark1668ed_i2s_priv *i2s = snd_soc_dai_get_drvdata(dai);
	/* 设置数据格式 */
	switch (fmt & SND_SOC_DAIFMT_FORMAT_MASK) {
	case SND_SOC_DAIFMT_I2S:
		i2s->fmt = 0;
		break;
	case SND_SOC_DAIFMT_RIGHT_J:
		break;
	case SND_SOC_DAIFMT_LEFT_J:
		break;
	case SND_SOC_DAIFMT_DSP_A:
		break;
	case SND_SOC_DAIFMT_DSP_B:
		break;
	default:
		return -EINVAL;
    }

	switch (fmt & SND_SOC_DAIFMT_CLOCK_PROVIDER_MASK) {
	case SND_SOC_DAIFMT_BP_FP:
		printk("######### i2s master#########\n");
		i2s->master = 1;
		break;
	case SND_SOC_DAIFMT_BC_FC:
		printk("#########i2s slave#########\n");
		i2s->master = 0;
		break;
	default:
		return -EINVAL;
	}

	return 0;
}


/* I2S supported rate and format */
#define ARK1668ED_I2S_RATES \
	(SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_16000 | SNDRV_PCM_RATE_22050 | \
	SNDRV_PCM_RATE_32000 | SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 | \
	SNDRV_PCM_RATE_64000 | SNDRV_PCM_RATE_88200 | SNDRV_PCM_RATE_96000 | \
	SNDRV_PCM_RATE_176400 | SNDRV_PCM_RATE_192000 | SNDRV_PCM_RATE_8000)

static const struct snd_soc_dai_ops ark1668ed_dai_ops = {
	.probe = ark1668ed_i2s_probe,
	.startup	= ark1668ed_i2s_startup,
	.hw_params = ark1668ed_hw_params,
	.trigger = ark1668ed_trigger,
	.set_fmt		= ark1668ed_i2s_set_fmt,
};

static struct snd_soc_dai_driver ark1668ed_dai = {
	.name = "ark1668ed-i2s",
	.playback = {
		.stream_name = "Playback",
		.channels_min = 1,
		.channels_max = 2,
		.rates = ARK1668ED_I2S_RATES,
		.formats = SNDRV_PCM_FMTBIT_S16_LE |
				SNDRV_PCM_FMTBIT_S24_LE |
				SNDRV_PCM_FMTBIT_S32_LE,
	},
	.capture = {
		.stream_name = "Capture",
		.channels_min = 1,
		.channels_max = 2,
		.rates = ARK1668ED_I2S_RATES,
		.formats = SNDRV_PCM_FMTBIT_S16_LE |
			SNDRV_PCM_FMTBIT_S24_LE |
			SNDRV_PCM_FMTBIT_S32_LE,
	},
	.ops = &ark1668ed_dai_ops,
	.symmetric_rate = 1,
};

static struct snd_pcm_hardware ark1668ed_pcm_hardware = {
	.info				= (SNDRV_PCM_INFO_MMAP |
						SNDRV_PCM_INFO_MMAP_VALID |
						SNDRV_PCM_INFO_PAUSE |
						SNDRV_PCM_INFO_RESUME |
						SNDRV_PCM_INFO_INTERLEAVED |
						SNDRV_PCM_INFO_BLOCK_TRANSFER),
	.formats			= SNDRV_PCM_FMTBIT_S16_LE | SNDRV_PCM_FMTBIT_S24_LE |
						SNDRV_PCM_FMTBIT_S32_LE,
	.rates				= (SNDRV_PCM_RATE_11025 | SNDRV_PCM_RATE_16000 |
						SNDRV_PCM_RATE_22050 | SNDRV_PCM_RATE_32000 |
						SNDRV_PCM_RATE_44100 | SNDRV_PCM_RATE_48000 |
						SNDRV_PCM_RATE_64000 | SNDRV_PCM_RATE_88200 |
						SNDRV_PCM_RATE_96000 | SNDRV_PCM_RATE_176400 |
						SNDRV_PCM_RATE_192000 | SNDRV_PCM_RATE_8000),
	.rate_min			= 8000,
	.rate_max			= 192000,
	.channels_min		= 1,
	.channels_max		= 2,
	.buffer_bytes_max	= 128 * 1024,
	.period_bytes_min	= 64,
	.period_bytes_max	= 64 * 1024,//(0xfff & ~0x3)
	.periods_min		= 2,
	.periods_max		= 64,
	.fifo_size = 32,
};

static const struct snd_dmaengine_pcm_config
ark1668ed_i2s_dmaengine_pcm_config = {
	.prepare_slave_config	= snd_dmaengine_pcm_prepare_slave_config,
	.pcm_hardware		= &ark1668ed_pcm_hardware,
};

static const struct snd_soc_component_driver ark1668ed_i2s_component = {
	.name		= DRV_NAME,
	.legacy_dai_naming = 1,
};

static int ark1668ed_i2s_drv_probe(struct platform_device *pdev)
{
	struct ark1668ed_i2s_priv *i2s;
	struct device_node *np = pdev->dev.of_node;
	//struct snd_dmaengine_pcm_config *dmaengine_cfg;
	struct resource *res;
	u32 val;
	int ret;
	//struct snd_soc_dai_driver *dai;

	i2s = devm_kzalloc(&pdev->dev, sizeof(*i2s), GFP_KERNEL);
	if (!i2s)
		return -ENOMEM;

	i2s->dev = &pdev->dev;

	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	i2s->base = devm_ioremap_resource(&pdev->dev, res);
	if (IS_ERR(i2s->base))
		return PTR_ERR(i2s->base);

	i2s->dma_addr = res->start;

	if (!of_property_read_u32(pdev->dev.of_node, "nco-reg", &val))
		i2s->nco_reg = val;

	if (!of_property_read_u32(pdev->dev.of_node, "adc-nco-reg", &val))
		i2s->adc_nco_reg = val;

	if (of_property_read_bool(pdev->dev.of_node, "full-duplex-mode"))
		i2s->full_duplex_en = 1;
	//printk(">>>>>>>>>>>>>>>>>>i2s->full_duplex_en = %d\n",i2s->full_duplex_en);

	i2s->clk = of_clk_get(pdev->dev.of_node, 0);
	if (IS_ERR(i2s->clk))
		return PTR_ERR(i2s->clk);

	i2s->irq = platform_get_irq(pdev, 0);
	if (i2s->irq < 0)
		return i2s->irq;

	ret = devm_request_irq(&pdev->dev, i2s->irq, ark1668ed_irq_handler,
			   IRQF_SHARED, DRV_NAME, i2s);
	if (ret) {
		dev_err(&pdev->dev, "Failed to request IRQ: %d\n", ret);
		return ret;
	}

	ret = of_property_read_u32(np, "index", &i2s->index);
	if (ret) {
		//dev_info(&pdev->dev, "Using calculated index: %u\n", i2s->index);
	} else {
		//dev_info(&pdev->dev, "Using device tree index: %u\n", i2s->index);
	}
	ark1668ed_dai.id = i2s->index;

	struct property *dma_names;
	const char *dma_name;
	struct device_node *node = i2s->dev->of_node;

	of_property_for_each_string(node, "dma-names", dma_names, dma_name) {
		if (!strcmp(dma_name, "tx")) {
			i2s->has_playback = true; }
		if (!strcmp(dma_name, "rx")) {
			i2s->has_capture = true; }
	}

	i2s->playback_dma_data.addr = res->start + I2S_SADR;
	i2s->playback_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
	i2s->playback_dma_data.maxburst = 16;

	i2s->capture_dma_data.addr = res->start + I2S_SADR;
	i2s->capture_dma_data.addr_width = DMA_SLAVE_BUSWIDTH_4_BYTES;
	i2s->capture_dma_data.maxburst = 16;

	ret = devm_snd_soc_register_component(&pdev->dev,
		     &ark1668ed_i2s_component,
		     &ark1668ed_dai, 1);
	if (ret) {
		printk(">>>>>>>Failed to register DAI: %d\n", ret);
		return ret;
	}

	platform_set_drvdata(pdev, i2s);

	ret = devm_snd_dmaengine_pcm_register(&pdev->dev, &ark1668ed_i2s_dmaengine_pcm_config, 0);
	if (ret) {
		dev_err(&pdev->dev, "Failed to register PCM: %d\n", ret);
		return ret;
	}

	dev_info(&pdev->dev, "Virtual Platform Driver probed successfully\n");

	return 0;
}

static const struct of_device_id ark1668ed_match[] = {
	{ .compatible = "arkmicro,ark1668ed-i2s", },
	{}
};
MODULE_DEVICE_TABLE(of, ark1668ed_match);

static struct platform_driver ark1668ed_driver = {
	.probe = ark1668ed_i2s_drv_probe,
	.driver = {
		.name = DRV_NAME,
		.of_match_table = ark1668ed_match,
	},
};

module_platform_driver(ark1668ed_driver);

MODULE_AUTHOR("ark");
MODULE_DESCRIPTION("Virtual Platform Driver for Linux 6.12.116");
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:" DRV_NAME);