Unverified Commit e8e8c4a5 authored by Mark Brown's avatar Mark Brown
Browse files

Merge series "ASoC: Add common modules support for ACP hw block" from Ajit... 

Merge series "ASoC: Add common modules support for ACP hw block" from Ajit Kumar Pandey <AjitKumar.Pandey@amd.com>:

changes since v3:
- rebase and fixes merge conflict.
- Fixed kernel autobot warning.

Ajit Kumar Pandey (8):
  ASoC: amd: Add common framework to support I2S on ACP SOC
  ASoC: amd: acp: Add I2S support on Renoir platform
  ASoC: amd: acp: Add callback for machine driver on ACP
  ASoC: amd: acp: Add generic machine driver support for ACP cards
  ASoC: amd: acp: Add legacy sound card support for Chrome audio
  ASoC: amd: acp: Add SOF audio support on Chrome board
  ASoC: amd: acp: Add support for Maxim amplifier codec
  ASoC: amd: acp: Add support for RT5682-VS codec

 sound/soc/amd/Kconfig                |   2 +
 sound/soc/amd/Makefile               |   1 +
 sound/soc/amd/acp/Kconfig            |  51 +++
 sound/soc/amd/acp/Makefile           |  26 ++
 sound/soc/amd/acp/acp-i2s.c          | 340 +++++++++++++++
 sound/soc/amd/acp/acp-legacy-mach.c  | 104 +++++
 sound/soc/amd/acp/acp-mach-common.c  | 600 +++++++++++++++++++++++++++
 sound/soc/amd/acp/acp-mach.h         |  57 +++
 sound/soc/amd/acp/acp-platform.c     | 315 ++++++++++++++
 sound/soc/amd/acp/acp-renoir.c       | 144 +++++++
 sound/soc/amd/acp/acp-sof-mach.c     | 131 ++++++
 sound/soc/amd/acp/amd.h              | 146 +++++++
 sound/soc/amd/acp/chip_offset_byte.h |  76 ++++
 13 files changed, 1993 insertions(+)
 create mode 100644 sound/soc/amd/acp/Kconfig
 create mode 100644 sound/soc/amd/acp/Makefile
 create mode 100644 sound/soc/amd/acp/acp-i2s.c
 create mode 100644 sound/soc/amd/acp/acp-legacy-mach.c
 create mode 100644 sound/soc/amd/acp/acp-mach-common.c
 create mode 100644 sound/soc/amd/acp/acp-mach.h
 create mode 100644 sound/soc/amd/acp/acp-platform.c
 create mode 100644 sound/soc/amd/acp/acp-renoir.c
 create mode 100644 sound/soc/amd/acp/acp-sof-mach.c
 create mode 100644 sound/soc/amd/acp/amd.h
 create mode 100644 sound/soc/amd/acp/chip_offset_byte.h

--
2.25.1
parents d96e75bb 8b725626

sound/soc/amd/Kconfig

+2 −0
Original line number Diff line number Diff line
@@ -95,3 +95,5 @@ config SND_SOC_AMD_YC_MACH 
	  DMIC can be connected directly to ACP IP.

	  Say m if you have such a device.

	  If unsure select "N".



source "sound/soc/amd/acp/Kconfig"

sound/soc/amd/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -12,3 +12,4 @@ obj-$(CONFIG_SND_SOC_AMD_RV_RT5682_MACH) += snd-soc-acp-rt5682-mach.o 
obj-$(CONFIG_SND_SOC_AMD_RENOIR) += renoir/

obj-$(CONFIG_SND_SOC_AMD_ACP5x) += vangogh/

obj-$(CONFIG_SND_SOC_AMD_ACP6x) += yc/

obj-$(CONFIG_SND_SOC_AMD_ACP_COMMON) += acp/

sound/soc/amd/acp/Kconfig

0 → 100644
+51 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)

# This file is provided under a dual BSD/GPLv2 license. When using or

# redistributing this file, you may do so under either license.

#

# Copyright(c) 2021 Advanced Micro Devices, Inc. All rights reserved.

#



config SND_SOC_AMD_ACP_COMMON

	tristate "AMD Audio ACP Common support"

	select SND_AMD_ACP_CONFIG

	help

	  This option enables common modules for Audio-Coprocessor i.e. ACP

	  IP block on AMD platforms.



