diff mbox series

[v8,04/14] ASoC: Intel: catpt: Define DSP operations

Message ID 20200923122508.3360-5-cezary.rojewski@intel.com (mailing list archive)
State Superseded
Headers show
Series ASoC: Intel: Catpt - Lynx and Wildcat point | expand

Commit Message

Cezary Rojewski Sept. 23, 2020, 12:24 p.m. UTC
Implement dsp lifecycle functions such as core RESET and STALL,
SRAM power control and LP clock selection. This also adds functions for
handling transport over DW DMA controller.

Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
---
 sound/soc/intel/catpt/core.h |  34 ++++
 sound/soc/intel/catpt/dsp.c  | 334 +++++++++++++++++++++++++++++++++++
 2 files changed, 368 insertions(+)

Comments

Andy Shevchenko Sept. 23, 2020, 1:26 p.m. UTC | #1
On Wed, Sep 23, 2020 at 02:24:58PM +0200, Cezary Rojewski wrote:
> Implement dsp lifecycle functions such as core RESET and STALL,
> SRAM power control and LP clock selection. This also adds functions for
> handling transport over DW DMA controller.

FWIW,
Reviewed-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>

> Signed-off-by: Cezary Rojewski <cezary.rojewski@intel.com>
> ---
>  sound/soc/intel/catpt/core.h |  34 ++++
>  sound/soc/intel/catpt/dsp.c  | 334 +++++++++++++++++++++++++++++++++++
>  2 files changed, 368 insertions(+)
> 
> diff --git a/sound/soc/intel/catpt/core.h b/sound/soc/intel/catpt/core.h
> index 3c860c0645dc..9e9b3dceedce 100644
> --- a/sound/soc/intel/catpt/core.h
> +++ b/sound/soc/intel/catpt/core.h
> @@ -99,6 +99,10 @@ struct catpt_dev {
>  	struct resource dram;
>  	struct resource iram;
>  	struct resource *scratch;
> +
> +	struct list_head stream_list;
> +	spinlock_t list_lock;
> +	struct mutex clk_mutex;
>  };
>  
>  int catpt_dmac_probe(struct catpt_dev *cdev);
> @@ -111,6 +115,16 @@ int catpt_dma_memcpy_fromdsp(struct catpt_dev *cdev, struct dma_chan *chan,
>  			     dma_addr_t dst_addr, dma_addr_t src_addr,
>  			     size_t size);
>  
> +void lpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable);
> +void wpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable);
> +int lpt_dsp_power_up(struct catpt_dev *cdev);
> +int lpt_dsp_power_down(struct catpt_dev *cdev);
> +int wpt_dsp_power_up(struct catpt_dev *cdev);
> +int wpt_dsp_power_down(struct catpt_dev *cdev);
> +int catpt_dsp_stall(struct catpt_dev *cdev, bool stall);
> +void catpt_dsp_update_srampge(struct catpt_dev *cdev, struct resource *sram,
> +			      unsigned long mask);
> +int catpt_dsp_update_lpclock(struct catpt_dev *cdev);
>  irqreturn_t catpt_dsp_irq_handler(int irq, void *dev_id);
>  irqreturn_t catpt_dsp_irq_thread(int irq, void *dev_id);
>  
> @@ -129,4 +143,24 @@ int catpt_dsp_send_msg(struct catpt_dev *cdev, struct catpt_ipc_msg request,
>  
>  int catpt_coredump(struct catpt_dev *cdev);
>  
> +#include <sound/memalloc.h>
> +#include <uapi/sound/asound.h>
> +
> +struct snd_pcm_substream;
> +struct catpt_stream_template;
> +
> +struct catpt_stream_runtime {
> +	struct snd_pcm_substream *substream;
> +
> +	struct catpt_stream_template *template;
> +	struct catpt_stream_info info;
> +	struct resource *persistent;
> +	struct snd_dma_buffer pgtbl;
> +
> +	bool allocated;
> +	bool prepared;
> +
> +	struct list_head node;
> +};
> +
>  #endif
> diff --git a/sound/soc/intel/catpt/dsp.c b/sound/soc/intel/catpt/dsp.c
> index 9d988b05c8cf..2a52d1bf4e00 100644
> --- a/sound/soc/intel/catpt/dsp.c
> +++ b/sound/soc/intel/catpt/dsp.c
> @@ -8,7 +8,10 @@
>  #include <linux/devcoredump.h>
>  #include <linux/dma-mapping.h>
>  #include <linux/firmware.h>
> +#include <linux/pci.h>
> +#include <linux/pxa2xx_ssp.h>
>  #include "core.h"
> +#include "messages.h"
>  #include "registers.h"
>  
>  static bool catpt_dma_filter(struct dma_chan *chan, void *param)
> @@ -138,6 +141,337 @@ void catpt_dmac_remove(struct catpt_dev *cdev)
>  	dw_dma_remove(cdev->dmac);
>  }
>  
> +static void catpt_dsp_set_srampge(struct catpt_dev *cdev, struct resource *sram,
> +				  unsigned long mask, unsigned long new)
> +{
> +	unsigned long old;
> +	u32 off = sram->start;
> +	u32 b = __ffs(mask);
> +
> +	old = catpt_readl_pci(cdev, VDRTCTL0) & mask;
> +	dev_dbg(cdev->dev, "SRAMPGE [0x%08lx] 0x%08lx -> 0x%08lx",
> +		mask, old, new);
> +
> +	if (old == new)
> +		return;
> +
> +	catpt_updatel_pci(cdev, VDRTCTL0, mask, new);
> +	/* wait for SRAM power gating to propagate */
> +	udelay(60);
> +
> +	/*
> +	 * Dummy read as the very first access after block enable
> +	 * to prevent byte loss in future operations.
> +	 */
> +	for_each_clear_bit_from(b, &new, fls_long(mask)) {
> +		u8 buf[4];
> +
> +		/* newly enabled: new bit=0 while old bit=1 */
> +		if (test_bit(b, &old)) {
> +			dev_dbg(cdev->dev, "sanitize block %ld: off 0x%08x\n",
> +				b - __ffs(mask), off);
> +			memcpy_fromio(buf, cdev->lpe_ba + off, sizeof(buf));
> +		}
> +		off += CATPT_MEMBLOCK_SIZE;
> +	}
> +}
> +
> +void catpt_dsp_update_srampge(struct catpt_dev *cdev, struct resource *sram,
> +			      unsigned long mask)
> +{
> +	struct resource *res;
> +	unsigned long new = 0;
> +
> +	/* flag all busy blocks */
> +	for (res = sram->child; res; res = res->sibling) {
> +		u32 h, l;
> +
> +		h = (res->end - sram->start) / CATPT_MEMBLOCK_SIZE;
> +		l = (res->start - sram->start) / CATPT_MEMBLOCK_SIZE;
> +		new |= GENMASK(h, l);
> +	}
> +
> +	/* offset value given mask's start and invert it as ON=b0 */
> +	new = ~(new << __ffs(mask)) & mask;
> +
> +	/* disable core clock gating */
> +	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE, 0);
> +
> +	catpt_dsp_set_srampge(cdev, sram, mask, new);
> +
> +	/* enable core clock gating */
> +	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE,
> +			  CATPT_VDRTCTL2_DCLCGE);
> +}
> +
> +int catpt_dsp_stall(struct catpt_dev *cdev, bool stall)
> +{
> +	u32 reg, val;
> +
> +	val = stall ? CATPT_CS_STALL : 0;
> +	catpt_updatel_shim(cdev, CS1, CATPT_CS_STALL, val);
> +
> +	return catpt_readl_poll_shim(cdev, CS1,
> +				     reg, (reg & CATPT_CS_STALL) == val,
> +				     500, 10000);
> +}
> +
> +static int catpt_dsp_reset(struct catpt_dev *cdev, bool reset)
> +{
> +	u32 reg, val;
> +
> +	val = reset ? CATPT_CS_RST : 0;
> +	catpt_updatel_shim(cdev, CS1, CATPT_CS_RST, val);
> +
> +	return catpt_readl_poll_shim(cdev, CS1,
> +				     reg, (reg & CATPT_CS_RST) == val,
> +				     500, 10000);
> +}
> +
> +void lpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable)
> +{
> +	u32 val;
> +
> +	val = enable ? LPT_VDRTCTL0_APLLSE : 0;
> +	catpt_updatel_pci(cdev, VDRTCTL0, LPT_VDRTCTL0_APLLSE, val);
> +}
> +
> +void wpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable)
> +{
> +	u32 val;
> +
> +	val = enable ? WPT_VDRTCTL2_APLLSE : 0;
> +	catpt_updatel_pci(cdev, VDRTCTL2, WPT_VDRTCTL2_APLLSE, val);
> +}
> +
> +static int catpt_dsp_select_lpclock(struct catpt_dev *cdev, bool lp, bool waiti)
> +{
> +	u32 mask, reg, val;
> +	int ret;
> +
> +	mutex_lock(&cdev->clk_mutex);
> +
> +	val = lp ? CATPT_CS_LPCS : 0;
> +	reg = catpt_readl_shim(cdev, CS1) & CATPT_CS_LPCS;
> +	dev_dbg(cdev->dev, "LPCS [0x%08lx] 0x%08x -> 0x%08x",
> +		CATPT_CS_LPCS, reg, val);
> +
> +	if (reg == val) {
> +		mutex_unlock(&cdev->clk_mutex);
> +		return 0;
> +	}
> +
> +	if (waiti) {
> +		/* wait for DSP to signal WAIT state */
> +		ret = catpt_readl_poll_shim(cdev, ISD,
> +					    reg, (reg & CATPT_ISD_DCPWM),
> +					    500, 10000);
> +		if (ret) {
> +			dev_err(cdev->dev, "await WAITI timeout\n");
> +			mutex_unlock(&cdev->clk_mutex);
> +			return ret;
> +		}
> +	}
> +
> +	ret = catpt_readl_poll_shim(cdev, CLKCTL,
> +				    reg, !(reg & CATPT_CLKCTL_CFCIP),
> +				    500, 10000);
> +	if (ret)
> +		dev_warn(cdev->dev, "clock change still in progress\n");
> +
> +	/* default to DSP core & audio fabric high clock */
> +	val |= CATPT_CS_DCS_HIGH;
> +	mask = CATPT_CS_LPCS | CATPT_CS_DCS;
> +	catpt_updatel_shim(cdev, CS1, mask, val);
> +
> +	ret = catpt_readl_poll_shim(cdev, CLKCTL,
> +				    reg, !(reg & CATPT_CLKCTL_CFCIP),
> +				    500, 10000);
> +	if (ret)
> +		dev_warn(cdev->dev, "clock change still in progress\n");
> +
> +	/* update PLL accordingly */
> +	cdev->spec->pll_shutdown(cdev, lp);
> +
> +	mutex_unlock(&cdev->clk_mutex);
> +	return 0;
> +}
> +
> +int catpt_dsp_update_lpclock(struct catpt_dev *cdev)
> +{
> +	struct catpt_stream_runtime *stream;
> +
> +	list_for_each_entry(stream, &cdev->stream_list, node)
> +		if (stream->prepared)
> +			return catpt_dsp_select_lpclock(cdev, false, true);
> +
> +	return catpt_dsp_select_lpclock(cdev, true, true);
> +}
> +
> +/* bring registers to their defaults as HW won't reset itself */
> +static void catpt_dsp_set_regs_defaults(struct catpt_dev *cdev)
> +{
> +	int i;
> +
> +	catpt_writel_shim(cdev, CS1, CATPT_CS_DEFAULT);
> +	catpt_writel_shim(cdev, ISC, CATPT_ISC_DEFAULT);
> +	catpt_writel_shim(cdev, ISD, CATPT_ISD_DEFAULT);
> +	catpt_writel_shim(cdev, IMC, CATPT_IMC_DEFAULT);
> +	catpt_writel_shim(cdev, IMD, CATPT_IMD_DEFAULT);
> +	catpt_writel_shim(cdev, IPCC, CATPT_IPCC_DEFAULT);
> +	catpt_writel_shim(cdev, IPCD, CATPT_IPCD_DEFAULT);
> +	catpt_writel_shim(cdev, CLKCTL, CATPT_CLKCTL_DEFAULT);
> +	catpt_writel_shim(cdev, CS2, CATPT_CS2_DEFAULT);
> +	catpt_writel_shim(cdev, LTRC, CATPT_LTRC_DEFAULT);
> +	catpt_writel_shim(cdev, HMDC, CATPT_HMDC_DEFAULT);
> +
> +	for (i = 0; i < CATPT_SSP_COUNT; i++) {
> +		catpt_writel_ssp(cdev, i, SSCR0, CATPT_SSC0_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSCR1, CATPT_SSC1_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSSR, CATPT_SSS_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSITR, CATPT_SSIT_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSDR, CATPT_SSD_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSTO, CATPT_SSTO_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSPSP, CATPT_SSPSP_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSTSA, CATPT_SSTSA_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSRSA, CATPT_SSRSA_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSTSS, CATPT_SSTSS_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSCR2, CATPT_SSCR2_DEFAULT);
> +		catpt_writel_ssp(cdev, i, SSPSP2, CATPT_SSPSP2_DEFAULT);
> +	}
> +}
> +
> +int lpt_dsp_power_down(struct catpt_dev *cdev)
> +{
> +	catpt_dsp_reset(cdev, true);
> +
> +	/* set 24Mhz clock for both SSPs */
> +	catpt_updatel_shim(cdev, CS1, CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
> +			   CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
> +	catpt_dsp_select_lpclock(cdev, true, false);
> +
> +	/* DRAM power gating all */
> +	catpt_dsp_set_srampge(cdev, &cdev->dram, cdev->spec->dram_mask,
> +			      cdev->spec->dram_mask);
> +	catpt_dsp_set_srampge(cdev, &cdev->iram, cdev->spec->iram_mask,
> +			      cdev->spec->iram_mask);
> +
> +	catpt_updatel_pci(cdev, PMCS, PCI_PM_CTRL_STATE_MASK, PCI_D3hot);
> +	/* give hw time to drop off */
> +	udelay(50);
> +
> +	return 0;
> +}
> +
> +int lpt_dsp_power_up(struct catpt_dev *cdev)
> +{
> +	/* SRAM power gating none */
> +	catpt_dsp_set_srampge(cdev, &cdev->dram, cdev->spec->dram_mask, 0);
> +	catpt_dsp_set_srampge(cdev, &cdev->iram, cdev->spec->iram_mask, 0);
> +
> +	catpt_updatel_pci(cdev, PMCS, PCI_PM_CTRL_STATE_MASK, PCI_D0);
> +	/* give hw time to wake up */
> +	udelay(100);
> +
> +	catpt_dsp_select_lpclock(cdev, false, false);
> +	catpt_updatel_shim(cdev, CS1,
> +			   CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
> +			   CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
> +	/* stagger DSP reset after clock selection */
> +	udelay(50);
> +
> +	catpt_dsp_reset(cdev, false);
> +	/* generate int deassert msg to fix inversed int logic */
> +	catpt_updatel_shim(cdev, IMC, CATPT_IMC_IPCDB | CATPT_IMC_IPCCD, 0);
> +
> +	return 0;
> +}
> +
> +int wpt_dsp_power_down(struct catpt_dev *cdev)
> +{
> +	u32 mask, val;
> +
> +	/* disable core clock gating */
> +	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE, 0);
> +
> +	catpt_dsp_reset(cdev, true);
> +	/* set 24Mhz clock for both SSPs */
> +	catpt_updatel_shim(cdev, CS1, CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
> +			   CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
> +	catpt_dsp_select_lpclock(cdev, true, false);
> +	/* disable MCLK */
> +	catpt_updatel_shim(cdev, CLKCTL, CATPT_CLKCTL_SMOS, 0);
> +
> +	catpt_dsp_set_regs_defaults(cdev);
> +
> +	/* switch clock gating */
> +	mask = CATPT_VDRTCTL2_CGEALL & (~CATPT_VDRTCTL2_DCLCGE);
> +	val = mask & (~CATPT_VDRTCTL2_DTCGE);
> +	catpt_updatel_pci(cdev, VDRTCTL2, mask, val);
> +	/* enable DTCGE separatelly */
> +	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DTCGE,
> +			  CATPT_VDRTCTL2_DTCGE);
> +
> +	/* SRAM power gating all */
> +	catpt_dsp_set_srampge(cdev, &cdev->dram, cdev->spec->dram_mask,
> +			      cdev->spec->dram_mask);
> +	catpt_dsp_set_srampge(cdev, &cdev->iram, cdev->spec->iram_mask,
> +			      cdev->spec->iram_mask);
> +	mask = WPT_VDRTCTL0_D3SRAMPGD | WPT_VDRTCTL0_D3PGD;
> +	catpt_updatel_pci(cdev, VDRTCTL0, mask, WPT_VDRTCTL0_D3PGD);
> +
> +	catpt_updatel_pci(cdev, PMCS, PCI_PM_CTRL_STATE_MASK, PCI_D3hot);
> +	/* give hw time to drop off */
> +	udelay(50);
> +
> +	/* enable core clock gating */
> +	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE,
> +			  CATPT_VDRTCTL2_DCLCGE);
> +	udelay(50);
> +
> +	return 0;
> +}
> +
> +int wpt_dsp_power_up(struct catpt_dev *cdev)
> +{
> +	u32 mask, val;
> +
> +	/* disable core clock gating */
> +	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE, 0);
> +
> +	/* switch clock gating */
> +	mask = CATPT_VDRTCTL2_CGEALL & (~CATPT_VDRTCTL2_DCLCGE);
> +	val = mask & (~CATPT_VDRTCTL2_DTCGE);
> +	catpt_updatel_pci(cdev, VDRTCTL2, mask, val);
> +
> +	catpt_updatel_pci(cdev, PMCS, PCI_PM_CTRL_STATE_MASK, PCI_D0);
> +
> +	/* SRAM power gating none */
> +	mask = WPT_VDRTCTL0_D3SRAMPGD | WPT_VDRTCTL0_D3PGD;
> +	catpt_updatel_pci(cdev, VDRTCTL0, mask, mask);
> +	catpt_dsp_set_srampge(cdev, &cdev->dram, cdev->spec->dram_mask, 0);
> +	catpt_dsp_set_srampge(cdev, &cdev->iram, cdev->spec->iram_mask, 0);
> +
> +	catpt_dsp_set_regs_defaults(cdev);
> +
> +	/* restore MCLK */
> +	catpt_updatel_shim(cdev, CLKCTL, CATPT_CLKCTL_SMOS, CATPT_CLKCTL_SMOS);
> +	catpt_dsp_select_lpclock(cdev, false, false);
> +	/* set 24Mhz clock for both SSPs */
> +	catpt_updatel_shim(cdev, CS1, CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
> +			   CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
> +	catpt_dsp_reset(cdev, false);
> +
> +	/* enable core clock gating */
> +	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE,
> +			  CATPT_VDRTCTL2_DCLCGE);
> +
> +	/* generate int deassert msg to fix inversed int logic */
> +	catpt_updatel_shim(cdev, IMC, CATPT_IMC_IPCDB | CATPT_IMC_IPCCD, 0);
> +
> +	return 0;
> +}
> +
>  #define CATPT_DUMP_MAGIC		0xcd42
>  #define CATPT_DUMP_SECTION_ID_FILE	0x00
>  #define CATPT_DUMP_SECTION_ID_IRAM	0x01
> -- 
> 2.17.1
>
diff mbox series

