Unverified Commit 4b192114 authored by syed saba kareem's avatar syed saba kareem Committed by Mark Brown
Browse files

ASoC: amd: fix ACP version typo mistake 



Pink Sardine is based on ACP6.3 architecture.
This patch fixes the typo mistake acp6.2 -> acp6.3

Signed-off-by: default avatarsyed saba kareem <syed.sabakareem@amd.com>
Link: https://lore.kernel.org/r/20221104121001.207992-1-Syed.SabaKareem@amd.com


Signed-off-by: default avatarMark Brown <broonie@kernel.org>
parent a0e7636b

include/sound/acp62_chip_offset_byte.h→include/sound/acp63_chip_offset_byte.h

+1 −1
Original line number Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0+ */

/*

 * AMD ACP 6.2 Register Documentation

 * AMD ACP 6.3 Register Documentation

 *

 * Copyright 2022 Advanced Micro Devices, Inc.

 */

sound/soc/amd/Kconfig

+2 −2
Original line number Diff line number Diff line
@@ -129,10 +129,10 @@ config SND_SOC_AMD_RPL_ACP6x 
          If unsure select "N".



config SND_SOC_AMD_PS

        tristate "AMD Audio Coprocessor-v6.2 Pink Sardine support"

        tristate "AMD Audio Coprocessor-v6.3 Pink Sardine support"

        depends on X86 && PCI && ACPI

        help

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

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

          AMD Pink sardine 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.

sound/soc/amd/ps/acp62.h→sound/soc/amd/ps/acp63.h

+5 −5
Original line number Diff line number Diff line
@@ -5,7 +5,7 @@ 
 * Copyright (C) 2022 Advanced Micro Devices, Inc. All rights reserved.

 */



#include <sound/acp62_chip_offset_byte.h>

#include <sound/acp63_chip_offset_byte.h>



#define ACP_DEVICE_ID 0x15E2

#define ACP6x_REG_START		0x1240000
@@ -78,21 +78,21 @@ struct pdm_stream_instance { 
	u16 channels;

	dma_addr_t dma_addr;

	u64 bytescount;

	void __iomem *acp62_base;

	void __iomem *acp63_base;

};



struct pdm_dev_data {

	u32 pdm_irq;

	void __iomem *acp62_base;

	void __iomem *acp63_base;

	struct snd_pcm_substream *capture_stream;

};



static inline u32 acp62_readl(void __iomem *base_addr)

static inline u32 acp63_readl(void __iomem *base_addr)

{

	return readl(base_addr);

}



static inline void acp62_writel(u32 val, void __iomem *base_addr)

static inline void acp63_writel(u32 val, void __iomem *base_addr)

{

	writel(val, base_addr);

}

sound/soc/amd/ps/pci-ps.c

+66 −66
Original line number Diff line number Diff line
@@ -15,30 +15,30 @@ 
#include <sound/pcm_params.h>

#include <linux/pm_runtime.h>



#include "acp62.h"

#include "acp63.h"



struct acp62_dev_data {

	void __iomem *acp62_base;

struct acp63_dev_data {

	void __iomem *acp63_base;

	struct resource *res;

	bool acp62_audio_mode;

	bool acp63_audio_mode;

