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

Merge series "Add Yellow Carp platform ASoC driver" from Vijendar Mukunda... 

Merge series "Add Yellow Carp platform ASoC driver" from Vijendar Mukunda <Vijendar.Mukunda@amd.com>:

Yellow Carp platform is new APU series based on acp6.x design.
This patch set adds an ASoC driver for the ACP (Audio CoProcessor)
block on AMD Yellow Carp APU with DMIC endpoint support.

changes since v1:
  - fixed SPDX commenting style in acp6x pci driver.
  - fixed Copyright commenting style in acp6x pci driver,
    pdm dma driver and machine driver files.
  - fixed local variable check logic in acp6x_power_on() function.
  - fixed Kconfig indentation issue
  - removed irq_flag local variable in irq handler.
  - add dmi info check in machine driver probe

Vijendar Mukunda (13):
  ASoC: amd: add Yellow Carp ACP6x IP register header
  ASoC: amd: add Yellow Carp ACP PCI driver
  ASoC: amd: add acp6x init/de-init functions
  ASoC: amd: add platform devices for acp6x pdm driver and dmic driver
  ASoC: amd: add acp6x pdm platform driver
  ASoC: amd: add acp6x irq handler
  ASoC: amd: add acp6x pdm driver dma ops
  ASoC: amd: add acp6x pci driver pm ops
  ASoC: amd: add acp6x pdm driver pm ops
  ASoC: amd: enable Yellow carp acp6x drivers build
  ASoC: amd: create platform device for acp6x machine driver
  ASoC: amd: add YC machine driver using dmic
  ASoC: amd: enable Yellow Carp platform machine driver build

 sound/soc/amd/Kconfig                     |  21 +
 sound/soc/amd/Makefile                    |   1 +
 sound/soc/amd/yc/Makefile                 |   9 +
 sound/soc/amd/yc/acp6x-mach.c             | 194 ++++++++++
 sound/soc/amd/yc/acp6x-pdm-dma.c          | 448 ++++++++++++++++++++++
 sound/soc/amd/yc/acp6x.h                  | 107 ++++++
 sound/soc/amd/yc/acp6x_chip_offset_byte.h | 444 +++++++++++++++++++++
 sound/soc/amd/yc/pci-acp6x.c              | 338 ++++++++++++++++
 8 files changed, 1562 insertions(+)
 create mode 100644 sound/soc/amd/yc/Makefile
 create mode 100644 sound/soc/amd/yc/acp6x-mach.c
 create mode 100644 sound/soc/amd/yc/acp6x-pdm-dma.c
 create mode 100644 sound/soc/amd/yc/acp6x.h
 create mode 100644 sound/soc/amd/yc/acp6x_chip_offset_byte.h
 create mode 100644 sound/soc/amd/yc/pci-acp6x.c

--
2.25.1
parents 866d7444 a80d7eda

sound/soc/amd/Kconfig

+21 −0
Original line number Diff line number Diff line
@@ -74,3 +74,24 @@ config SND_SOC_AMD_VANGOGH_MACH 
	  using NAU8821 and CS35L41 codecs.

	  Say m if you have such a device.

	  If unsure select "N".



config SND_SOC_AMD_ACP6x

	tristate "AMD Audio Coprocessor-v6.x Yellow Carp support"

	depends on X86 && PCI

	help

	  This option enables Audio Coprocessor i.e ACP v6.x support on

	  AMD Yellow Carp platform. By enabling this flag build will be

	  triggered for ACP PCI driver, ACP PDM DMA driver.

	  Say m if you have such a device.

	  If unsure select "N".



config SND_SOC_AMD_YC_MACH

	tristate "AMD YC support for DMIC"

	select SND_SOC_DMIC

	depends on SND_SOC_AMD_ACP6x

	help

	  This option enables machine driver for Yellow Carp platform

	  using dmic. ACP IP has PDM Decoder block with DMA controller.

	  DMIC can be connected directly to ACP IP.

	  Say m if you have such a device.

	  If unsure select "N".

sound/soc/amd/Makefile

+1 −0
Original line number Diff line number Diff line
@@ -11,3 +11,4 @@ obj-$(CONFIG_SND_SOC_AMD_ACP3x) += raven/ 
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/

sound/soc/amd/yc/Makefile

0 → 100644
+9 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: GPL-2.0+

# Yellow Carp platform Support

snd-pci-acp6x-objs	:= pci-acp6x.o