Patch

diff --git a/sound/soc/intel/catpt/core.h b/sound/soc/intel/catpt/core.h
index 3c860c0645dc..9e9b3dceedce 100644
--- a/sound/soc/intel/catpt/core.h
+++ b/sound/soc/intel/catpt/core.h
@@ -99,6 +99,10 @@  struct catpt_dev {
 	struct resource dram;
 	struct resource iram;
 	struct resource *scratch;
+
+	struct list_head stream_list;
+	spinlock_t list_lock;
+	struct mutex clk_mutex;
 };
 
 int catpt_dmac_probe(struct catpt_dev *cdev);
@@ -111,6 +115,16 @@  int catpt_dma_memcpy_fromdsp(struct catpt_dev *cdev, struct dma_chan *chan,
 			     dma_addr_t dst_addr, dma_addr_t src_addr,
 			     size_t size);
 
+void lpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable);
+void wpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable);
+int lpt_dsp_power_up(struct catpt_dev *cdev);
+int lpt_dsp_power_down(struct catpt_dev *cdev);
+int wpt_dsp_power_up(struct catpt_dev *cdev);
+int wpt_dsp_power_down(struct catpt_dev *cdev);
+int catpt_dsp_stall(struct catpt_dev *cdev, bool stall);
+void catpt_dsp_update_srampge(struct catpt_dev *cdev, struct resource *sram,
+			      unsigned long mask);
+int catpt_dsp_update_lpclock(struct catpt_dev *cdev);
 irqreturn_t catpt_dsp_irq_handler(int irq, void *dev_id);
 irqreturn_t catpt_dsp_irq_thread(int irq, void *dev_id);
 