config SND_SOC_AMD_ACP_I2S

	tristate



config SND_SOC_AMD_ACP_PCM

	tristate



config SND_AMD_ASOC_RENOIR

	tristate "AMD ACP ASOC Renoir Support"

	select SND_SOC_AMD_ACP_PCM

	select SND_SOC_AMD_ACP_I2S

	depends on X86 && PCI

	help

	  This option enables Renoir I2S support on AMD platform.



config SND_SOC_AMD_MACH_COMMON

	tristate

	select CLK_FIXED_FCH

	select SND_SOC_RT5682_I2C

	select SND_SOC_DMIC

	select SND_SOC_RT1019

	select SND_SOC_MAX98357A

	select SND_SOC_RT5682S

	depends on X86 && PCI && I2C

	help

	  This option enables common Machine driver module for ACP.



config SND_SOC_AMD_LEGACY_MACH

	tristate "AMD Legacy Machine Driver Support"

	select SND_SOC_AMD_MACH_COMMON

	help

	  This option enables legacy sound card support for ACP audio.



config SND_SOC_AMD_SOF_MACH

	tristate "AMD SOF Machine Driver Support"

	select SND_SOC_AMD_MACH_COMMON

	help

	  This option enables SOF sound card support for ACP audio.

sound/soc/amd/acp/Makefile

0 → 100644
+26 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)

# This file is provided under a dual BSD/GPLv2 license. When using or

# redistributing this file, you may do so under either license.

#

# Copyright(c) 2021 Advanced Micro Devices, Inc. All rights reserved.



#common acp driver

snd-acp-pcm-objs     := acp-platform.o

snd-acp-i2s-objs     := acp-i2s.o



#platform specific driver

snd-acp-renoir-objs     := acp-renoir.o



#machine specific driver

snd-acp-mach-objs     := acp-mach-common.o

snd-acp-legacy-mach-objs     := acp-legacy-mach.o

snd-acp-sof-mach-objs     := acp-sof-mach.o



obj-$(CONFIG_SND_SOC_AMD_ACP_PCM) += snd-acp-pcm.o

obj-$(CONFIG_SND_SOC_AMD_ACP_I2S) += snd-acp-i2s.o



obj-$(CONFIG_SND_AMD_ASOC_RENOIR) += snd-acp-renoir.o



obj-$(CONFIG_SND_SOC_AMD_MACH_COMMON) += snd-acp-mach.o

obj-$(CONFIG_SND_SOC_AMD_LEGACY_MACH) += snd-acp-legacy-mach.o

obj-$(CONFIG_SND_SOC_AMD_SOF_MACH) += snd-acp-sof-mach.o

sound/soc/amd/acp/acp-i2s.c

0 → 100644
+340 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: (GPL-2.0-only OR BSD-3-Clause)

//

// This file is provided under a dual BSD/GPLv2 license. When using or

// redistributing this file, you may do so under either license.

//

// Copyright(c) 2021 Advanced Micro Devices, Inc.

//

// Authors: Ajit Kumar Pandey <AjitKumar.Pandey@amd.com>

//



/*

 * Generic Hardware interface for ACP Audio I2S controller

 */



#include <linux/platform_device.h>

#include <linux/module.h>

#include <linux/err.h>

#include <linux/io.h>

#include <sound/pcm_params.h>

#include <sound/soc.h>

#include <sound/soc-dai.h>

#include <linux/dma-mapping.h>



#include "amd.h"



#define DRV_NAME "acp_i2s_playcap"



static int acp_i2s_hwparams(struct snd_pcm_substream *substream, struct snd_pcm_hw_params *params,

			    struct snd_soc_dai *dai)

{

	struct device *dev = dai->component->dev;

	struct acp_dev_data *adata;

	u32 val;

	u32 xfer_resolution;

	u32 reg_val;



	adata = snd_soc_dai_get_drvdata(dai);



	/* These values are as per Hardware Spec */