	struct platform_device *pdev[ACP6x_DEVS];

};



static int acp62_power_on(void __iomem *acp_base)

static int acp63_power_on(void __iomem *acp_base)

{

	u32 val;

	int timeout;



	val = acp62_readl(acp_base + ACP_PGFSM_STATUS);

	val = acp63_readl(acp_base + ACP_PGFSM_STATUS);



	if (!val)

		return val;



	if ((val & ACP_PGFSM_STATUS_MASK) != ACP_POWER_ON_IN_PROGRESS)

		acp62_writel(ACP_PGFSM_CNTL_POWER_ON_MASK, acp_base + ACP_PGFSM_CONTROL);

		acp63_writel(ACP_PGFSM_CNTL_POWER_ON_MASK, acp_base + ACP_PGFSM_CONTROL);

	timeout = 0;

	while (++timeout < 500) {

		val = acp62_readl(acp_base + ACP_PGFSM_STATUS);

		val = acp63_readl(acp_base + ACP_PGFSM_STATUS);

		if (!val)

			return 0;

		udelay(1);
@@ -46,23 +46,23 @@ static int acp62_power_on(void __iomem *acp_base) 
	return -ETIMEDOUT;

}



static int acp62_reset(void __iomem *acp_base)

static int acp63_reset(void __iomem *acp_base)

{

	u32 val;

	int timeout;



	acp62_writel(1, acp_base + ACP_SOFT_RESET);

	acp63_writel(1, acp_base + ACP_SOFT_RESET);

	timeout = 0;

	while (++timeout < 500) {

		val = acp62_readl(acp_base + ACP_SOFT_RESET);

		val = acp63_readl(acp_base + ACP_SOFT_RESET);

		if (val & ACP_SOFT_RESET_SOFTRESET_AUDDONE_MASK)

			break;

		cpu_relax();

	}

	acp62_writel(0, acp_base + ACP_SOFT_RESET);

	acp63_writel(0, acp_base + ACP_SOFT_RESET);

	timeout = 0;

	while (++timeout < 500) {

		val = acp62_readl(acp_base + ACP_SOFT_RESET);

		val = acp63_readl(acp_base + ACP_SOFT_RESET);

		if (!val)

			return 0;

		cpu_relax();
@@ -70,57 +70,57 @@ static int acp62_reset(void __iomem *acp_base) 
	return -ETIMEDOUT;

}



static void acp62_enable_interrupts(void __iomem *acp_base)

static void acp63_enable_interrupts(void __iomem *acp_base)

{

	acp62_writel(1, acp_base + ACP_EXTERNAL_INTR_ENB);

	acp63_writel(1, acp_base + ACP_EXTERNAL_INTR_ENB);

}



static void acp62_disable_interrupts(void __iomem *acp_base)

static void acp63_disable_interrupts(void __iomem *acp_base)

{

	acp62_writel(ACP_EXT_INTR_STAT_CLEAR_MASK, acp_base +

	acp63_writel(ACP_EXT_INTR_STAT_CLEAR_MASK, acp_base +

		     ACP_EXTERNAL_INTR_STAT);

	acp62_writel(0, acp_base + ACP_EXTERNAL_INTR_CNTL);

	acp62_writel(0, acp_base + ACP_EXTERNAL_INTR_ENB);

	acp63_writel(0, acp_base + ACP_EXTERNAL_INTR_CNTL);

	acp63_writel(0, acp_base + ACP_EXTERNAL_INTR_ENB);

}



static int acp62_init(void __iomem *acp_base, struct device *dev)

static int acp63_init(void __iomem *acp_base, struct device *dev)

{

	int ret;



	ret = acp62_power_on(acp_base);

	ret = acp63_power_on(acp_base);

	if (ret) {

		dev_err(dev, "ACP power on failed\n");

		return ret;

	}

	acp62_writel(0x01, acp_base + ACP_CONTROL);

	ret = acp62_reset(acp_base);

	acp63_writel(0x01, acp_base + ACP_CONTROL);

	ret = acp63_reset(acp_base);

	if (ret) {

		dev_err(dev, "ACP reset failed\n");

		return ret;

	}

	acp62_writel(0x03, acp_base + ACP_CLKMUX_SEL);

	acp62_enable_interrupts(acp_base);

	acp63_writel(0x03, acp_base + ACP_CLKMUX_SEL);

	acp63_enable_interrupts(acp_base);

	return 0;

}



static int acp62_deinit(void __iomem *acp_base, struct device *dev)

static int acp63_deinit(void __iomem *acp_base, struct device *dev)

{

	int ret;



	acp62_disable_interrupts(acp_base);

	ret = acp62_reset(acp_base);

	acp63_disable_interrupts(acp_base);

	ret = acp63_reset(acp_base);

	if (ret) {

		dev_err(dev, "ACP reset failed\n");

		return ret;

	}

	acp62_writel(0, acp_base + ACP_CLKMUX_SEL);

	acp62_writel(0, acp_base + ACP_CONTROL);

	acp63_writel(0, acp_base + ACP_CLKMUX_SEL);

	acp63_writel(0, acp_base + ACP_CONTROL);

	return 0;

}



static irqreturn_t acp62_irq_handler(int irq, void *dev_id)

static irqreturn_t acp63_irq_handler(int irq, void *dev_id)

{

	struct acp62_dev_data *adata;

	struct acp63_dev_data *adata;

	struct pdm_dev_data *ps_pdm_data;

	u32 val;
@@ -128,10 +128,10 @@ static irqreturn_t acp62_irq_handler(int irq, void *dev_id) 
	if (!adata)

		return IRQ_NONE;



	val = acp62_readl(adata->acp62_base + ACP_EXTERNAL_INTR_STAT);

	val = acp63_readl(adata->acp63_base + ACP_EXTERNAL_INTR_STAT);

	if (val & BIT(PDM_DMA_STAT)) {

		ps_pdm_data = dev_get_drvdata(&adata->pdev[0]->dev);

		acp62_writel(BIT(PDM_DMA_STAT), adata->acp62_base + ACP_EXTERNAL_INTR_STAT);

		acp63_writel(BIT(PDM_DMA_STAT), adata->acp63_base + ACP_EXTERNAL_INTR_STAT);

		if (ps_pdm_data->capture_stream)

			snd_pcm_period_elapsed(ps_pdm_data->capture_stream);

		return IRQ_HANDLED;
@@ -139,10 +139,10 @@ static irqreturn_t acp62_irq_handler(int irq, void *dev_id) 
	return IRQ_NONE;

}



static int snd_acp62_probe(struct pci_dev *pci,

static int snd_acp63_probe(struct pci_dev *pci,

			   const struct pci_device_id *pci_id)

{

	struct acp62_dev_data *adata;

	struct acp63_dev_data *adata;

	struct platform_device_info pdevinfo[ACP6x_DEVS];

	int index, ret;

	int val = 0x00;
@@ -157,7 +157,7 @@ static int snd_acp62_probe(struct pci_dev *pci, 
	case 0x63:

		break;

	default:

		dev_dbg(&pci->dev, "acp62 pci device not found\n");

		dev_dbg(&pci->dev, "acp63 pci device not found\n");

		return -ENODEV;

	}

	if (pci_enable_device(pci)) {
@@ -170,7 +170,7 @@ static int snd_acp62_probe(struct pci_dev *pci, 
		dev_err(&pci->dev, "pci_request_regions failed\n");

		goto disable_pci;

	}

	adata = devm_kzalloc(&pci->dev, sizeof(struct acp62_dev_data),

	adata = devm_kzalloc(&pci->dev, sizeof(struct acp63_dev_data),

			     GFP_KERNEL);

	if (!adata) {

		ret = -ENOMEM;
@@ -178,18 +178,18 @@ static int snd_acp62_probe(struct pci_dev *pci, 
	}



	addr = pci_resource_start(pci, 0);

	adata->acp62_base = devm_ioremap(&pci->dev, addr,

	adata->acp63_base = devm_ioremap(&pci->dev, addr,

					 pci_resource_len(pci, 0));

	if (!adata->acp62_base) {

	if (!adata->acp63_base) {

		ret = -ENOMEM;

		goto release_regions;

	}

	pci_set_master(pci);

	pci_set_drvdata(pci, adata);

	ret = acp62_init(adata->acp62_base, &pci->dev);

	ret = acp63_init(adata->acp63_base, &pci->dev);

	if (ret)

		goto release_regions;

	val = acp62_readl(adata->acp62_base + ACP_PIN_CONFIG);

	val = acp63_readl(adata->acp63_base + ACP_PIN_CONFIG);

	switch (val) {

	case ACP_CONFIG_0:

	case ACP_CONFIG_1:
@@ -220,7 +220,7 @@ static int snd_acp62_probe(struct pci_dev *pci, 
			adata->res->flags = IORESOURCE_MEM;

			adata->res->start = addr;

			adata->res->end = addr + (ACP6x_REG_END - ACP6x_REG_START);

			adata->acp62_audio_mode = ACP6x_PDM_MODE;

			adata->acp63_audio_mode = ACP6x_PDM_MODE;



			memset(&pdevinfo, 0, sizeof(pdevinfo));

			pdevinfo[0].name = "acp_ps_pdm_dma";
@@ -248,7 +248,7 @@ static int snd_acp62_probe(struct pci_dev *pci, 
					ret = PTR_ERR(adata->pdev[index]);

					goto unregister_devs;

				}

				ret = devm_request_irq(&pci->dev, pci->irq, acp62_irq_handler,

				ret = devm_request_irq(&pci->dev, pci->irq, acp63_irq_handler,

						       irqflags, "ACP_PCI_IRQ", adata);

				if (ret) {

					dev_err(&pci->dev, "ACP PCI IRQ request failed\n");
@@ -267,7 +267,7 @@ static int snd_acp62_probe(struct pci_dev *pci, 
	for (--index; index >= 0; index--)

		platform_device_unregister(adata->pdev[index]);

de_init:

	if (acp62_deinit(adata->acp62_base, &pci->dev))

	if (acp63_deinit(adata->acp63_base, &pci->dev))

		dev_err(&pci->dev, "ACP de-init failed\n");

release_regions:

	pci_release_regions(pci);
@@ -277,46 +277,46 @@ static int snd_acp62_probe(struct pci_dev *pci, 
	return ret;

}



static int __maybe_unused snd_acp62_suspend(struct device *dev)

static int __maybe_unused snd_acp63_suspend(struct device *dev)

{

	struct acp62_dev_data *adata;

	struct acp63_dev_data *adata;

	int ret;



	adata = dev_get_drvdata(dev);

	ret = acp62_deinit(adata->acp62_base, dev);

	ret = acp63_deinit(adata->acp63_base, dev);

	if (ret)

		dev_err(dev, "ACP de-init failed\n");

	return ret;

}



static int __maybe_unused snd_acp62_resume(struct device *dev)

static int __maybe_unused snd_acp63_resume(struct device *dev)

{

	struct acp62_dev_data *adata;

	struct acp63_dev_data *adata;

	int ret;



	adata = dev_get_drvdata(dev);

	ret = acp62_init(adata->acp62_base, dev);

	ret = acp63_init(adata->acp63_base, dev);

	if (ret)

		dev_err(dev, "ACP init failed\n");

	return ret;

}



static const struct dev_pm_ops acp62_pm_ops = {

	SET_RUNTIME_PM_OPS(snd_acp62_suspend, snd_acp62_resume, NULL)

	SET_SYSTEM_SLEEP_PM_OPS(snd_acp62_suspend, snd_acp62_resume)

static const struct dev_pm_ops acp63_pm_ops = {

	SET_RUNTIME_PM_OPS(snd_acp63_suspend, snd_acp63_resume, NULL)

	SET_SYSTEM_SLEEP_PM_OPS(snd_acp63_suspend, snd_acp63_resume)

};



static void snd_acp62_remove(struct pci_dev *pci)

static void snd_acp63_remove(struct pci_dev *pci)

{

	struct acp62_dev_data *adata;

	struct acp63_dev_data *adata;

	int ret, index;



	adata = pci_get_drvdata(pci);

	if (adata->acp62_audio_mode == ACP6x_PDM_MODE) {

	if (adata->acp63_audio_mode == ACP6x_PDM_MODE) {

		for (index = 0; index < ACP6x_DEVS; index++)

			platform_device_unregister(adata->pdev[index]);

	}

	ret = acp62_deinit(adata->acp62_base, &pci->dev);

	ret = acp63_deinit(adata->acp63_base, &pci->dev);

	if (ret)

		dev_err(&pci->dev, "ACP de-init failed\n");

	pm_runtime_forbid(&pci->dev);
@@ -325,25 +325,25 @@ static void snd_acp62_remove(struct pci_dev *pci) 
	pci_disable_device(pci);

}



static const struct pci_device_id snd_acp62_ids[] = {

static const struct pci_device_id snd_acp63_ids[] = {

	{ PCI_DEVICE(PCI_VENDOR_ID_AMD, ACP_DEVICE_ID),

	.class = PCI_CLASS_MULTIMEDIA_OTHER << 8,

	.class_mask = 0xffffff },

	{ 0, },

};

MODULE_DEVICE_TABLE(pci, snd_acp62_ids);

MODULE_DEVICE_TABLE(pci, snd_acp63_ids);



static struct pci_driver ps_acp62_driver  = {

static struct pci_driver ps_acp63_driver  = {

	.name = KBUILD_MODNAME,

	.id_table = snd_acp62_ids,

	.probe = snd_acp62_probe,

	.remove = snd_acp62_remove,

	.id_table = snd_acp63_ids,

	.probe = snd_acp63_probe,

	.remove = snd_acp63_remove,

	.driver = {

		.pm = &acp62_pm_ops,

		.pm = &acp63_pm_ops,

	}

};



module_pci_driver(ps_acp62_driver);

module_pci_driver(ps_acp63_driver);



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

MODULE_AUTHOR("Syed.SabaKareem@amd.com");

sound/soc/amd/ps/ps-mach.c

+15 −15
Original line number Diff line number Diff line
@@ -13,11 +13,11 @@ 
#include <linux/io.h>

#include <linux/dmi.h>



#include "acp62.h"

#include "acp63.h"



#define DRV_NAME "acp_ps_mach"



SND_SOC_DAILINK_DEF(acp62_pdm,

SND_SOC_DAILINK_DEF(acp63_pdm,

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



SND_SOC_DAILINK_DEF(dmic_codec,
@@ -27,31 +27,31 @@ SND_SOC_DAILINK_DEF(dmic_codec, 
SND_SOC_DAILINK_DEF(pdm_platform,

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



static struct snd_soc_dai_link acp62_dai_pdm[] = {

static struct snd_soc_dai_link acp63_dai_pdm[] = {

	{

		.name = "acp62-dmic-capture",

		.name = "acp63-dmic-capture",

		.stream_name = "DMIC capture",

		.capture_only = 1,

		SND_SOC_DAILINK_REG(acp62_pdm, dmic_codec, pdm_platform),

		SND_SOC_DAILINK_REG(acp63_pdm, dmic_codec, pdm_platform),

	},

};



static struct snd_soc_card acp62_card = {

	.name = "acp62",

static struct snd_soc_card acp63_card = {

	.name = "acp63",

	.owner = THIS_MODULE,

	.dai_link = acp62_dai_pdm,

	.dai_link = acp63_dai_pdm,

	.num_links = 1,

};



static int acp62_probe(struct platform_device *pdev)

static int acp63_probe(struct platform_device *pdev)

{

	struct acp62_pdm *machine = NULL;

	struct acp63_pdm *machine = NULL;

	struct snd_soc_card *card;

	int ret;



	platform_set_drvdata(pdev, &acp62_card);

	platform_set_drvdata(pdev, &acp63_card);

	card = platform_get_drvdata(pdev);

	acp62_card.dev = &pdev->dev;

	acp63_card.dev = &pdev->dev;



	snd_soc_card_set_drvdata(card, machine);

	ret = devm_snd_soc_register_card(&pdev->dev, card);
@@ -64,15 +64,15 @@ static int acp62_probe(struct platform_device *pdev) 
	return 0;

}



static struct platform_driver acp62_mach_driver = {

static struct platform_driver acp63_mach_driver = {

	.driver = {

		.name = "acp_ps_mach",

		.pm = &snd_soc_pm_ops,

	},

	.probe = acp62_probe,

	.probe = acp63_probe,

};



module_platform_driver(acp62_mach_driver);

module_platform_driver(acp63_mach_driver);



MODULE_AUTHOR("Syed.SabaKareem@amd.com");

MODULE_LICENSE("GPL v2");