snd-acp6x-pdm-dma-objs	:= acp6x-pdm-dma.o

snd-soc-acp6x-mach-objs := acp6x-mach.o



obj-$(CONFIG_SND_SOC_AMD_ACP6x) += snd-pci-acp6x.o

obj-$(CONFIG_SND_SOC_AMD_ACP6x) += snd-acp6x-pdm-dma.o

obj-$(CONFIG_SND_SOC_AMD_YC_MACH)   += snd-soc-acp6x-mach.o

sound/soc/amd/yc/acp6x-mach.c

0 → 100644
+194 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0+

/*

 * Machine driver for AMD Yellow Carp platform using DMIC

 *

 * Copyright 2021 Advanced Micro Devices, Inc.

 */



#include <sound/soc.h>

#include <sound/soc-dapm.h>

#include <linux/module.h>

#include <sound/pcm.h>

#include <sound/pcm_params.h>

#include <linux/io.h>

#include <linux/dmi.h>



#include "acp6x.h"



#define DRV_NAME "acp_yc_mach"



SND_SOC_DAILINK_DEF(acp6x_pdm,

		    DAILINK_COMP_ARRAY(COMP_CPU("acp_yc_pdm_dma.0")));



SND_SOC_DAILINK_DEF(dmic_codec,

		    DAILINK_COMP_ARRAY(COMP_CODEC("dmic-codec.0",

						  "dmic-hifi")));



SND_SOC_DAILINK_DEF(pdm_platform,

		    DAILINK_COMP_ARRAY(COMP_PLATFORM("acp_yc_pdm_dma.0")));



static struct snd_soc_dai_link acp6x_dai_pdm[] = {

	{

		.name = "acp6x-dmic-capture",

		.stream_name = "DMIC capture",

		.capture_only = 1,

		SND_SOC_DAILINK_REG(acp6x_pdm, dmic_codec, pdm_platform),

	},

};



static struct snd_soc_card acp6x_card = {

	.name = "acp6x",

	.owner = THIS_MODULE,

	.dai_link = acp6x_dai_pdm,

	.num_links = 1,

};



static const struct dmi_system_id yc_acp_quirk_table[] = {

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21D2"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21D3"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21D4"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21D5"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21CF"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21CG"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21CQ"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21CR"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21AW"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21AX"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21BN"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21BQ"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21CH"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21CJ"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21CK"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21CL"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21D8"),

		}

	},

	{

		.matches = {

			DMI_MATCH(DMI_BOARD_VENDOR, "LENOVO"),

			DMI_MATCH(DMI_PRODUCT_NAME, "21D9"),

		}

	},

	{}

};



static int acp6x_probe(struct platform_device *pdev)

{

	struct acp6x_pdm *machine = NULL;

	struct snd_soc_card *card;

	int ret;

	const struct dmi_system_id *dmi_id;



	dmi_id = dmi_first_match(yc_acp_quirk_table);

	if (!dmi_id)

		return -ENODEV;

	card = &acp6x_card;

	acp6x_card.dev = &pdev->dev;



	platform_set_drvdata(pdev, card);

	snd_soc_card_set_drvdata(card, machine);

	ret = devm_snd_soc_register_card(&pdev->dev, card);

	if (ret) {

		return dev_err_probe(&pdev->dev, ret,

				"snd_soc_register_card(%s) failed\n",

				card->name);

	}

	return 0;

}



static struct platform_driver acp6x_mach_driver = {

	.driver = {

		.name = "acp_yc_mach",

		.pm = &snd_soc_pm_ops,

	},

	.probe = acp6x_probe,

};



module_platform_driver(acp6x_mach_driver);



MODULE_AUTHOR("Vijendar.Mukunda@amd.com");

MODULE_LICENSE("GPL v2");

MODULE_ALIAS("platform:" DRV_NAME);

sound/soc/amd/yc/acp6x-pdm-dma.c

0 → 100644
+448 −0
Original line number Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0+

/*

 * AMD ALSA SoC Yellow Carp PDM Driver

 *

 * Copyright 2021 Advanced Micro Devices, Inc.

 */



#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/pm_runtime.h>



#include "acp6x.h"



#define DRV_NAME "acp_yc_pdm_dma"