	switch (params_format(params)) {

	case SNDRV_PCM_FORMAT_U8:

	case SNDRV_PCM_FORMAT_S8:

		xfer_resolution = 0x0;

		break;

	case SNDRV_PCM_FORMAT_S16_LE:

		xfer_resolution = 0x02;

		break;

	case SNDRV_PCM_FORMAT_S24_LE:

		xfer_resolution = 0x04;

		break;

	case SNDRV_PCM_FORMAT_S32_LE:

		xfer_resolution = 0x05;

		break;

	default:

		return -EINVAL;

	}



	if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

		switch (dai->driver->id) {

		case I2S_BT_INSTANCE:

			reg_val = ACP_BTTDM_ITER;

			break;

		case I2S_SP_INSTANCE:

			reg_val = ACP_I2STDM_ITER;

			break;

		default:

			dev_err(dev, "Invalid dai id %x\n", dai->driver->id);

			return -EINVAL;

		}

	} else {

		switch (dai->driver->id) {

		case I2S_BT_INSTANCE:

			reg_val = ACP_BTTDM_IRER;

			break;

		case I2S_SP_INSTANCE:

			reg_val = ACP_I2STDM_IRER;

			break;

		default:

			dev_err(dev, "Invalid dai id %x\n", dai->driver->id);

			return -EINVAL;

		}

	}



	val = readl(adata->acp_base + reg_val);

	val &= ~ACP3x_ITER_IRER_SAMP_LEN_MASK;

	val = val | (xfer_resolution  << 3);

	writel(val, adata->acp_base + reg_val);



	return 0;

}



static int acp_i2s_trigger(struct snd_pcm_substream *substream, int cmd, struct snd_soc_dai *dai)

{

	struct acp_stream *stream = substream->runtime->private_data;

	struct device *dev = dai->component->dev;

	struct acp_dev_data *adata = dev_get_drvdata(dev);

	u32 val, period_bytes, reg_val, ier_val, water_val, buf_size, buf_reg;



	period_bytes = frames_to_bytes(substream->runtime, substream->runtime->period_size);

	buf_size = frames_to_bytes(substream->runtime, substream->runtime->buffer_size);



	switch (cmd) {

	case SNDRV_PCM_TRIGGER_START:

	case SNDRV_PCM_TRIGGER_RESUME:

	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:

		stream->bytescount = acp_get_byte_count(adata, stream->dai_id, substream->stream);

		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

			switch (dai->driver->id) {

			case I2S_BT_INSTANCE:

				water_val = ACP_BT_TX_INTR_WATERMARK_SIZE;

				reg_val = ACP_BTTDM_ITER;

				ier_val = ACP_BTTDM_IER;

				buf_reg = ACP_BT_TX_RINGBUFSIZE;

				break;

			case I2S_SP_INSTANCE:

				water_val = ACP_I2S_TX_INTR_WATERMARK_SIZE;

				reg_val = ACP_I2STDM_ITER;

				ier_val = ACP_I2STDM_IER;

				buf_reg = ACP_I2S_TX_RINGBUFSIZE;

				break;

			default:

				dev_err(dev, "Invalid dai id %x\n", dai->driver->id);

				return -EINVAL;

			}

		} else {

			switch (dai->driver->id) {

			case I2S_BT_INSTANCE:

				water_val = ACP_BT_RX_INTR_WATERMARK_SIZE;

				reg_val = ACP_BTTDM_IRER;

				ier_val = ACP_BTTDM_IER;

				buf_reg = ACP_BT_RX_RINGBUFSIZE;

				break;

			case I2S_SP_INSTANCE:

				water_val = ACP_I2S_RX_INTR_WATERMARK_SIZE;

				reg_val = ACP_I2STDM_IRER;

				ier_val = ACP_I2STDM_IER;

				buf_reg = ACP_I2S_RX_RINGBUFSIZE;

				break;

			default:

				dev_err(dev, "Invalid dai id %x\n", dai->driver->id);

				return -EINVAL;

			}

		}

		writel(period_bytes, adata->acp_base + water_val);

		writel(buf_size, adata->acp_base + buf_reg);

		val = readl(adata->acp_base + reg_val);

		val = val | BIT(0);

		writel(val, adata->acp_base + reg_val);

		writel(1, adata->acp_base + ier_val);

		return 0;

	case SNDRV_PCM_TRIGGER_STOP:

	case SNDRV_PCM_TRIGGER_SUSPEND:

	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:

		if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {

			switch (dai->driver->id) {

			case I2S_BT_INSTANCE:

				reg_val = ACP_BTTDM_ITER;

				break;

			case I2S_SP_INSTANCE:

				reg_val = ACP_I2STDM_ITER;

				break;

			default:

				dev_err(dev, "Invalid dai id %x\n", dai->driver->id);

				return -EINVAL;

			}



		} else {

			switch (dai->driver->id) {

			case I2S_BT_INSTANCE:

				reg_val = ACP_BTTDM_IRER;

				break;

			case I2S_SP_INSTANCE:

				reg_val = ACP_I2STDM_IRER;

				break;

			default:

				dev_err(dev, "Invalid dai id %x\n", dai->driver->id);

				return -EINVAL;

			}

		}

		val = readl(adata->acp_base + reg_val);

		val = val & ~BIT(0);

		writel(val, adata->acp_base + reg_val);



		if (!(readl(adata->acp_base + ACP_BTTDM_ITER) & BIT(0)) &&

		    !(readl(adata->acp_base + ACP_BTTDM_IRER) & BIT(0)))

			writel(0, adata->acp_base + ACP_BTTDM_IER);

		if (!(readl(adata->acp_base + ACP_I2STDM_ITER) & BIT(0)) &&

		    !(readl(adata->acp_base + ACP_I2STDM_IRER) & BIT(0)))

			writel(0, adata->acp_base + ACP_I2STDM_IER);

		return 0;

	default:

		return -EINVAL;

	}



	return 0;

}