@@ -129,4 +143,24 @@  int catpt_dsp_send_msg(struct catpt_dev *cdev, struct catpt_ipc_msg request,
 
 int catpt_coredump(struct catpt_dev *cdev);
 
+#include <sound/memalloc.h>
+#include <uapi/sound/asound.h>
+
+struct snd_pcm_substream;
+struct catpt_stream_template;
+
+struct catpt_stream_runtime {
+	struct snd_pcm_substream *substream;
+
+	struct catpt_stream_template *template;
+	struct catpt_stream_info info;
+	struct resource *persistent;
+	struct snd_dma_buffer pgtbl;
+
+	bool allocated;
+	bool prepared;
+
+	struct list_head node;
+};
+
 #endif
diff --git a/sound/soc/intel/catpt/dsp.c b/sound/soc/intel/catpt/dsp.c
index 9d988b05c8cf..2a52d1bf4e00 100644
--- a/sound/soc/intel/catpt/dsp.c
+++ b/sound/soc/intel/catpt/dsp.c
@@ -8,7 +8,10 @@ 
 #include <linux/devcoredump.h>
 #include <linux/dma-mapping.h>
 #include <linux/firmware.h>
+#include <linux/pci.h>
+#include <linux/pxa2xx_ssp.h>
 #include "core.h"
+#include "messages.h"
 #include "registers.h"
 
 static bool catpt_dma_filter(struct dma_chan *chan, void *param)
@@ -138,6 +141,337 @@  void catpt_dmac_remove(struct catpt_dev *cdev)
 	dw_dma_remove(cdev->dmac);
 }
 