static const struct snd_pcm_hardware acp6x_pdm_hardware_capture = {

	.info = SNDRV_PCM_INFO_INTERLEAVED |

		SNDRV_PCM_INFO_BLOCK_TRANSFER |

		SNDRV_PCM_INFO_MMAP |

		SNDRV_PCM_INFO_MMAP_VALID |

		SNDRV_PCM_INFO_PAUSE | SNDRV_PCM_INFO_RESUME,

	.formats = SNDRV_PCM_FMTBIT_S32_LE,

	.channels_min = 2,

	.channels_max = 2,

	.rates = SNDRV_PCM_RATE_48000,

	.rate_min = 48000,

	.rate_max = 48000,

	.buffer_bytes_max = CAPTURE_MAX_NUM_PERIODS * CAPTURE_MAX_PERIOD_SIZE,

	.period_bytes_min = CAPTURE_MIN_PERIOD_SIZE,

	.period_bytes_max = CAPTURE_MAX_PERIOD_SIZE,

	.periods_min = CAPTURE_MIN_NUM_PERIODS,

	.periods_max = CAPTURE_MAX_NUM_PERIODS,

};



static void acp6x_init_pdm_ring_buffer(u32 physical_addr, u32 buffer_size,

				       u32 watermark_size, void __iomem *acp_base)

{

	acp6x_writel(physical_addr, acp_base + ACP_WOV_RX_RINGBUFADDR);

	acp6x_writel(buffer_size, acp_base + ACP_WOV_RX_RINGBUFSIZE);

	acp6x_writel(watermark_size, acp_base + ACP_WOV_RX_INTR_WATERMARK_SIZE);

	acp6x_writel(0x01, acp_base + ACPAXI2AXI_ATU_CTRL);

}



static void acp6x_enable_pdm_clock(void __iomem *acp_base)

{

	u32 pdm_clk_enable, pdm_ctrl;



	pdm_clk_enable = ACP_PDM_CLK_FREQ_MASK;

	pdm_ctrl = 0x00;



	acp6x_writel(pdm_clk_enable, acp_base + ACP_WOV_CLK_CTRL);

	pdm_ctrl = acp6x_readl(acp_base + ACP_WOV_MISC_CTRL);

	pdm_ctrl |= ACP_WOV_MISC_CTRL_MASK;

	acp6x_writel(pdm_ctrl, acp_base + ACP_WOV_MISC_CTRL);

}



static void acp6x_enable_pdm_interrupts(void __iomem *acp_base)

{

	u32 ext_int_ctrl;



	ext_int_ctrl = acp6x_readl(acp_base + ACP_EXTERNAL_INTR_CNTL);

	ext_int_ctrl |= PDM_DMA_INTR_MASK;

	acp6x_writel(ext_int_ctrl, acp_base + ACP_EXTERNAL_INTR_CNTL);

}



static void acp6x_disable_pdm_interrupts(void __iomem *acp_base)

{

	u32 ext_int_ctrl;



	ext_int_ctrl = acp6x_readl(acp_base + ACP_EXTERNAL_INTR_CNTL);

	ext_int_ctrl &= ~PDM_DMA_INTR_MASK;

	acp6x_writel(ext_int_ctrl, acp_base + ACP_EXTERNAL_INTR_CNTL);

}



static bool acp6x_check_pdm_dma_status(void __iomem *acp_base)

{

	bool pdm_dma_status;

	u32 pdm_enable, pdm_dma_enable;



	pdm_dma_status = false;

	pdm_enable = acp6x_readl(acp_base + ACP_WOV_PDM_ENABLE);

	pdm_dma_enable = acp6x_readl(acp_base + ACP_WOV_PDM_DMA_ENABLE);

	if ((pdm_enable & ACP_PDM_ENABLE) && (pdm_dma_enable & ACP_PDM_DMA_EN_STATUS))

		pdm_dma_status = true;



	return pdm_dma_status;

}



static int acp6x_start_pdm_dma(void __iomem *acp_base)

{

	u32 pdm_enable;

	u32 pdm_dma_enable;

	int timeout;



	pdm_enable = 0x01;

	pdm_dma_enable  = 0x01;



	acp6x_enable_pdm_clock(acp_base);

	acp6x_writel(pdm_enable, acp_base + ACP_WOV_PDM_ENABLE);

	acp6x_writel(pdm_dma_enable, acp_base + ACP_WOV_PDM_DMA_ENABLE);

	timeout = 0;

	while (++timeout < ACP_COUNTER) {

		pdm_dma_enable = acp6x_readl(acp_base + ACP_WOV_PDM_DMA_ENABLE);

		if ((pdm_dma_enable & 0x02) == ACP_PDM_DMA_EN_STATUS)

			return 0;

		udelay(DELAY_US);

	}

	return -ETIMEDOUT;

}