static int acp_i2s_prepare(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)

{

	struct device *dev = dai->component->dev;

	struct acp_dev_data *adata = dev_get_drvdata(dev);

	struct acp_stream *stream = substream->runtime->private_data;

	u32 reg_dma_size = 0, reg_fifo_size = 0, reg_fifo_addr = 0;

	u32 phy_addr = 0, acp_fifo_addr = 0, ext_int_ctrl;

	unsigned int dir = substream->stream;



	switch (dai->driver->id) {

	case I2S_SP_INSTANCE:

		if (dir == SNDRV_PCM_STREAM_PLAYBACK) {

			reg_dma_size = ACP_I2S_TX_DMA_SIZE;

			acp_fifo_addr = ACP_SRAM_PTE_OFFSET +

						SP_PB_FIFO_ADDR_OFFSET;

			reg_fifo_addr =	ACP_I2S_TX_FIFOADDR;

			reg_fifo_size = ACP_I2S_TX_FIFOSIZE;



			phy_addr = I2S_SP_TX_MEM_WINDOW_START + stream->reg_offset;

			writel(phy_addr, adata->acp_base + ACP_I2S_TX_RINGBUFADDR);

		} else {

			reg_dma_size = ACP_I2S_RX_DMA_SIZE;

			acp_fifo_addr = ACP_SRAM_PTE_OFFSET +

						SP_CAPT_FIFO_ADDR_OFFSET;

			reg_fifo_addr = ACP_I2S_RX_FIFOADDR;

			reg_fifo_size = ACP_I2S_RX_FIFOSIZE;

			phy_addr = I2S_SP_RX_MEM_WINDOW_START + stream->reg_offset;

			writel(phy_addr, adata->acp_base + ACP_I2S_RX_RINGBUFADDR);

		}

		break;

	case I2S_BT_INSTANCE:

		if (dir == SNDRV_PCM_STREAM_PLAYBACK) {

			reg_dma_size = ACP_BT_TX_DMA_SIZE;

			acp_fifo_addr = ACP_SRAM_PTE_OFFSET +

						BT_PB_FIFO_ADDR_OFFSET;

			reg_fifo_addr = ACP_BT_TX_FIFOADDR;

			reg_fifo_size = ACP_BT_TX_FIFOSIZE;



			phy_addr = I2S_BT_TX_MEM_WINDOW_START + stream->reg_offset;

			writel(phy_addr, adata->acp_base + ACP_BT_TX_RINGBUFADDR);

		} else {

			reg_dma_size = ACP_BT_RX_DMA_SIZE;

			acp_fifo_addr = ACP_SRAM_PTE_OFFSET +

						BT_CAPT_FIFO_ADDR_OFFSET;

			reg_fifo_addr = ACP_BT_RX_FIFOADDR;

			reg_fifo_size = ACP_BT_RX_FIFOSIZE;



			phy_addr = I2S_BT_TX_MEM_WINDOW_START + stream->reg_offset;

			writel(phy_addr, adata->acp_base + ACP_BT_RX_RINGBUFADDR);

		}

		break;

	default:

		dev_err(dev, "Invalid dai id %x\n", dai->driver->id);

		return -EINVAL;

	}



	writel(DMA_SIZE, adata->acp_base + reg_dma_size);

	writel(acp_fifo_addr, adata->acp_base + reg_fifo_addr);

	writel(FIFO_SIZE, adata->acp_base + reg_fifo_size);



	ext_int_ctrl = readl(adata->acp_base + ACP_EXTERNAL_INTR_CNTL);

	ext_int_ctrl |= BIT(I2S_RX_THRESHOLD) | BIT(BT_RX_THRESHOLD)

			| BIT(I2S_TX_THRESHOLD) | BIT(BT_TX_THRESHOLD);



	writel(ext_int_ctrl, adata->acp_base + ACP_EXTERNAL_INTR_CNTL);



	return 0;

}