+static void catpt_dsp_set_srampge(struct catpt_dev *cdev, struct resource *sram,
+				  unsigned long mask, unsigned long new)
+{
+	unsigned long old;
+	u32 off = sram->start;
+	u32 b = __ffs(mask);
+
+	old = catpt_readl_pci(cdev, VDRTCTL0) & mask;
+	dev_dbg(cdev->dev, "SRAMPGE [0x%08lx] 0x%08lx -> 0x%08lx",
+		mask, old, new);
+
+	if (old == new)
+		return;
+
+	catpt_updatel_pci(cdev, VDRTCTL0, mask, new);
+	/* wait for SRAM power gating to propagate */
+	udelay(60);
+
+	/*
+	 * Dummy read as the very first access after block enable
+	 * to prevent byte loss in future operations.
+	 */
+	for_each_clear_bit_from(b, &new, fls_long(mask)) {
+		u8 buf[4];
+
+		/* newly enabled: new bit=0 while old bit=1 */
+		if (test_bit(b, &old)) {
+			dev_dbg(cdev->dev, "sanitize block %ld: off 0x%08x\n",
+				b - __ffs(mask), off);
+			memcpy_fromio(buf, cdev->lpe_ba + off, sizeof(buf));
+		}
+		off += CATPT_MEMBLOCK_SIZE;
+	}
+}
+
+void catpt_dsp_update_srampge(struct catpt_dev *cdev, struct resource *sram,
+			      unsigned long mask)
+{
+	struct resource *res;
+	unsigned long new = 0;
+
+	/* flag all busy blocks */
+	for (res = sram->child; res; res = res->sibling) {
+		u32 h, l;
+
+		h = (res->end - sram->start) / CATPT_MEMBLOCK_SIZE;
+		l = (res->start - sram->start) / CATPT_MEMBLOCK_SIZE;
+		new |= GENMASK(h, l);
+	}
+
+	/* offset value given mask's start and invert it as ON=b0 */
+	new = ~(new << __ffs(mask)) & mask;
+
+	/* disable core clock gating */
+	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE, 0);
+
+	catpt_dsp_set_srampge(cdev, sram, mask, new);
+
+	/* enable core clock gating */
+	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE,
+			  CATPT_VDRTCTL2_DCLCGE);
+}
+
+int catpt_dsp_stall(struct catpt_dev *cdev, bool stall)
+{
+	u32 reg, val;
+
+	val = stall ? CATPT_CS_STALL : 0;
+	catpt_updatel_shim(cdev, CS1, CATPT_CS_STALL, val);
+
+	return catpt_readl_poll_shim(cdev, CS1,
+				     reg, (reg & CATPT_CS_STALL) == val,
+				     500, 10000);
+}
+
+static int catpt_dsp_reset(struct catpt_dev *cdev, bool reset)
+{
+	u32 reg, val;
+
+	val = reset ? CATPT_CS_RST : 0;
+	catpt_updatel_shim(cdev, CS1, CATPT_CS_RST, val);
+
+	return catpt_readl_poll_shim(cdev, CS1,
+				     reg, (reg & CATPT_CS_RST) == val,
+				     500, 10000);
+}
+
+void lpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable)
+{
+	u32 val;
+
+	val = enable ? LPT_VDRTCTL0_APLLSE : 0;
+	catpt_updatel_pci(cdev, VDRTCTL0, LPT_VDRTCTL0_APLLSE, val);
+}
+
+void wpt_dsp_pll_shutdown(struct catpt_dev *cdev, bool enable)
+{
+	u32 val;
+
+	val = enable ? WPT_VDRTCTL2_APLLSE : 0;
+	catpt_updatel_pci(cdev, VDRTCTL2, WPT_VDRTCTL2_APLLSE, val);
+}
+
+static int catpt_dsp_select_lpclock(struct catpt_dev *cdev, bool lp, bool waiti)
+{
+	u32 mask, reg, val;
+	int ret;
+
+	mutex_lock(&cdev->clk_mutex);
+
+	val = lp ? CATPT_CS_LPCS : 0;
+	reg = catpt_readl_shim(cdev, CS1) & CATPT_CS_LPCS;
+	dev_dbg(cdev->dev, "LPCS [0x%08lx] 0x%08x -> 0x%08x",
+		CATPT_CS_LPCS, reg, val);
+
+	if (reg == val) {
+		mutex_unlock(&cdev->clk_mutex);
+		return 0;
+	}
+
+	if (waiti) {
+		/* wait for DSP to signal WAIT state */
+		ret = catpt_readl_poll_shim(cdev, ISD,
+					    reg, (reg & CATPT_ISD_DCPWM),
+					    500, 10000);
+		if (ret) {
+			dev_err(cdev->dev, "await WAITI timeout\n");
+			mutex_unlock(&cdev->clk_mutex);
+			return ret;
+		}
+	}
+
+	ret = catpt_readl_poll_shim(cdev, CLKCTL,
+				    reg, !(reg & CATPT_CLKCTL_CFCIP),
+				    500, 10000);
+	if (ret)
+		dev_warn(cdev->dev, "clock change still in progress\n");
+
+	/* default to DSP core & audio fabric high clock */
+	val |= CATPT_CS_DCS_HIGH;
+	mask = CATPT_CS_LPCS | CATPT_CS_DCS;
+	catpt_updatel_shim(cdev, CS1, mask, val);
+
+	ret = catpt_readl_poll_shim(cdev, CLKCTL,
+				    reg, !(reg & CATPT_CLKCTL_CFCIP),
+				    500, 10000);
+	if (ret)
+		dev_warn(cdev->dev, "clock change still in progress\n");
+
+	/* update PLL accordingly */
+	cdev->spec->pll_shutdown(cdev, lp);
+
+	mutex_unlock(&cdev->clk_mutex);
+	return 0;
+}
+
+int catpt_dsp_update_lpclock(struct catpt_dev *cdev)
+{
+	struct catpt_stream_runtime *stream;
+
+	list_for_each_entry(stream, &cdev->stream_list, node)
+		if (stream->prepared)
+			return catpt_dsp_select_lpclock(cdev, false, true);
+
+	return catpt_dsp_select_lpclock(cdev, true, true);
+}
+
+/* bring registers to their defaults as HW won't reset itself */
+static void catpt_dsp_set_regs_defaults(struct catpt_dev *cdev)
+{
+	int i;
+
+	catpt_writel_shim(cdev, CS1, CATPT_CS_DEFAULT);
+	catpt_writel_shim(cdev, ISC, CATPT_ISC_DEFAULT);
+	catpt_writel_shim(cdev, ISD, CATPT_ISD_DEFAULT);
+	catpt_writel_shim(cdev, IMC, CATPT_IMC_DEFAULT);
+	catpt_writel_shim(cdev, IMD, CATPT_IMD_DEFAULT);
+	catpt_writel_shim(cdev, IPCC, CATPT_IPCC_DEFAULT);
+	catpt_writel_shim(cdev, IPCD, CATPT_IPCD_DEFAULT);
+	catpt_writel_shim(cdev, CLKCTL, CATPT_CLKCTL_DEFAULT);
+	catpt_writel_shim(cdev, CS2, CATPT_CS2_DEFAULT);
+	catpt_writel_shim(cdev, LTRC, CATPT_LTRC_DEFAULT);
+	catpt_writel_shim(cdev, HMDC, CATPT_HMDC_DEFAULT);
+
+	for (i = 0; i < CATPT_SSP_COUNT; i++) {
+		catpt_writel_ssp(cdev, i, SSCR0, CATPT_SSC0_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSCR1, CATPT_SSC1_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSSR, CATPT_SSS_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSITR, CATPT_SSIT_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSDR, CATPT_SSD_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSTO, CATPT_SSTO_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSPSP, CATPT_SSPSP_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSTSA, CATPT_SSTSA_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSRSA, CATPT_SSRSA_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSTSS, CATPT_SSTSS_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSCR2, CATPT_SSCR2_DEFAULT);
+		catpt_writel_ssp(cdev, i, SSPSP2, CATPT_SSPSP2_DEFAULT);
+	}
+}
+
+int lpt_dsp_power_down(struct catpt_dev *cdev)
+{
+	catpt_dsp_reset(cdev, true);
+
+	/* set 24Mhz clock for both SSPs */
+	catpt_updatel_shim(cdev, CS1, CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
+			   CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
+	catpt_dsp_select_lpclock(cdev, true, false);
+
+	/* DRAM power gating all */
+	catpt_dsp_set_srampge(cdev, &cdev->dram, cdev->spec->dram_mask,
+			      cdev->spec->dram_mask);
+	catpt_dsp_set_srampge(cdev, &cdev->iram, cdev->spec->iram_mask,
+			      cdev->spec->iram_mask);
+
+	catpt_updatel_pci(cdev, PMCS, PCI_PM_CTRL_STATE_MASK, PCI_D3hot);
+	/* give hw time to drop off */
+	udelay(50);
+
+	return 0;
+}
+
+int lpt_dsp_power_up(struct catpt_dev *cdev)
+{
+	/* SRAM power gating none */
+	catpt_dsp_set_srampge(cdev, &cdev->dram, cdev->spec->dram_mask, 0);
+	catpt_dsp_set_srampge(cdev, &cdev->iram, cdev->spec->iram_mask, 0);
+
+	catpt_updatel_pci(cdev, PMCS, PCI_PM_CTRL_STATE_MASK, PCI_D0);
+	/* give hw time to wake up */
+	udelay(100);
+
+	catpt_dsp_select_lpclock(cdev, false, false);
+	catpt_updatel_shim(cdev, CS1,
+			   CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
+			   CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
+	/* stagger DSP reset after clock selection */
+	udelay(50);
+
+	catpt_dsp_reset(cdev, false);
+	/* generate int deassert msg to fix inversed int logic */
+	catpt_updatel_shim(cdev, IMC, CATPT_IMC_IPCDB | CATPT_IMC_IPCCD, 0);
+
+	return 0;
+}
+
+int wpt_dsp_power_down(struct catpt_dev *cdev)
+{
+	u32 mask, val;
+
+	/* disable core clock gating */
+	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE, 0);
+
+	catpt_dsp_reset(cdev, true);
+	/* set 24Mhz clock for both SSPs */
+	catpt_updatel_shim(cdev, CS1, CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
+			   CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
+	catpt_dsp_select_lpclock(cdev, true, false);
+	/* disable MCLK */
+	catpt_updatel_shim(cdev, CLKCTL, CATPT_CLKCTL_SMOS, 0);
+
+	catpt_dsp_set_regs_defaults(cdev);
+
+	/* switch clock gating */
+	mask = CATPT_VDRTCTL2_CGEALL & (~CATPT_VDRTCTL2_DCLCGE);
+	val = mask & (~CATPT_VDRTCTL2_DTCGE);
+	catpt_updatel_pci(cdev, VDRTCTL2, mask, val);
+	/* enable DTCGE separatelly */
+	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DTCGE,
+			  CATPT_VDRTCTL2_DTCGE);
+
+	/* SRAM power gating all */
+	catpt_dsp_set_srampge(cdev, &cdev->dram, cdev->spec->dram_mask,
+			      cdev->spec->dram_mask);
+	catpt_dsp_set_srampge(cdev, &cdev->iram, cdev->spec->iram_mask,
+			      cdev->spec->iram_mask);
+	mask = WPT_VDRTCTL0_D3SRAMPGD | WPT_VDRTCTL0_D3PGD;
+	catpt_updatel_pci(cdev, VDRTCTL0, mask, WPT_VDRTCTL0_D3PGD);
+
+	catpt_updatel_pci(cdev, PMCS, PCI_PM_CTRL_STATE_MASK, PCI_D3hot);
+	/* give hw time to drop off */
+	udelay(50);
+
+	/* enable core clock gating */
+	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE,
+			  CATPT_VDRTCTL2_DCLCGE);
+	udelay(50);
+
+	return 0;
+}
+
+int wpt_dsp_power_up(struct catpt_dev *cdev)
+{
+	u32 mask, val;
+
+	/* disable core clock gating */
+	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE, 0);
+
+	/* switch clock gating */
+	mask = CATPT_VDRTCTL2_CGEALL & (~CATPT_VDRTCTL2_DCLCGE);
+	val = mask & (~CATPT_VDRTCTL2_DTCGE);
+	catpt_updatel_pci(cdev, VDRTCTL2, mask, val);
+
+	catpt_updatel_pci(cdev, PMCS, PCI_PM_CTRL_STATE_MASK, PCI_D0);
+
+	/* SRAM power gating none */
+	mask = WPT_VDRTCTL0_D3SRAMPGD | WPT_VDRTCTL0_D3PGD;
+	catpt_updatel_pci(cdev, VDRTCTL0, mask, mask);
+	catpt_dsp_set_srampge(cdev, &cdev->dram, cdev->spec->dram_mask, 0);
+	catpt_dsp_set_srampge(cdev, &cdev->iram, cdev->spec->iram_mask, 0);
+
+	catpt_dsp_set_regs_defaults(cdev);
+
+	/* restore MCLK */
+	catpt_updatel_shim(cdev, CLKCTL, CATPT_CLKCTL_SMOS, CATPT_CLKCTL_SMOS);
+	catpt_dsp_select_lpclock(cdev, false, false);
+	/* set 24Mhz clock for both SSPs */
+	catpt_updatel_shim(cdev, CS1, CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1),
+			   CATPT_CS_SBCS(0) | CATPT_CS_SBCS(1));
+	catpt_dsp_reset(cdev, false);
+
+	/* enable core clock gating */
+	catpt_updatel_pci(cdev, VDRTCTL2, CATPT_VDRTCTL2_DCLCGE,
+			  CATPT_VDRTCTL2_DCLCGE);
+
+	/* generate int deassert msg to fix inversed int logic */
+	catpt_updatel_shim(cdev, IMC, CATPT_IMC_IPCDB | CATPT_IMC_IPCCD, 0);
+
+	return 0;
+}
+
 #define CATPT_DUMP_MAGIC		0xcd42
 #define CATPT_DUMP_SECTION_ID_FILE	0x00
 #define CATPT_DUMP_SECTION_ID_IRAM	0x01