static int acp6x_stop_pdm_dma(void __iomem *acp_base)

{

	u32 pdm_enable, pdm_dma_enable;

	int timeout;



	pdm_enable = 0x00;

	pdm_dma_enable  = 0x00;



	pdm_enable = acp6x_readl(acp_base + ACP_WOV_PDM_ENABLE);

	pdm_dma_enable = acp6x_readl(acp_base + ACP_WOV_PDM_DMA_ENABLE);

	if (pdm_dma_enable & 0x01) {

		pdm_dma_enable = 0x02;

		acp6x_writel(pdm_dma_enable, acp_base + ACP_WOV_PDM_DMA_ENABLE);

		timeout = 0;

		while (++timeout < ACP_COUNTER) {

			pdm_dma_enable = acp6x_readl(acp_base + ACP_WOV_PDM_DMA_ENABLE);

			if ((pdm_dma_enable & 0x02) == 0x00)

				break;

			udelay(DELAY_US);

		}

		if (timeout == ACP_COUNTER)

			return -ETIMEDOUT;

	}

	if (pdm_enable == ACP_PDM_ENABLE) {

		pdm_enable = ACP_PDM_DISABLE;

		acp6x_writel(pdm_enable, acp_base + ACP_WOV_PDM_ENABLE);

	}

	acp6x_writel(0x01, acp_base + ACP_WOV_PDM_FIFO_FLUSH);

	return 0;

}



static void acp6x_config_dma(struct pdm_stream_instance *rtd, int direction)

{

	u16 page_idx;

	u32 low, high, val;

	dma_addr_t addr;



	addr = rtd->dma_addr;

	val = PDM_PTE_OFFSET;



	/* Group Enable */

	acp6x_writel(ACP_SRAM_PTE_OFFSET | BIT(31), rtd->acp6x_base +

		     ACPAXI2AXI_ATU_BASE_ADDR_GRP_1);

	acp6x_writel(PAGE_SIZE_4K_ENABLE, rtd->acp6x_base +

		     ACPAXI2AXI_ATU_PAGE_SIZE_GRP_1);

	for (page_idx = 0; page_idx < rtd->num_pages; page_idx++) {

		/* Load the low address of page int ACP SRAM through SRBM */

		low = lower_32_bits(addr);

		high = upper_32_bits(addr);



		acp6x_writel(low, rtd->acp6x_base + ACP_SCRATCH_REG_0 + val);

		high |= BIT(31);

		acp6x_writel(high, rtd->acp6x_base + ACP_SCRATCH_REG_0 + val + 4);

		val += 8;

		addr += PAGE_SIZE;

	}

}



static int acp6x_pdm_dma_open(struct snd_soc_component *component,

			      struct snd_pcm_substream *substream)

{

	struct snd_pcm_runtime *runtime;

	struct pdm_dev_data *adata;

	struct pdm_stream_instance *pdm_data;

	int ret;



	runtime = substream->runtime;

	adata = dev_get_drvdata(component->dev);

	pdm_data = kzalloc(sizeof(*pdm_data), GFP_KERNEL);

	if (!pdm_data)

		return -EINVAL;



	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)

		runtime->hw = acp6x_pdm_hardware_capture;



	ret = snd_pcm_hw_constraint_integer(runtime,

					    SNDRV_PCM_HW_PARAM_PERIODS);

	if (ret < 0) {

		dev_err(component->dev, "set integer constraint failed\n");

		kfree(pdm_data);

		return ret;

	}



	acp6x_enable_pdm_interrupts(adata->acp6x_base);



	if (substream->stream == SNDRV_PCM_STREAM_CAPTURE)

		adata->capture_stream = substream;



	pdm_data->acp6x_base = adata->acp6x_base;

	runtime->private_data = pdm_data;

	return ret;

}



static int acp6x_pdm_dma_hw_params(struct snd_soc_component *component,

				   struct snd_pcm_substream *substream,

				   struct snd_pcm_hw_params *params)

{

	struct pdm_stream_instance *rtd;

	size_t size, period_bytes;



	rtd = substream->runtime->private_data;

	if (!rtd)

		return -EINVAL;

	size = params_buffer_bytes(params);