static int acp_i2s_startup(struct snd_pcm_substream *substream, struct snd_soc_dai *dai)

{

	struct acp_stream *stream = substream->runtime->private_data;

	struct device *dev = dai->component->dev;

	unsigned int dir = substream->stream;

	unsigned int irq_bit = 0;



	switch (dai->driver->id) {

	case I2S_SP_INSTANCE:

		if (dir == SNDRV_PCM_STREAM_PLAYBACK) {

			irq_bit = BIT(I2S_TX_THRESHOLD);

			stream->pte_offset = ACP_SRAM_SP_PB_PTE_OFFSET;

			stream->fifo_offset = SP_PB_FIFO_ADDR_OFFSET;

		} else {

			irq_bit = BIT(I2S_RX_THRESHOLD);

			stream->pte_offset = ACP_SRAM_SP_CP_PTE_OFFSET;

			stream->fifo_offset = SP_CAPT_FIFO_ADDR_OFFSET;

		}

		break;

	case I2S_BT_INSTANCE:

		if (dir == SNDRV_PCM_STREAM_PLAYBACK) {

			irq_bit = BIT(BT_TX_THRESHOLD);

			stream->pte_offset = ACP_SRAM_BT_PB_PTE_OFFSET;

			stream->fifo_offset = BT_PB_FIFO_ADDR_OFFSET;

		} else {

			irq_bit = BIT(BT_RX_THRESHOLD);

			stream->pte_offset = ACP_SRAM_BT_CP_PTE_OFFSET;

			stream->fifo_offset = BT_CAPT_FIFO_ADDR_OFFSET;

		}

		break;

	default:

		dev_err(dev, "Invalid dai id %x\n", dai->driver->id);

		return -EINVAL;

	}



	/* Save runtime dai configuration in stream */

	stream->id = dai->driver->id + dir;

	stream->dai_id = dai->driver->id;

	stream->irq_bit = irq_bit;



	return 0;

}



const struct snd_soc_dai_ops asoc_acp_cpu_dai_ops = {

	.startup = acp_i2s_startup,

	.hw_params = acp_i2s_hwparams,

	.prepare = acp_i2s_prepare,

	.trigger = acp_i2s_trigger,

};

EXPORT_SYMBOL_NS_GPL(asoc_acp_cpu_dai_ops, SND_SOC_ACP_COMMON);



int asoc_acp_i2s_probe(struct snd_soc_dai *dai)

{

	struct device *dev = dai->component->dev;

	struct acp_dev_data *adata = dev_get_drvdata(dev);

	unsigned int val;



	if (!adata->acp_base) {

		dev_err(dev, "I2S base is NULL\n");

		return -EINVAL;

	}



	val = readl(adata->acp_base + ACP_I2S_PIN_CONFIG);

	if (val != I2S_MODE) {

		dev_err(dev, "I2S Mode not supported val %x\n", val);

		return -EINVAL;

	}



	return 0;

}

EXPORT_SYMBOL_NS_GPL(asoc_acp_i2s_probe, SND_SOC_ACP_COMMON);



MODULE_LICENSE("Dual BSD/GPL");

MODULE_ALIAS(DRV_NAME);