	period_bytes = params_period_bytes(params);

	rtd->dma_addr = substream->runtime->dma_addr;

	rtd->num_pages = (PAGE_ALIGN(size) >> PAGE_SHIFT);

	acp6x_config_dma(rtd, substream->stream);

	acp6x_init_pdm_ring_buffer(PDM_MEM_WINDOW_START, size,

				   period_bytes, rtd->acp6x_base);

	return 0;

}



static u64 acp6x_pdm_get_byte_count(struct pdm_stream_instance *rtd,

				    int direction)

{

	union acp_pdm_dma_count byte_count;



	byte_count.bcount.high =

			acp6x_readl(rtd->acp6x_base + ACP_WOV_RX_LINEARPOSITIONCNTR_HIGH);

	byte_count.bcount.low =

			acp6x_readl(rtd->acp6x_base + ACP_WOV_RX_LINEARPOSITIONCNTR_LOW);

	return byte_count.bytescount;

}



static snd_pcm_uframes_t acp6x_pdm_dma_pointer(struct snd_soc_component *comp,

					       struct snd_pcm_substream *stream)

{

	struct pdm_stream_instance *rtd;

	u32 pos, buffersize;

	u64 bytescount;



	rtd = stream->runtime->private_data;

	buffersize = frames_to_bytes(stream->runtime,

				     stream->runtime->buffer_size);

	bytescount = acp6x_pdm_get_byte_count(rtd, stream->stream);

	if (bytescount > rtd->bytescount)

		bytescount -= rtd->bytescount;

	pos = do_div(bytescount, buffersize);

	return bytes_to_frames(stream->runtime, pos);

}



static int acp6x_pdm_dma_new(struct snd_soc_component *component,

			     struct snd_soc_pcm_runtime *rtd)

{

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



	snd_pcm_set_managed_buffer_all(rtd->pcm, SNDRV_DMA_TYPE_DEV,

				       parent, MIN_BUFFER, MAX_BUFFER);

	return 0;

}



static int acp6x_pdm_dma_close(struct snd_soc_component *component,

			       struct snd_pcm_substream *substream)

{

	struct pdm_dev_data *adata = dev_get_drvdata(component->dev);



	acp6x_disable_pdm_interrupts(adata->acp6x_base);

	adata->capture_stream = NULL;

	return 0;

}



static int acp6x_pdm_dai_trigger(struct snd_pcm_substream *substream,

				 int cmd, struct snd_soc_dai *dai)

{

	struct pdm_stream_instance *rtd;

	int ret;

	bool pdm_status;

	unsigned int ch_mask;



	rtd = substream->runtime->private_data;

	ret = 0;

	switch (substream->runtime->channels) {

	case TWO_CH:

		ch_mask = 0x00;

		break;

	default:

		return -EINVAL;

	}

	switch (cmd) {

	case SNDRV_PCM_TRIGGER_START:

	case SNDRV_PCM_TRIGGER_RESUME:

	case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:

		acp6x_writel(ch_mask, rtd->acp6x_base + ACP_WOV_PDM_NO_OF_CHANNELS);

		acp6x_writel(PDM_DECIMATION_FACTOR, rtd->acp6x_base +

			     ACP_WOV_PDM_DECIMATION_FACTOR);

		rtd->bytescount = acp6x_pdm_get_byte_count(rtd, substream->stream);

		pdm_status = acp6x_check_pdm_dma_status(rtd->acp6x_base);

		if (!pdm_status)

			ret = acp6x_start_pdm_dma(rtd->acp6x_base);

		break;

	case SNDRV_PCM_TRIGGER_STOP:

	case SNDRV_PCM_TRIGGER_SUSPEND:

	case SNDRV_PCM_TRIGGER_PAUSE_PUSH:

		pdm_status = acp6x_check_pdm_dma_status(rtd->acp6x_base);

		if (pdm_status)

			ret = acp6x_stop_pdm_dma(rtd->acp6x_base);

		break;

	default:

		ret = -EINVAL;

		break;

	}

	return ret;

}



static struct snd_soc_dai_ops acp6x_pdm_dai_ops = {

	.trigger   = acp6x_pdm_dai_trigger,

};



static struct snd_soc_dai_driver acp6x_pdm_dai_driver = {

	.capture = {

		.rates = SNDRV_PCM_RATE_48000,

		.formats = SNDRV_PCM_FMTBIT_S32_LE,

		.channels_min = 2,

		.channels_max = 2,

		.rate_min = 48000,

		.rate_max = 48000,

	},

	.ops = &acp6x_pdm_dai_ops,

};



static const struct snd_soc_component_driver acp6x_pdm_component = {

	.name		= DRV_NAME,

	.open		= acp6x_pdm_dma_open,

	.close		= acp6x_pdm_dma_close,

	.hw_params	= acp6x_pdm_dma_hw_params,

	.pointer	= acp6x_pdm_dma_pointer,

	.pcm_construct	= acp6x_pdm_dma_new,

};



static int acp6x_pdm_audio_probe(struct platform_device *pdev)

{

	struct resource *res;

	struct pdm_dev_data *adata;

	int status;



	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);

	if (!res) {

		dev_err(&pdev->dev, "IORESOURCE_MEM FAILED\n");

		return -ENODEV;

	}



	adata = devm_kzalloc(&pdev->dev, sizeof(*adata), GFP_KERNEL);

	if (!adata)

		return -ENOMEM;



	adata->acp6x_base = devm_ioremap(&pdev->dev, res->start, resource_size(res));

	if (!adata->acp6x_base)

		return -ENOMEM;



	adata->capture_stream = NULL;



	dev_set_drvdata(&pdev->dev, adata);

	status = devm_snd_soc_register_component(&pdev->dev,

						 &acp6x_pdm_component,

						 &acp6x_pdm_dai_driver, 1);

	if (status) {

		dev_err(&pdev->dev, "Fail to register acp pdm dai\n");



		return -ENODEV;

	}

	pm_runtime_set_autosuspend_delay(&pdev->dev, ACP_SUSPEND_DELAY_MS);

	pm_runtime_use_autosuspend(&pdev->dev);

	pm_runtime_enable(&pdev->dev);

	pm_runtime_allow(&pdev->dev);

	return 0;

}



static int acp6x_pdm_audio_remove(struct platform_device *pdev)

{

	pm_runtime_disable(&pdev->dev);

	return 0;

}



static int __maybe_unused acp6x_pdm_resume(struct device *dev)

{

	struct pdm_dev_data *adata;

	struct snd_pcm_runtime *runtime;

	struct pdm_stream_instance *rtd;

	u32 period_bytes, buffer_len;



	adata = dev_get_drvdata(dev);

	if (adata->capture_stream && adata->capture_stream->runtime) {

		runtime = adata->capture_stream->runtime;

		rtd = runtime->private_data;

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

		buffer_len = frames_to_bytes(runtime, runtime->buffer_size);

		acp6x_config_dma(rtd, SNDRV_PCM_STREAM_CAPTURE);

		acp6x_init_pdm_ring_buffer(PDM_MEM_WINDOW_START, buffer_len,

					   period_bytes, adata->acp6x_base);

	}

	acp6x_enable_pdm_interrupts(adata->acp6x_base);

	return 0;

}



static int __maybe_unused acp6x_pdm_suspend(struct device *dev)

{

	struct pdm_dev_data *adata;



	adata = dev_get_drvdata(dev);

	acp6x_disable_pdm_interrupts(adata->acp6x_base);

	return 0;

}



static int __maybe_unused acp6x_pdm_runtime_resume(struct device *dev)

{

	struct pdm_dev_data *adata;



	adata = dev_get_drvdata(dev);

	acp6x_enable_pdm_interrupts(adata->acp6x_base);

	return 0;

}



static const struct dev_pm_ops acp6x_pdm_pm_ops = {

	SET_RUNTIME_PM_OPS(acp6x_pdm_suspend, acp6x_pdm_runtime_resume, NULL)

	SET_SYSTEM_SLEEP_PM_OPS(acp6x_pdm_suspend, acp6x_pdm_resume)

};



static struct platform_driver acp6x_pdm_dma_driver = {

	.probe = acp6x_pdm_audio_probe,

	.remove = acp6x_pdm_audio_remove,

	.driver = {

		.name = "acp_yc_pdm_dma",

		.pm = &acp6x_pdm_pm_ops,

	},

};



module_platform_driver(acp6x_pdm_dma_driver);



MODULE_AUTHOR("Vijendar.Mukunda@amd.com");

MODULE_DESCRIPTION("AMD ACP6x YC PDM Driver");

MODULE_LICENSE("GPL v2");

MODULE_ALIAS("platform:" DRV_NAME);