Merge tag 'sound-5.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound

Pull sound updates from Takashi Iwai:
 "As shown in diffstat and logs, it was again a busy development cycle
  at this time, too. The most significant changes are still on-going
  refactoring / modernization works for ASoC core and drivers, but there
  are lots of other changes as well. Here we go, some highlights below:

  ASoC:

   - Quite a lot of cleanup / refactoring of ASoC core and APIs; most of
     them are systematic, but also including cleanups and modernization

   - A bulk of updates for some ASoC platforms, Freescale, sunxi and
     Intel SST/SOF

   - Initial support for Sound Open Firmware on i.MX8

   - Removal of deprecated w90x900 and nuc900 drivers

   - New support for Cirrus Logic CS47L15 and CS47L92, Freescale i.MX
     7ULP and 8MQ, Meson G12A and NXP UDA1334

  USB-audio:

   - More validations of descriptor units for hardening against bugs
     reported by fuzzers

   - PCM device assignment workaround for a past call-order change

   - Scarlett Gen2 mixer interface, a few more more quirks

  HD-audio:

   - Support for audio component with AMD/ATI and Nvidia HDMI codecs

   - Clean up HD-audio core and remove indirect access ops for Intel SOF

   - DMIC detection at probe; it would make systems automatically
     falling back to SST/SOF driver on devices that need DMIC handling.
     Needs a new Kconfig to set, and beware that it's still new and a
     bit experimental

  FireWire:

   - Lots of code refactoring and cleanups"

* tag 'sound-5.4-rc1' of git://git.kernel.org/pub/scm/linux/kernel/git/tiwai/sound: (521 commits)
  ASoC: sdm845: remove unneeded semicolon
  ASoC: fsl_sai: Implement set_bclk_ratio
  ASoC: dmaengine: Replace strncpy() with strscpy_pad() for pcm->name
  ASoC: wcd9335: remove redundant use of ret variable
  ALSA: firewire-tascam: check intermediate state of clock status and retry
  ALSA: firewire-tascam: handle error code when getting current source of clock
  ASoC: hdmi-codec: Add an op to set callback function for plug event
  ASoC: rt5677: keep analog power register at SND_SOC_BIAS_OFF
  ASoC: rt5677: Remove magic number register writes
  ASoC: soc-core: self contained soc_unbind_aux_dev()
  ASoC: soc-core: add soc_unbind_aux_dev()
  ASoC: soc-core: self contained soc_bind_aux_dev()
  ASoC: soc-core: move soc_probe_link_dais() next to soc_remove_link_dais()
  ASoC: soc-core: self contained soc_probe_link_dais()
  ASoC: soc-core: add new soc_link_init()
  ASoC: soc-core: move soc_probe_dai() next to soc_remove_dai()
  ASoC: soc-core: self contained soc_remove_link_dais()
  ASoC: soc-core: self contained soc_remove_link_components()
  ASoC: soc-core: self contained soc_probe_link_components()
  ASoC: rt1308: make array pd static const, makes object smaller
  ...

41 files changed, 1082 insertions, 1292 deletions

diff --git a/sound/soc/intel/Kconfig b/sound/soc/intel/Kconfig
index 96a00a9d4cf8..01c99750212a 100644
--- a/sound/soc/intel/Kconfig
+++ b/sound/soc/intel/Kconfig
@@ -215,6 +215,7 @@ config SND_SOC_INTEL_SKYLAKE_COMMON
         select SND_SOC_INTEL_SST
         select SND_SOC_HDAC_HDA if SND_SOC_INTEL_SKYLAKE_HDAUDIO_CODEC
         select SND_SOC_ACPI_INTEL_MATCH
+        select SND_INTEL_NHLT if ACPI
         help
           If you have a Intel Skylake/Broxton/ApolloLake/KabyLake/
           GeminiLake or CannonLake platform with the DSP enabled in the BIOS
diff --git a/sound/soc/intel/baytrail/sst-baytrail-ipc.c b/sound/soc/intel/baytrail/sst-baytrail-ipc.c
index 8bd1eddcc091..74274bd38f7a 100644
--- a/sound/soc/intel/baytrail/sst-baytrail-ipc.c
+++ b/sound/soc/intel/baytrail/sst-baytrail-ipc.c
@@ -211,7 +211,7 @@ static struct sst_byt_stream *sst_byt_get_stream(struct sst_byt *byt,
 static void sst_byt_stream_update(struct sst_byt *byt, struct ipc_message *msg)
 {
         struct sst_byt_stream *stream;
-        u64 header = msg->header;
+        u64 header = msg->tx.header;
         u8 stream_id = sst_byt_header_str_id(header);
         u8 stream_msg = sst_byt_header_msg_id(header);
 
@@ -240,9 +240,10 @@ static int sst_byt_process_reply(struct sst_byt *byt, u64 header)
         if (msg == NULL)
                 return 1;
 
+        msg->rx.header = header;
         if (header & IPC_HEADER_LARGE(true)) {
-                msg->rx_size = sst_byt_header_data(header);
-                sst_dsp_inbox_read(byt->dsp, msg->rx_data, msg->rx_size);
+                msg->rx.size = sst_byt_header_data(header);
+                sst_dsp_inbox_read(byt->dsp, msg->rx.data, msg->rx.size);
         }
 
         /* update any stream states */
@@ -407,17 +408,18 @@ int sst_byt_stream_buffer(struct sst_byt *byt, struct sst_byt_stream *stream,
 
 int sst_byt_stream_commit(struct sst_byt *byt, struct sst_byt_stream *stream)
 {
-        struct sst_byt_alloc_params *str_req = &stream->request;
-        struct sst_byt_alloc_response *reply = &stream->reply;
-        u64 header;
+        struct sst_ipc_message request, reply = {0};
         int ret;
 
-        header = sst_byt_header(IPC_IA_ALLOC_STREAM,
-                                sizeof(*str_req) + sizeof(u32),
+        request.header = sst_byt_header(IPC_IA_ALLOC_STREAM,
+                                sizeof(stream->request) + sizeof(u32),
                                 true, stream->str_id);
-        ret = sst_ipc_tx_message_wait(&byt->ipc, header, str_req,
-                                      sizeof(*str_req),
-                                      reply, sizeof(*reply));
+        request.data = &stream->request;
+        request.size = sizeof(stream->request);
+        reply.data = &stream->reply;
+        reply.size = sizeof(stream->reply);
+
+        ret = sst_ipc_tx_message_wait(&byt->ipc, request, &reply);
         if (ret < 0) {
                 dev_err(byt->dev, "ipc: error stream commit failed\n");
                 return ret;
@@ -430,7 +432,7 @@ int sst_byt_stream_commit(struct sst_byt *byt, struct sst_byt_stream *stream)
 
 int sst_byt_stream_free(struct sst_byt *byt, struct sst_byt_stream *stream)
 {
-        u64 header;
+        struct sst_ipc_message request = {0};
         int ret = 0;
         struct sst_dsp *sst = byt->dsp;
         unsigned long flags;
@@ -438,8 +440,9 @@ int sst_byt_stream_free(struct sst_byt *byt, struct sst_byt_stream *stream)
         if (!stream->commited)
                 goto out;
 
-        header = sst_byt_header(IPC_IA_FREE_STREAM, 0, false, stream->str_id);
-        ret = sst_ipc_tx_message_wait(&byt->ipc, header, NULL, 0, NULL, 0);
+        request.header = sst_byt_header(IPC_IA_FREE_STREAM,
+                        0, false, stream->str_id);
+        ret = sst_ipc_tx_message_wait(&byt->ipc, request, NULL);
         if (ret < 0) {
                 dev_err(byt->dev, "ipc: free stream %d failed\n",
                         stream->str_id);
@@ -459,15 +462,13 @@ out:
 static int sst_byt_stream_operations(struct sst_byt *byt, int type,
                                      int stream_id, int wait)
 {
-        u64 header;
+        struct sst_ipc_message request = {0};
 
-        header = sst_byt_header(type, 0, false, stream_id);
+        request.header = sst_byt_header(type, 0, false, stream_id);
         if (wait)
-                return sst_ipc_tx_message_wait(&byt->ipc, header, NULL,
-                                                0, NULL, 0);
+                return sst_ipc_tx_message_wait(&byt->ipc, request, NULL);
         else
-                return sst_ipc_tx_message_nowait(&byt->ipc, header,
-                                                NULL, 0);
+                return sst_ipc_tx_message_nowait(&byt->ipc, request);
 }
 
 /* stream ALSA trigger operations */
@@ -475,19 +476,17 @@ int sst_byt_stream_start(struct sst_byt *byt, struct sst_byt_stream *stream,
                          u32 start_offset)
 {
         struct sst_byt_start_stream_params start_stream;
-        void *tx_msg;
-        size_t size;
-        u64 header;
+        struct sst_ipc_message request;
         int ret;
 
         start_stream.byte_offset = start_offset;
-        header = sst_byt_header(IPC_IA_START_STREAM,
+        request.header = sst_byt_header(IPC_IA_START_STREAM,
                                 sizeof(start_stream) + sizeof(u32),
                                 true, stream->str_id);
-        tx_msg = &start_stream;
-        size = sizeof(start_stream);
+        request.data = &start_stream;
+        request.size = sizeof(start_stream);
 
-        ret = sst_ipc_tx_message_nowait(&byt->ipc, header, tx_msg, size);
+        ret = sst_ipc_tx_message_nowait(&byt->ipc, request);
         if (ret < 0)
                 dev_err(byt->dev, "ipc: error failed to start stream %d\n",
                         stream->str_id);
@@ -623,10 +622,10 @@ EXPORT_SYMBOL_GPL(sst_byt_dsp_wait_for_ready);
 
 static void byt_tx_msg(struct sst_generic_ipc *ipc, struct ipc_message *msg)
 {
-        if (msg->header & IPC_HEADER_LARGE(true))
-                sst_dsp_outbox_write(ipc->dsp, msg->tx_data, msg->tx_size);
+        if (msg->tx.header & IPC_HEADER_LARGE(true))
+                sst_dsp_outbox_write(ipc->dsp, msg->tx.data, msg->tx.size);
 
-        sst_dsp_shim_write64_unlocked(ipc->dsp, SST_IPCX, msg->header);
+        sst_dsp_shim_write64_unlocked(ipc->dsp, SST_IPCX, msg->tx.header);
 }
 
 static void byt_shim_dbg(struct sst_generic_ipc *ipc, const char *text)
@@ -648,9 +647,9 @@ static void byt_tx_data_copy(struct ipc_message *msg, char *tx_data,
         size_t tx_size)
 {
         /* msg content = lower 32-bit of the header + data */
-        *(u32 *)msg->tx_data = (u32)(msg->header & (u32)-1);
-        memcpy(msg->tx_data + sizeof(u32), tx_data, tx_size);
-        msg->tx_size += sizeof(u32);
+        *(u32 *)msg->tx.data = (u32)(msg->tx.header & (u32)-1);
+        memcpy(msg->tx.data + sizeof(u32), tx_data, tx_size);
+        msg->tx.size += sizeof(u32);
 }
 
 static u64 byt_reply_msg_match(u64 header, u64 *mask)
diff --git a/sound/soc/intel/baytrail/sst-baytrail-pcm.c b/sound/soc/intel/baytrail/sst-baytrail-pcm.c
index 9cbc982d46a9..54f2ee3010ee 100644
--- a/sound/soc/intel/baytrail/sst-baytrail-pcm.c
+++ b/sound/soc/intel/baytrail/sst-baytrail-pcm.c
@@ -193,6 +193,7 @@ static int sst_byt_pcm_trigger(struct snd_pcm_substream *substream, int cmd)
                 break;
         case SNDRV_PCM_TRIGGER_SUSPEND:
                 pdata->restore_stream = false;
+                /* fallthrough */
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
                 sst_byt_stream_pause(byt, pcm_data->stream);
                 break;
diff --git a/sound/soc/intel/boards/Kconfig b/sound/soc/intel/boards/Kconfig
index 50bf149818b5..5c27f7ab4a5f 100644
--- a/sound/soc/intel/boards/Kconfig
+++ b/sound/soc/intel/boards/Kconfig
@@ -256,16 +256,20 @@ config SND_SOC_INTEL_SKL_NAU88L25_MAX98357A_MACH
 
 endif ## SND_SOC_INTEL_SKL
 
+config SND_SOC_INTEL_DA7219_MAX98357A_GENERIC
+        tristate
+        select SND_SOC_DA7219
+        select SND_SOC_MAX98357A
+        select SND_SOC_DMIC
+        select SND_SOC_HDAC_HDMI
+
 if SND_SOC_INTEL_APL
 
 config SND_SOC_INTEL_BXT_DA7219_MAX98357A_MACH
         tristate "Broxton with DA7219 and MAX98357A in I2S Mode"
         depends on I2C && ACPI
         depends on MFD_INTEL_LPSS || COMPILE_TEST
-        select SND_SOC_DA7219
-        select SND_SOC_MAX98357A
-        select SND_SOC_DMIC
-        select SND_SOC_HDAC_HDMI
+        select SND_SOC_INTEL_DA7219_MAX98357A_GENERIC
         select SND_HDA_DSP_LOADER
         help
            This adds support for ASoC machine driver for Broxton-P platforms
@@ -326,10 +330,7 @@ config SND_SOC_INTEL_KBL_DA7219_MAX98357A_MACH
         tristate "KBL with DA7219 and MAX98357A in I2S Mode"
         depends on I2C && ACPI
         depends on MFD_INTEL_LPSS || COMPILE_TEST
-        select SND_SOC_DA7219
-        select SND_SOC_MAX98357A
-        select SND_SOC_DMIC
-        select SND_SOC_HDAC_HDMI
+        select SND_SOC_INTEL_DA7219_MAX98357A_GENERIC
         help
           This adds support for ASoC Onboard Codec I2S machine driver. This will
           create an alsa sound card for DA7219 + MAX98357A I2S audio codec.
@@ -387,6 +388,7 @@ if SND_SOC_INTEL_SKYLAKE_HDAUDIO_CODEC || SND_SOC_SOF_HDA_AUDIO_CODEC
 config SND_SOC_INTEL_SKL_HDA_DSP_GENERIC_MACH
         tristate "SKL/KBL/BXT/APL with HDA Codecs"
         select SND_SOC_HDAC_HDMI
+        select SND_SOC_DMIC
         # SND_SOC_HDAC_HDA is already selected
         help
           This adds support for ASoC machine driver for Intel platforms
@@ -412,4 +414,14 @@ config SND_SOC_INTEL_SOF_RT5682_MACH
            If unsure select "N".
 endif ## SND_SOC_SOF_HDA_COMMON || SND_SOC_SOF_BAYTRAIL
 
+if (SND_SOC_SOF_COMETLAKE_LP && SND_SOC_SOF_HDA_LINK)
+
+config SND_SOC_INTEL_CML_LP_DA7219_MAX98357A_MACH
+        tristate "CML_LP with DA7219 and MAX98357A in I2S Mode"
+        depends on I2C && ACPI
+        depends on MFD_INTEL_LPSS || COMPILE_TEST
+        select SND_SOC_INTEL_DA7219_MAX98357A_GENERIC
+
+endif ## SND_SOC_SOF_COMETLAKE_LP && SND_SOC_SOF_HDA_LINK
+
 endif ## SND_SOC_INTEL_MACH
diff --git a/sound/soc/intel/boards/bdw-rt5677.c b/sound/soc/intel/boards/bdw-rt5677.c
index e8e9c3dc82a5..4a4d3353e26d 100644
--- a/sound/soc/intel/boards/bdw-rt5677.c
+++ b/sound/soc/intel/boards/bdw-rt5677.c
@@ -340,7 +340,6 @@ static int bdw_rt5677_probe(struct platform_device *pdev)
 {
         struct bdw_rt5677_priv *bdw_rt5677;
         struct snd_soc_acpi_mach *mach;
-        const char *platform_name = NULL;
         int ret;
 
         bdw_rt5677_card.dev = &pdev->dev;
@@ -355,11 +354,8 @@ static int bdw_rt5677_probe(struct platform_device *pdev)
 
         /* override plaform name, if required */
         mach = (&pdev->dev)->platform_data;
-        if (mach) /* extra check since legacy does not pass parameters */
-                platform_name = mach->mach_params.platform;
-
         ret = snd_soc_fixup_dai_links_platform_name(&bdw_rt5677_card,
-                                                    platform_name);
+                                                    mach->mach_params.platform);
         if (ret)
                 return ret;
 
diff --git a/sound/soc/intel/boards/broadwell.c b/sound/soc/intel/boards/broadwell.c
index ab38ef30dfff..db7e1e87156d 100644
--- a/sound/soc/intel/boards/broadwell.c
+++ b/sound/soc/intel/boards/broadwell.c
@@ -270,18 +270,14 @@ static struct snd_soc_card broadwell_rt286 = {
 static int broadwell_audio_probe(struct platform_device *pdev)
 {
         struct snd_soc_acpi_mach *mach;
-        const char *platform_name = NULL;
         int ret;
 
         broadwell_rt286.dev = &pdev->dev;
 
         /* override plaform name, if required */
         mach = (&pdev->dev)->platform_data;
-        if (mach) /* extra check since legacy does not pass parameters */
-                platform_name = mach->mach_params.platform;
-
         ret = snd_soc_fixup_dai_links_platform_name(&broadwell_rt286,
-                                                    platform_name);
+                                                    mach->mach_params.platform);
         if (ret)
                 return ret;
 
diff --git a/sound/soc/intel/boards/bxt_da7219_max98357a.c b/sound/soc/intel/boards/bxt_da7219_max98357a.c
index c0d865a940dc..ac1dea5f9d11 100644
--- a/sound/soc/intel/boards/bxt_da7219_max98357a.c
+++ b/sound/soc/intel/boards/bxt_da7219_max98357a.c
@@ -179,10 +179,17 @@ static int broxton_da7219_codec_init(struct snd_soc_pcm_runtime *rtd)
         int ret;
         struct snd_soc_dai *codec_dai = rtd->codec_dai;
         struct snd_soc_component *component = rtd->codec_dai->component;
+        int clk_freq;
 
         /* Configure sysclk for codec */
-        ret = snd_soc_dai_set_sysclk(codec_dai, DA7219_CLKSRC_MCLK, 19200000,
+        if (soc_intel_is_cml())
+                clk_freq = 24000000;
+        else
+                clk_freq = 19200000;
+
+        ret = snd_soc_dai_set_sysclk(codec_dai, DA7219_CLKSRC_MCLK, clk_freq,
                                      SND_SOC_CLOCK_IN);
+
         if (ret) {
                 dev_err(rtd->dev, "can't set codec sysclk configuration\n");
                 return ret;
@@ -683,6 +690,25 @@ static int broxton_audio_probe(struct platform_device *pdev)
                                 broxton_dais[i].cpus->dai_name = "SSP2 Pin";
                         }
                 }
+        } else if (soc_intel_is_cml()) {
+                unsigned int i;
+
+                broxton_audio_card.name = "cmlda7219max";
+
+                for (i = 0; i < ARRAY_SIZE(broxton_dais); i++) {
+                        /* MAXIM_CODEC is connected to SSP1. */
+                        if (!strcmp(broxton_dais[i].codecs->dai_name,
+                                        BXT_MAXIM_CODEC_DAI)) {
+                                broxton_dais[i].name = "SSP1-Codec";
+                                broxton_dais[i].cpus->dai_name = "SSP1 Pin";
+                        }
+                        /* DIALOG_CODEC is connected to SSP0 */
+                        else if (!strcmp(broxton_dais[i].codecs->dai_name,
+                                        BXT_DIALOG_CODEC_DAI)) {
+                                broxton_dais[i].name = "SSP0-Codec";
+                                broxton_dais[i].cpus->dai_name = "SSP0 Pin";
+                        }
+                }
         }
 
         /* override plaform name, if required */
@@ -700,6 +726,7 @@ static int broxton_audio_probe(struct platform_device *pdev)
 static const struct platform_device_id bxt_board_ids[] = {
         { .name = "bxt_da7219_max98357a" },
         { .name = "glk_da7219_max98357a" },
+        { .name = "cml_da7219_max98357a" },
         { }
 };
 
@@ -720,6 +747,8 @@ MODULE_AUTHOR("Rohit Ainapure <rohit.m.ainapure@intel.com>");
 MODULE_AUTHOR("Harsha Priya <harshapriya.n@intel.com>");
 MODULE_AUTHOR("Conrad Cooke <conrad.cooke@intel.com>");
 MODULE_AUTHOR("Naveen Manohar <naveen.m@intel.com>");
+MODULE_AUTHOR("Mac Chiang <mac.chiang@intel.com>");
 MODULE_LICENSE("GPL v2");
 MODULE_ALIAS("platform:bxt_da7219_max98357a");
 MODULE_ALIAS("platform:glk_da7219_max98357a");
+MODULE_ALIAS("platform:cml_da7219_max98357a");
diff --git a/sound/soc/intel/boards/cht_bsw_max98090_ti.c b/sound/soc/intel/boards/cht_bsw_max98090_ti.c
index 05db311b579e..70bb86f3342f 100644
--- a/sound/soc/intel/boards/cht_bsw_max98090_ti.c
+++ b/sound/soc/intel/boards/cht_bsw_max98090_ti.c
@@ -325,9 +325,8 @@ static const struct snd_soc_ops cht_be_ssp2_ops = {
 };
 
 static struct snd_soc_aux_dev cht_max98090_headset_dev = {
-        .name = "Headset Chip",
+        .dlc = COMP_AUX("i2c-104C227E:00"),
         .init = cht_max98090_headset_init,
-        .codec_name = "i2c-104C227E:00",
 };
 
 SND_SOC_DAILINK_DEF(dummy,
@@ -401,6 +400,20 @@ static struct snd_soc_card snd_soc_card_cht = {
 
 static const struct dmi_system_id cht_max98090_quirk_table[] = {
         {
+                /* Banjo model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Banjo"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
+                /* Candy model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Candy"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
                 /* Clapper model Chromebook */
                 .matches = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Clapper"),
@@ -408,6 +421,27 @@ static const struct dmi_system_id cht_max98090_quirk_table[] = {
                 .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
         },
         {
+                /* Cyan model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Cyan"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
+                /* Enguarde model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Enguarde"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
+                /* Glimmer model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Glimmer"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
                 /* Gnawty model Chromebook (Acer Chromebook CB3-111) */
                 .matches = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Gnawty"),
@@ -415,12 +449,75 @@ static const struct dmi_system_id cht_max98090_quirk_table[] = {
                 .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
         },
         {
+                /* Heli model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Heli"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
+                /* Kip model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Kip"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
+                /* Ninja model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Ninja"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
+                /* Orco model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Orco"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
+                /* Quawks model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Quawks"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
+                /* Rambi model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Rambi"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
+                /* Squawks model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Squawks"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
+                /* Sumo model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Sumo"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
+        {
                 /* Swanky model Chromebook (Toshiba Chromebook 2) */
                 .matches = {
                         DMI_MATCH(DMI_PRODUCT_NAME, "Swanky"),
                 },
                 .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
         },
+        {
+                /* Winky model Chromebook */
+                .matches = {
+                        DMI_MATCH(DMI_PRODUCT_NAME, "Winky"),
+                },
+                .driver_data = (void *)QUIRK_PMC_PLT_CLK_0,
+        },
         {}
 };
 
diff --git a/sound/soc/intel/boards/haswell.c b/sound/soc/intel/boards/haswell.c
index 4d3822cff98c..3dadf9bff796 100644
--- a/sound/soc/intel/boards/haswell.c
+++ b/sound/soc/intel/boards/haswell.c
@@ -188,18 +188,14 @@ static struct snd_soc_card haswell_rt5640 = {
 static int haswell_audio_probe(struct platform_device *pdev)
 {
         struct snd_soc_acpi_mach *mach;
-        const char *platform_name = NULL;
         int ret;
 
         haswell_rt5640.dev = &pdev->dev;
 
         /* override plaform name, if required */
         mach = (&pdev->dev)->platform_data;
-        if (mach) /* extra check since legacy does not pass parameters */
-                platform_name = mach->mach_params.platform;
-
         ret = snd_soc_fixup_dai_links_platform_name(&haswell_rt5640,
-                                                    platform_name);
+                                                    mach->mach_params.platform);
         if (ret)
                 return ret;
 
diff --git a/sound/soc/intel/boards/skl_hda_dsp_common.c b/sound/soc/intel/boards/skl_hda_dsp_common.c
index 55fd82e05e2c..58409b6e476e 100644
--- a/sound/soc/intel/boards/skl_hda_dsp_common.c
+++ b/sound/soc/intel/boards/skl_hda_dsp_common.c
@@ -147,6 +147,11 @@ int skl_hda_hdmi_jack_init(struct snd_soc_card *card)
                 if (err)
                         return err;
 
+                err = snd_jack_add_new_kctl(pcm->hdmi_jack.jack,
+                                            jack_name, SND_JACK_AVOUT);
+                if (err)
+                        dev_warn(component->dev, "failed creating Jack kctl\n");
+
                 err = hdac_hdmi_jack_init(pcm->codec_dai, pcm->device,
                                           &pcm->hdmi_jack);
                 if (err < 0)
diff --git a/sound/soc/intel/boards/skl_hda_dsp_generic.c b/sound/soc/intel/boards/skl_hda_dsp_generic.c
index 9ed68eb4f058..1778acdc367c 100644
--- a/sound/soc/intel/boards/skl_hda_dsp_generic.c
+++ b/sound/soc/intel/boards/skl_hda_dsp_generic.c
@@ -23,6 +23,7 @@ static const struct snd_soc_dapm_widget skl_hda_widgets[] = {
         SND_SOC_DAPM_MIC("Alt Analog In", NULL),
         SND_SOC_DAPM_SPK("Digital Out", NULL),
         SND_SOC_DAPM_MIC("Digital In", NULL),
+        SND_SOC_DAPM_MIC("SoC DMIC", NULL),
 };
 
 static const struct snd_soc_dapm_route skl_hda_map[] = {
@@ -41,6 +42,9 @@ static const struct snd_soc_dapm_route skl_hda_map[] = {
         { "Codec Input Pin2", NULL, "Digital In" },
         { "Codec Input Pin3", NULL, "Alt Analog In" },
 
+        /* digital mics */
+        {"DMic", NULL, "SoC DMIC"},
+
         /* CODEC BE connections */
         { "Analog Codec Playback", NULL, "Analog CPU Playback" },
         { "Analog CPU Playback", NULL, "codec0_out" },
diff --git a/sound/soc/intel/boards/sof_rt5682.c b/sound/soc/intel/boards/sof_rt5682.c
index daeaa396d928..a437567b8cee 100644
--- a/sound/soc/intel/boards/sof_rt5682.c
+++ b/sound/soc/intel/boards/sof_rt5682.c
@@ -91,8 +91,7 @@ static const struct dmi_system_id sof_rt5682_quirk_table[] = {
         {
                 .callback = sof_rt5682_quirk_cb,
                 .matches = {
-                        DMI_MATCH(DMI_SYS_VENDOR, "Google"),
-                        DMI_MATCH(DMI_PRODUCT_NAME, "Hatch"),
+                        DMI_MATCH(DMI_PRODUCT_FAMILY, "Google_Hatch"),
                 },
                 .driver_data = (void *)(SOF_RT5682_MCLK_EN |
                                         SOF_RT5682_MCLK_24MHZ |
@@ -309,6 +308,7 @@ static const struct snd_soc_dapm_widget sof_widgets[] = {
         SND_SOC_DAPM_HP("Headphone Jack", NULL),
         SND_SOC_DAPM_MIC("Headset Mic", NULL),
         SND_SOC_DAPM_SPK("Spk", NULL),
+        SND_SOC_DAPM_MIC("SoC DMIC", NULL),
 };
 
 static const struct snd_soc_dapm_route sof_map[] = {
@@ -319,6 +319,9 @@ static const struct snd_soc_dapm_route sof_map[] = {
         /* other jacks */
         { "IN1P", NULL, "Headset Mic" },
 
+        /* digital mics */
+        {"DMic", NULL, "SoC DMIC"},
+
 };
 
 static const struct snd_soc_dapm_route speaker_map[] = {
diff --git a/sound/soc/intel/common/Makefile b/sound/soc/intel/common/Makefile
index 56c81e20b5bf..18d9630ae9a2 100644
--- a/sound/soc/intel/common/Makefile
+++ b/sound/soc/intel/common/Makefile
@@ -8,6 +8,7 @@ snd-soc-acpi-intel-match-objs := soc-acpi-intel-byt-match.o soc-acpi-intel-cht-m
         soc-acpi-intel-skl-match.o soc-acpi-intel-kbl-match.o \
         soc-acpi-intel-bxt-match.o soc-acpi-intel-glk-match.o \
         soc-acpi-intel-cnl-match.o soc-acpi-intel-icl-match.o \
+        soc-acpi-intel-tgl-match.o soc-acpi-intel-ehl-match.o \
         soc-acpi-intel-hda-match.o
 
 obj-$(CONFIG_SND_SOC_INTEL_SST) += snd-soc-sst-dsp.o snd-soc-sst-ipc.o
diff --git a/sound/soc/intel/common/soc-acpi-intel-cnl-match.c b/sound/soc/intel/common/soc-acpi-intel-cnl-match.c
index 771b0ef21051..985aa366c9e8 100644
--- a/sound/soc/intel/common/soc-acpi-intel-cnl-match.c
+++ b/sound/soc/intel/common/soc-acpi-intel-cnl-match.c
@@ -19,6 +19,11 @@ static struct snd_soc_acpi_codecs cml_codecs = {
         .codecs = {"10EC5682"}
 };
 
+static struct snd_soc_acpi_codecs cml_spk_codecs = {
+        .num_codecs = 1,
+        .codecs = {"MX98357A"}
+};
+
 struct snd_soc_acpi_mach snd_soc_acpi_intel_cnl_machines[] = {
         {
                 .id = "INT34C2",
@@ -29,6 +34,13 @@ struct snd_soc_acpi_mach snd_soc_acpi_intel_cnl_machines[] = {
                 .sof_tplg_filename = "sof-cnl-rt274.tplg",
         },
         {
+                .id = "DLGS7219",
+                .drv_name = "cml_da7219_max98357a",
+                .quirk_data = &cml_spk_codecs,
+                .sof_fw_filename = "sof-cnl.ri",
+                .sof_tplg_filename = "sof-cml-da7219-max98357a.tplg",
+        },
+        {
                 .id = "MX98357A",
                 .drv_name = "sof_rt5682",
                 .quirk_data = &cml_codecs,
diff --git a/sound/soc/intel/common/soc-acpi-intel-ehl-match.c b/sound/soc/intel/common/soc-acpi-intel-ehl-match.c
new file mode 100644
index 000000000000..a1290c3fa99f
--- /dev/null
+++ b/sound/soc/intel/common/soc-acpi-intel-ehl-match.c
@@ -0,0 +1,18 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * soc-apci-intel-ehl-match.c - tables and support for EHL ACPI enumeration.
+ *
+ * Copyright (c) 2019, Intel Corporation.
+ *
+ */
+
+#include <sound/soc-acpi.h>
+#include <sound/soc-acpi-intel-match.h>
+
+struct snd_soc_acpi_mach snd_soc_acpi_intel_ehl_machines[] = {
+        {},
+};
+EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_ehl_machines);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("Intel Common ACPI Match module");
diff --git a/sound/soc/intel/common/soc-acpi-intel-tgl-match.c b/sound/soc/intel/common/soc-acpi-intel-tgl-match.c
new file mode 100644
index 000000000000..57a6298d6dca
--- /dev/null
+++ b/sound/soc/intel/common/soc-acpi-intel-tgl-match.c
@@ -0,0 +1,24 @@
+// SPDX-License-Identifier: GPL-2.0
+/*
+ * soc-apci-intel-tgl-match.c - tables and support for ICL ACPI enumeration.
+ *
+ * Copyright (c) 2019, Intel Corporation.
+ *
+ */
+
+#include <sound/soc-acpi.h>
+#include <sound/soc-acpi-intel-match.h>
+
+struct snd_soc_acpi_mach snd_soc_acpi_intel_tgl_machines[] = {
+        {
+                .id = "10EC1308",
+                .drv_name = "tgl_rt1308",
+                .sof_fw_filename = "sof-tgl.ri",
+                .sof_tplg_filename = "sof-tgl-rt1308.tplg",
+        },
+        {},
+};
+EXPORT_SYMBOL_GPL(snd_soc_acpi_intel_tgl_machines);
+
+MODULE_LICENSE("GPL v2");
+MODULE_DESCRIPTION("Intel Common ACPI Match module");
diff --git a/sound/soc/intel/common/soc-intel-quirks.h b/sound/soc/intel/common/soc-intel-quirks.h
index 4718fd3cf636..863a477d3405 100644
--- a/sound/soc/intel/common/soc-intel-quirks.h
+++ b/sound/soc/intel/common/soc-intel-quirks.h
@@ -36,6 +36,7 @@ SOC_INTEL_IS_CPU(byt, INTEL_FAM6_ATOM_SILVERMONT);
 SOC_INTEL_IS_CPU(cht, INTEL_FAM6_ATOM_AIRMONT);
 SOC_INTEL_IS_CPU(apl, INTEL_FAM6_ATOM_GOLDMONT);
 SOC_INTEL_IS_CPU(glk, INTEL_FAM6_ATOM_GOLDMONT_PLUS);
+SOC_INTEL_IS_CPU(cml, INTEL_FAM6_KABYLAKE_L);
 
 static inline bool soc_intel_is_byt_cr(struct platform_device *pdev)
 {
@@ -110,6 +111,10 @@ static inline bool soc_intel_is_glk(void)
         return false;
 }
 
+static inline bool soc_intel_is_cml(void)
+{
+        return false;
+}
 #endif
 
  #endif /* _SND_SOC_INTEL_QUIRKS_H */
diff --git a/sound/soc/intel/common/sst-acpi.c b/sound/soc/intel/common/sst-acpi.c
index 0e8e0a7a11df..5854868650b9 100644
--- a/sound/soc/intel/common/sst-acpi.c
+++ b/sound/soc/intel/common/sst-acpi.c
@@ -141,11 +141,12 @@ static int sst_acpi_probe(struct platform_device *pdev)
         }
 
         platform_set_drvdata(pdev, sst_acpi);
+        mach->pdata = sst_pdata;
 
         /* register machine driver */
         sst_acpi->pdev_mach =
                 platform_device_register_data(dev, mach->drv_name, -1,
-                                              sst_pdata, sizeof(*sst_pdata));
+                                              mach, sizeof(*mach));
         if (IS_ERR(sst_acpi->pdev_mach))
                 return PTR_ERR(sst_acpi->pdev_mach);
 
diff --git a/sound/soc/intel/common/sst-ipc.c b/sound/soc/intel/common/sst-ipc.c
index ef5b66af1cd2..6068bb697e22 100644
--- a/sound/soc/intel/common/sst-ipc.c
+++ b/sound/soc/intel/common/sst-ipc.c
@@ -43,7 +43,7 @@ static struct ipc_message *msg_get_empty(struct sst_generic_ipc *ipc)
 }
 
 static int tx_wait_done(struct sst_generic_ipc *ipc,
-        struct ipc_message *msg, void *rx_data)
+        struct ipc_message *msg, struct sst_ipc_message *reply)
 {
         unsigned long flags;
         int ret;
@@ -62,8 +62,11 @@ static int tx_wait_done(struct sst_generic_ipc *ipc,
         } else {
 
                 /* copy the data returned from DSP */
-                if (rx_data)
-                        memcpy(rx_data, msg->rx_data, msg->rx_size);
+                if (reply) {
+                        reply->header = msg->rx.header;
+                        if (reply->data)
+                                memcpy(reply->data, msg->rx.data, msg->rx.size);
+                }
                 ret = msg->errno;
         }
 
@@ -72,9 +75,9 @@ static int tx_wait_done(struct sst_generic_ipc *ipc,
         return ret;
 }
 
-static int ipc_tx_message(struct sst_generic_ipc *ipc, u64 header,
-        void *tx_data, size_t tx_bytes, void *rx_data,
-        size_t rx_bytes, int wait)
+static int ipc_tx_message(struct sst_generic_ipc *ipc,
+        struct sst_ipc_message request,
+        struct sst_ipc_message *reply, int wait)
 {
         struct ipc_message *msg;
         unsigned long flags;
@@ -87,23 +90,24 @@ static int ipc_tx_message(struct sst_generic_ipc *ipc, u64 header,
                 return -EBUSY;
         }
 
-        msg->header = header;
-        msg->tx_size = tx_bytes;
-        msg->rx_size = rx_bytes;
+        msg->tx.header = request.header;
+        msg->tx.size = request.size;
+        msg->rx.header = 0;
+        msg->rx.size = reply ? reply->size : 0;
         msg->wait = wait;
         msg->errno = 0;
         msg->pending = false;
         msg->complete = false;
 
-        if ((tx_bytes) && (ipc->ops.tx_data_copy != NULL))
-                ipc->ops.tx_data_copy(msg, tx_data, tx_bytes);
+        if ((request.size) && (ipc->ops.tx_data_copy != NULL))
+                ipc->ops.tx_data_copy(msg, request.data, request.size);
 
         list_add_tail(&msg->list, &ipc->tx_list);
         schedule_work(&ipc->kwork);
         spin_unlock_irqrestore(&ipc->dsp->spinlock, flags);
 
         if (wait)
-                return tx_wait_done(ipc, msg, rx_data);
+                return tx_wait_done(ipc, msg, reply);
         else
                 return 0;
 }
@@ -118,13 +122,13 @@ static int msg_empty_list_init(struct sst_generic_ipc *ipc)
                 return -ENOMEM;
 
         for (i = 0; i < IPC_EMPTY_LIST_SIZE; i++) {
-                ipc->msg[i].tx_data = kzalloc(ipc->tx_data_max_size, GFP_KERNEL);
-                if (ipc->msg[i].tx_data == NULL)
+                ipc->msg[i].tx.data = kzalloc(ipc->tx_data_max_size, GFP_KERNEL);
+                if (ipc->msg[i].tx.data == NULL)
                         goto free_mem;
 
-                ipc->msg[i].rx_data = kzalloc(ipc->rx_data_max_size, GFP_KERNEL);
-                if (ipc->msg[i].rx_data == NULL) {
-                        kfree(ipc->msg[i].tx_data);
+                ipc->msg[i].rx.data = kzalloc(ipc->rx_data_max_size, GFP_KERNEL);
+                if (ipc->msg[i].rx.data == NULL) {
+                        kfree(ipc->msg[i].tx.data);
                         goto free_mem;
                 }
 
@@ -136,8 +140,8 @@ static int msg_empty_list_init(struct sst_generic_ipc *ipc)
 
 free_mem:
         while (i > 0) {
-                kfree(ipc->msg[i-1].tx_data);
-                kfree(ipc->msg[i-1].rx_data);
+                kfree(ipc->msg[i-1].tx.data);
+                kfree(ipc->msg[i-1].rx.data);
                 --i;
         }
         kfree(ipc->msg);
@@ -173,8 +177,8 @@ static void ipc_tx_msgs(struct work_struct *work)
         spin_unlock_irq(&ipc->dsp->spinlock);
 }
 
-int sst_ipc_tx_message_wait(struct sst_generic_ipc *ipc, u64 header,
-        void *tx_data, size_t tx_bytes, void *rx_data, size_t rx_bytes)
+int sst_ipc_tx_message_wait(struct sst_generic_ipc *ipc,
+        struct sst_ipc_message request, struct sst_ipc_message *reply)
 {
         int ret;
 
@@ -187,8 +191,7 @@ int sst_ipc_tx_message_wait(struct sst_generic_ipc *ipc, u64 header,
                 if (ipc->ops.check_dsp_lp_on(ipc->dsp, true))
                         return -EIO;
 
-        ret = ipc_tx_message(ipc, header, tx_data, tx_bytes,
-                rx_data, rx_bytes, 1);
+        ret = ipc_tx_message(ipc, request, reply, 1);
 
         if (ipc->ops.check_dsp_lp_on)
                 if (ipc->ops.check_dsp_lp_on(ipc->dsp, false))
@@ -198,19 +201,17 @@ int sst_ipc_tx_message_wait(struct sst_generic_ipc *ipc, u64 header,
 }
 EXPORT_SYMBOL_GPL(sst_ipc_tx_message_wait);
 
-int sst_ipc_tx_message_nowait(struct sst_generic_ipc *ipc, u64 header,
-        void *tx_data, size_t tx_bytes)
+int sst_ipc_tx_message_nowait(struct sst_generic_ipc *ipc,
+        struct sst_ipc_message request)
 {
-        return ipc_tx_message(ipc, header, tx_data, tx_bytes,
-                NULL, 0, 0);
+        return ipc_tx_message(ipc, request, NULL, 0);
 }
 EXPORT_SYMBOL_GPL(sst_ipc_tx_message_nowait);
 
-int sst_ipc_tx_message_nopm(struct sst_generic_ipc *ipc, u64 header,
-        void *tx_data, size_t tx_bytes, void *rx_data, size_t rx_bytes)
+int sst_ipc_tx_message_nopm(struct sst_generic_ipc *ipc,
+        struct sst_ipc_message request, struct sst_ipc_message *reply)
 {
-        return ipc_tx_message(ipc, header, tx_data, tx_bytes,
-                rx_data, rx_bytes, 1);
+        return ipc_tx_message(ipc, request, reply, 1);
 }
 EXPORT_SYMBOL_GPL(sst_ipc_tx_message_nopm);
 
@@ -222,6 +223,8 @@ struct ipc_message *sst_ipc_reply_find_msg(struct sst_generic_ipc *ipc,
 
         if (ipc->ops.reply_msg_match != NULL)
                 header = ipc->ops.reply_msg_match(header, &mask);
+        else
+                mask = (u64)-1;
 
         if (list_empty(&ipc->rx_list)) {
                 dev_err(ipc->dev, "error: rx list empty but received 0x%llx\n",
@@ -230,7 +233,7 @@ struct ipc_message *sst_ipc_reply_find_msg(struct sst_generic_ipc *ipc,
         }
 
         list_for_each_entry(msg, &ipc->rx_list, list) {
-                if ((msg->header & mask) == header)
+                if ((msg->tx.header & mask) == header)
                         return msg;
         }
 
@@ -304,8 +307,8 @@ void sst_ipc_fini(struct sst_generic_ipc *ipc)
 
         if (ipc->msg) {
                 for (i = 0; i < IPC_EMPTY_LIST_SIZE; i++) {
-                        kfree(ipc->msg[i].tx_data);
-                        kfree(ipc->msg[i].rx_data);
+                        kfree(ipc->msg[i].tx.data);
+                        kfree(ipc->msg[i].rx.data);
                 }
                 kfree(ipc->msg);
         }
diff --git a/sound/soc/intel/common/sst-ipc.h b/sound/soc/intel/common/sst-ipc.h
index c6779e2ac830..08c4831b2664 100644
--- a/sound/soc/intel/common/sst-ipc.h
+++ b/sound/soc/intel/common/sst-ipc.h
@@ -17,15 +17,16 @@
 
 #define IPC_MAX_MAILBOX_BYTES   256
 
-struct ipc_message {
-        struct list_head list;
+struct sst_ipc_message {
         u64 header;
+        void *data;
+        size_t size;
+};
 
-        /* direction wrt host CPU */
-        char *tx_data;
-        size_t tx_size;
-        char *rx_data;
-        size_t rx_size;
+struct ipc_message {
+        struct list_head list;
+        struct sst_ipc_message tx;
+        struct sst_ipc_message rx;
 
         wait_queue_head_t waitq;
         bool pending;
@@ -35,6 +36,7 @@ struct ipc_message {
 };
 
 struct sst_generic_ipc;
+struct sst_dsp;
 
 struct sst_plat_ipc_ops {
         void (*tx_msg)(struct sst_generic_ipc *, struct ipc_message *);
@@ -65,14 +67,14 @@ struct sst_generic_ipc {
         struct sst_plat_ipc_ops ops;
 };
 
-int sst_ipc_tx_message_wait(struct sst_generic_ipc *ipc, u64 header,
-        void *tx_data, size_t tx_bytes, void *rx_data, size_t rx_bytes);
+int sst_ipc_tx_message_wait(struct sst_generic_ipc *ipc,
+        struct sst_ipc_message request, struct sst_ipc_message *reply);
 
-int sst_ipc_tx_message_nowait(struct sst_generic_ipc *ipc, u64 header,
-        void *tx_data, size_t tx_bytes);
+int sst_ipc_tx_message_nowait(struct sst_generic_ipc *ipc,
+        struct sst_ipc_message request);
 
-int sst_ipc_tx_message_nopm(struct sst_generic_ipc *ipc, u64 header,
-        void *tx_data, size_t tx_bytes, void *rx_data, size_t rx_bytes);
+int sst_ipc_tx_message_nopm(struct sst_generic_ipc *ipc,
+        struct sst_ipc_message request, struct sst_ipc_message *reply);
 
 struct ipc_message *sst_ipc_reply_find_msg(struct sst_generic_ipc *ipc,
         u64 header);
diff --git a/sound/soc/intel/haswell/sst-haswell-ipc.c b/sound/soc/intel/haswell/sst-haswell-ipc.c
index a83b92d6bea8..0ff89ea96ccf 100644
--- a/sound/soc/intel/haswell/sst-haswell-ipc.c
+++ b/sound/soc/intel/haswell/sst-haswell-ipc.c
@@ -511,7 +511,7 @@ static void hsw_notification_work(struct work_struct *work)
 static void hsw_stream_update(struct sst_hsw *hsw, struct ipc_message *msg)
 {
         struct sst_hsw_stream *stream;
-        u32 header = msg->header & ~(IPC_STATUS_MASK | IPC_GLB_REPLY_MASK);
+        u32 header = msg->tx.header & ~(IPC_STATUS_MASK | IPC_GLB_REPLY_MASK);
         u32 stream_id = msg_get_stream_id(header);
         u32 stream_msg = msg_get_stream_type(header);
 
@@ -552,6 +552,7 @@ static int hsw_process_reply(struct sst_hsw *hsw, u32 header)
                 return -EIO;
         }
 
+        msg->rx.header = header;
         /* first process the header */
         switch (reply) {
         case IPC_GLB_REPLY_PENDING:
@@ -562,13 +563,13 @@ static int hsw_process_reply(struct sst_hsw *hsw, u32 header)
         case IPC_GLB_REPLY_SUCCESS:
                 if (msg->pending) {
                         trace_ipc_pending_reply("completed", header);
-                        sst_dsp_inbox_read(hsw->dsp, msg->rx_data,
-                                msg->rx_size);
+                        sst_dsp_inbox_read(hsw->dsp, msg->rx.data,
+                                msg->rx.size);
                         hsw->ipc.pending = false;
                 } else {
                         /* copy data from the DSP */
-                        sst_dsp_outbox_read(hsw->dsp, msg->rx_data,
-                                msg->rx_size);
+                        sst_dsp_outbox_read(hsw->dsp, msg->rx.data,
+                                msg->rx.size);
                 }
                 break;
         /* these will be rare - but useful for debug */
@@ -810,11 +811,13 @@ static irqreturn_t hsw_irq_thread(int irq, void *context)
 int sst_hsw_fw_get_version(struct sst_hsw *hsw,
         struct sst_hsw_ipc_fw_version *version)
 {
+        struct sst_ipc_message request = {0}, reply = {0};
         int ret;
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc,
-                IPC_GLB_TYPE(IPC_GLB_GET_FW_VERSION),
-                NULL, 0, version, sizeof(*version));
+        request.header = IPC_GLB_TYPE(IPC_GLB_GET_FW_VERSION);
+        reply.data = version;
+        reply.size = sizeof(*version);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, &reply);
         if (ret < 0)
                 dev_err(hsw->dev, "error: get version failed\n");
 
@@ -840,7 +843,7 @@ int sst_hsw_stream_set_volume(struct sst_hsw *hsw,
         struct sst_hsw_stream *stream, u32 stage_id, u32 channel, u32 volume)
 {
         struct sst_hsw_ipc_volume_req *req;
-        u32 header;
+        struct sst_ipc_message request;
         int ret;
 
         trace_ipc_request("set stream volume", stream->reply.stream_hw_id);
@@ -848,11 +851,11 @@ int sst_hsw_stream_set_volume(struct sst_hsw *hsw,
         if (channel >= 2 && channel != SST_HSW_CHANNELS_ALL)
                 return -EINVAL;
 
-        header = IPC_GLB_TYPE(IPC_GLB_STREAM_MESSAGE) |
+        request.header = IPC_GLB_TYPE(IPC_GLB_STREAM_MESSAGE) |
                 IPC_STR_TYPE(IPC_STR_STAGE_MESSAGE);
-        header |= (stream->reply.stream_hw_id << IPC_STR_ID_SHIFT);
-        header |= (IPC_STG_SET_VOLUME << IPC_STG_TYPE_SHIFT);
-        header |= (stage_id << IPC_STG_ID_SHIFT);
+        request.header |= (stream->reply.stream_hw_id << IPC_STR_ID_SHIFT);
+        request.header |= (IPC_STG_SET_VOLUME << IPC_STG_TYPE_SHIFT);
+        request.header |= (stage_id << IPC_STG_ID_SHIFT);
 
         req = &stream->vol_req;
         req->target_volume = volume;
@@ -877,8 +880,9 @@ int sst_hsw_stream_set_volume(struct sst_hsw *hsw,
                 req->channel = channel;
         }
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, req,
-                sizeof(*req), NULL, 0);
+        request.data = req;
+        request.size = sizeof(*req);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, NULL);
         if (ret < 0) {
                 dev_err(hsw->dev, "error: set stream volume failed\n");
                 return ret;
@@ -905,7 +909,7 @@ int sst_hsw_mixer_set_volume(struct sst_hsw *hsw, u32 stage_id, u32 channel,
         u32 volume)
 {
         struct sst_hsw_ipc_volume_req req;
-        u32 header;
+        struct sst_ipc_message request;
         int ret;
 
         trace_ipc_request("set mixer volume", volume);
@@ -933,18 +937,19 @@ int sst_hsw_mixer_set_volume(struct sst_hsw *hsw, u32 stage_id, u32 channel,
                 req.channel = channel;
         }
 
-        header = IPC_GLB_TYPE(IPC_GLB_STREAM_MESSAGE) |
+        request.header = IPC_GLB_TYPE(IPC_GLB_STREAM_MESSAGE) |
                 IPC_STR_TYPE(IPC_STR_STAGE_MESSAGE);
-        header |= (hsw->mixer_info.mixer_hw_id << IPC_STR_ID_SHIFT);
-        header |= (IPC_STG_SET_VOLUME << IPC_STG_TYPE_SHIFT);
-        header |= (stage_id << IPC_STG_ID_SHIFT);
+        request.header |= (hsw->mixer_info.mixer_hw_id << IPC_STR_ID_SHIFT);
+        request.header |= (IPC_STG_SET_VOLUME << IPC_STG_TYPE_SHIFT);
+        request.header |= (stage_id << IPC_STG_ID_SHIFT);
 
         req.curve_duration = hsw->curve_duration;
         req.curve_type = hsw->curve_type;
         req.target_volume = volume;
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, &req,
-                sizeof(req), NULL, 0);
+        request.data = &req;
+        request.size = sizeof(req);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, NULL);
         if (ret < 0) {
                 dev_err(hsw->dev, "error: set mixer volume failed\n");
                 return ret;
@@ -983,7 +988,7 @@ struct sst_hsw_stream *sst_hsw_stream_new(struct sst_hsw *hsw, int id,
 
 int sst_hsw_stream_free(struct sst_hsw *hsw, struct sst_hsw_stream *stream)
 {
-        u32 header;
+        struct sst_ipc_message request;
         int ret = 0;
         struct sst_dsp *sst = hsw->dsp;
         unsigned long flags;
@@ -1000,10 +1005,11 @@ int sst_hsw_stream_free(struct sst_hsw *hsw, struct sst_hsw_stream *stream)
         trace_ipc_request("stream free", stream->host_id);
 
         stream->free_req.stream_id = stream->reply.stream_hw_id;
-        header = IPC_GLB_TYPE(IPC_GLB_FREE_STREAM);
+        request.header = IPC_GLB_TYPE(IPC_GLB_FREE_STREAM);
+        request.data = &stream->free_req;
+        request.size = sizeof(stream->free_req);
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, &stream->free_req,
-                sizeof(stream->free_req), NULL, 0);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, NULL);
         if (ret < 0) {
                 dev_err(hsw->dev, "error: free stream %d failed\n",
                         stream->free_req.stream_id);
@@ -1175,9 +1181,7 @@ int sst_hsw_stream_set_module_info(struct sst_hsw *hsw,
 
 int sst_hsw_stream_commit(struct sst_hsw *hsw, struct sst_hsw_stream *stream)
 {
-        struct sst_hsw_ipc_stream_alloc_req *str_req = &stream->request;
-        struct sst_hsw_ipc_stream_alloc_reply *reply = &stream->reply;
-        u32 header;
+        struct sst_ipc_message request, reply = {0};
         int ret;
 
         if (!stream) {
@@ -1192,10 +1196,13 @@ int sst_hsw_stream_commit(struct sst_hsw *hsw, struct sst_hsw_stream *stream)
 
         trace_ipc_request("stream alloc", stream->host_id);
 
-        header = IPC_GLB_TYPE(IPC_GLB_ALLOCATE_STREAM);
+        request.header = IPC_GLB_TYPE(IPC_GLB_ALLOCATE_STREAM);
+        request.data = &stream->request;
+        request.size = sizeof(stream->request);
+        reply.data = &stream->reply;
+        reply.size = sizeof(stream->reply);
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, str_req,
-                sizeof(*str_req), reply, sizeof(*reply));
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, &reply);
         if (ret < 0) {
                 dev_err(hsw->dev, "error: stream commit failed\n");
                 return ret;
@@ -1235,23 +1242,22 @@ void sst_hsw_stream_set_silence_start(struct sst_hsw *hsw,
  ABI to be opaque to client PCM drivers to cope with any future ABI changes */
 int sst_hsw_mixer_get_info(struct sst_hsw *hsw)
 {
-        struct sst_hsw_ipc_stream_info_reply *reply;
-        u32 header;
+        struct sst_ipc_message request = {0}, reply = {0};
         int ret;
 
-        reply = &hsw->mixer_info;
-        header = IPC_GLB_TYPE(IPC_GLB_GET_MIXER_STREAM_INFO);
+        request.header = IPC_GLB_TYPE(IPC_GLB_GET_MIXER_STREAM_INFO);
+        reply.data = &hsw->mixer_info;
+        reply.size = sizeof(hsw->mixer_info);
 
         trace_ipc_request("get global mixer info", 0);
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, NULL, 0,
-                reply, sizeof(*reply));
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, &reply);
         if (ret < 0) {
                 dev_err(hsw->dev, "error: get stream info failed\n");
                 return ret;
         }
 
-        trace_hsw_mixer_info_reply(reply);
+        trace_hsw_mixer_info_reply(&hsw->mixer_info);
 
         return 0;
 }
@@ -1260,16 +1266,15 @@ int sst_hsw_mixer_get_info(struct sst_hsw *hsw)
 static int sst_hsw_stream_operations(struct sst_hsw *hsw, int type,
         int stream_id, int wait)
 {
-        u32 header;
+        struct sst_ipc_message request = {0};
 
-        header = IPC_GLB_TYPE(IPC_GLB_STREAM_MESSAGE) | IPC_STR_TYPE(type);
-        header |= (stream_id << IPC_STR_ID_SHIFT);
+        request.header = IPC_GLB_TYPE(IPC_GLB_STREAM_MESSAGE);
+        request.header |= IPC_STR_TYPE(type) | (stream_id << IPC_STR_ID_SHIFT);
 
         if (wait)
-                return sst_ipc_tx_message_wait(&hsw->ipc, header,
-                        NULL, 0, NULL, 0);
+                return sst_ipc_tx_message_wait(&hsw->ipc, request, NULL);
         else
-                return sst_ipc_tx_message_nowait(&hsw->ipc, header, NULL, 0);
+                return sst_ipc_tx_message_nowait(&hsw->ipc, request);
 }
 
 /* Stream ALSA trigger operations */
@@ -1377,8 +1382,8 @@ int sst_hsw_device_set_config(struct sst_hsw *hsw,
         enum sst_hsw_device_id dev, enum sst_hsw_device_mclk mclk,
         enum sst_hsw_device_mode mode, u32 clock_divider)
 {
+        struct sst_ipc_message request;
         struct sst_hsw_ipc_device_config_req config;
-        u32 header;
         int ret;
 
         trace_ipc_request("set device config", dev);
@@ -1394,10 +1399,11 @@ int sst_hsw_device_set_config(struct sst_hsw *hsw,
 
         trace_hsw_device_config_req(&config);
 
-        header = IPC_GLB_TYPE(IPC_GLB_SET_DEVICE_FORMATS);
+        request.header = IPC_GLB_TYPE(IPC_GLB_SET_DEVICE_FORMATS);
+        request.data = &config;
+        request.size = sizeof(config);
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, &config,
-                sizeof(config), NULL, 0);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, NULL);
         if (ret < 0)
                 dev_err(hsw->dev, "error: set device formats failed\n");
 
@@ -1409,16 +1415,20 @@ EXPORT_SYMBOL_GPL(sst_hsw_device_set_config);
 int sst_hsw_dx_set_state(struct sst_hsw *hsw,
         enum sst_hsw_dx_state state, struct sst_hsw_ipc_dx_reply *dx)
 {
-        u32 header, state_;
+        struct sst_ipc_message request, reply = {0};
+        u32 state_;
         int ret, item;
 
-        header = IPC_GLB_TYPE(IPC_GLB_ENTER_DX_STATE);
         state_ = state;
+        request.header = IPC_GLB_TYPE(IPC_GLB_ENTER_DX_STATE);
+        request.data = &state_;
+        request.size = sizeof(state_);
+        reply.data = dx;
+        reply.size = sizeof(*dx);
 
         trace_ipc_request("PM enter Dx state", state);
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc, header, &state_,
-                sizeof(state_), dx, sizeof(*dx));
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, &reply);
         if (ret < 0) {
                 dev_err(hsw->dev, "ipc: error set dx state %d failed\n", state);
                 return ret;
@@ -1878,7 +1888,7 @@ int sst_hsw_module_enable(struct sst_hsw *hsw,
         u32 module_id, u32 instance_id)
 {
         int ret;
-        u32 header = 0;
+        struct sst_ipc_message request;
         struct sst_hsw_ipc_module_config config;
         struct sst_module *module;
         struct sst_module_runtime *runtime;
@@ -1907,10 +1917,10 @@ int sst_hsw_module_enable(struct sst_hsw *hsw,
                 return -ENXIO;
         }
 
-        header = IPC_GLB_TYPE(IPC_GLB_MODULE_OPERATION) |
+        request.header = IPC_GLB_TYPE(IPC_GLB_MODULE_OPERATION) |
                         IPC_MODULE_OPERATION(IPC_MODULE_ENABLE) |
                         IPC_MODULE_ID(module_id);
-        dev_dbg(dev, "module enable header: %x\n", header);
+        dev_dbg(dev, "module enable header: %x\n", (u32)request.header);
 
         config.map.module_entries_count = 1;
         config.map.module_entries[0].module_id = module->id;
@@ -1932,8 +1942,9 @@ int sst_hsw_module_enable(struct sst_hsw *hsw,
                 config.scratch_mem.size, config.scratch_mem.offset,
                 config.map.module_entries[0].entry_point);
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc, header,
-                        &config, sizeof(config), NULL, 0);
+        request.data = &config;
+        request.size = sizeof(config);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, NULL);
         if (ret < 0)
                 dev_err(dev, "ipc: module enable failed - %d\n", ret);
         else
@@ -1946,7 +1957,7 @@ int sst_hsw_module_disable(struct sst_hsw *hsw,
         u32 module_id, u32 instance_id)
 {
         int ret;
-        u32 header;
+        struct sst_ipc_message request = {0};
         struct sst_module *module;
         struct device *dev = hsw->dev;
         struct sst_dsp *dsp = hsw->dsp;
@@ -1967,11 +1978,11 @@ int sst_hsw_module_disable(struct sst_hsw *hsw,
                 return -ENXIO;
         }
 
-        header = IPC_GLB_TYPE(IPC_GLB_MODULE_OPERATION) |
+        request.header = IPC_GLB_TYPE(IPC_GLB_MODULE_OPERATION) |
                         IPC_MODULE_OPERATION(IPC_MODULE_DISABLE) |
                         IPC_MODULE_ID(module_id);
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc, header,  NULL, 0, NULL, 0);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, NULL);
         if (ret < 0)
                 dev_err(dev, "module disable failed - %d\n", ret);
         else
@@ -1985,15 +1996,16 @@ int sst_hsw_module_set_param(struct sst_hsw *hsw,
         u32 param_size, char *param)
 {
         int ret;
-        u32 header = 0;
-        u32 payload_size = 0, transfer_parameter_size = 0;
+        struct sst_ipc_message request = {0};
+        u32 payload_size = 0;
         struct sst_hsw_transfer_parameter *parameter;
         struct device *dev = hsw->dev;
 
-        header = IPC_GLB_TYPE(IPC_GLB_MODULE_OPERATION) |
+        request.header = IPC_GLB_TYPE(IPC_GLB_MODULE_OPERATION) |
                         IPC_MODULE_OPERATION(IPC_MODULE_SET_PARAMETER) |
                         IPC_MODULE_ID(module_id);
-        dev_dbg(dev, "sst_hsw_module_set_param header=%x\n", header);
+        dev_dbg(dev, "sst_hsw_module_set_param header=%x\n",
+                        (u32)request.header);
 
         payload_size = param_size +
                 sizeof(struct sst_hsw_transfer_parameter) -
@@ -2003,14 +2015,14 @@ int sst_hsw_module_set_param(struct sst_hsw *hsw,
 
         if (payload_size <= SST_HSW_IPC_MAX_SHORT_PARAMETER_SIZE) {
                 /* short parameter, mailbox can contain data */
-                dev_dbg(dev, "transfer parameter size : %d\n",
-                        transfer_parameter_size);
+                dev_dbg(dev, "transfer parameter size : %zu\n",
+                        request.size);
 
-                transfer_parameter_size = ALIGN(payload_size, 4);
-                dev_dbg(dev, "transfer parameter aligned size : %d\n",
-                        transfer_parameter_size);
+                request.size = ALIGN(payload_size, 4);
+                dev_dbg(dev, "transfer parameter aligned size : %zu\n",
+                        request.size);
 
-                parameter = kzalloc(transfer_parameter_size, GFP_KERNEL);
+                parameter = kzalloc(request.size, GFP_KERNEL);
                 if (parameter == NULL)
                         return -ENOMEM;
 
@@ -2022,9 +2034,9 @@ int sst_hsw_module_set_param(struct sst_hsw *hsw,
 
         parameter->parameter_id = parameter_id;
         parameter->data_size = param_size;
+        request.data = parameter;
 
-        ret = sst_ipc_tx_message_wait(&hsw->ipc, header,
-                parameter, transfer_parameter_size , NULL, 0);
+        ret = sst_ipc_tx_message_wait(&hsw->ipc, request, NULL);
         if (ret < 0)
                 dev_err(dev, "ipc: module set parameter failed - %d\n", ret);
 
@@ -2041,8 +2053,8 @@ static struct sst_dsp_device hsw_dev = {
 static void hsw_tx_msg(struct sst_generic_ipc *ipc, struct ipc_message *msg)
 {
         /* send the message */
-        sst_dsp_outbox_write(ipc->dsp, msg->tx_data, msg->tx_size);
-        sst_dsp_ipc_msg_tx(ipc->dsp, msg->header);
+        sst_dsp_outbox_write(ipc->dsp, msg->tx.data, msg->tx.size);
+        sst_dsp_ipc_msg_tx(ipc->dsp, msg->tx.header);
 }
 
 static void hsw_shim_dbg(struct sst_generic_ipc *ipc, const char *text)
@@ -2063,7 +2075,7 @@ static void hsw_shim_dbg(struct sst_generic_ipc *ipc, const char *text)
 static void hsw_tx_data_copy(struct ipc_message *msg, char *tx_data,
         size_t tx_size)
 {
-        memcpy(msg->tx_data, tx_data, tx_size);
+        memcpy(msg->tx.data, tx_data, tx_size);
 }
 
 static u64 hsw_reply_msg_match(u64 header, u64 *mask)
diff --git a/sound/soc/intel/skylake/Makefile b/sound/soc/intel/skylake/Makefile
index 86f6e1d801af..48544ff1a3e6 100644
--- a/sound/soc/intel/skylake/Makefile
+++ b/sound/soc/intel/skylake/Makefile
@@ -1,6 +1,7 @@
 # SPDX-License-Identifier: GPL-2.0
-snd-soc-skl-objs := skl.o skl-pcm.o skl-nhlt.o skl-messages.o \
-skl-topology.o
+snd-soc-skl-objs := skl.o skl-pcm.o skl-nhlt.o skl-messages.o skl-topology.o \
+                skl-sst-ipc.o skl-sst-dsp.o cnl-sst-dsp.o skl-sst-cldma.o \
+                skl-sst.o bxt-sst.o cnl-sst.o skl-sst-utils.o
 
 ifdef CONFIG_DEBUG_FS
   snd-soc-skl-objs += skl-debug.o
@@ -8,13 +9,6 @@ endif
 
 obj-$(CONFIG_SND_SOC_INTEL_SKYLAKE) += snd-soc-skl.o
 
-# Skylake IPC Support
-snd-soc-skl-ipc-objs := skl-sst-ipc.o skl-sst-dsp.o cnl-sst-dsp.o \
-                skl-sst-cldma.o skl-sst.o bxt-sst.o cnl-sst.o \
-                skl-sst-utils.o
-
-obj-$(CONFIG_SND_SOC_INTEL_SKYLAKE) += snd-soc-skl-ipc.o
-
 #Skylake Clock device support
 snd-soc-skl-ssp-clk-objs := skl-ssp-clk.o
 
diff --git a/sound/soc/intel/skylake/bxt-sst.c b/sound/soc/intel/skylake/bxt-sst.c
index 46d5159cf905..92a82e6b5fe6 100644
--- a/sound/soc/intel/skylake/bxt-sst.c
+++ b/sound/soc/intel/skylake/bxt-sst.c
@@ -14,7 +14,7 @@
 
 #include "../common/sst-dsp.h"
 #include "../common/sst-dsp-priv.h"
-#include "skl-sst-ipc.h"
+#include "skl.h"
 
 #define BXT_BASEFW_TIMEOUT      3000
 #define BXT_INIT_TIMEOUT        300
@@ -49,7 +49,7 @@ static int
 bxt_load_library(struct sst_dsp *ctx, struct skl_lib_info *linfo, int lib_count)
 {
         struct snd_dma_buffer dmab;
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         struct firmware stripped_fw;
         int ret = 0, i, dma_id, stream_tag;
 
@@ -184,7 +184,7 @@ static int sst_transfer_fw_host_dma(struct sst_dsp *ctx)
 static int bxt_load_base_firmware(struct sst_dsp *ctx)
 {
         struct firmware stripped_fw;
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         int ret, i;
 
         if (ctx->fw == NULL) {
@@ -268,7 +268,7 @@ sst_load_base_firmware_failed:
  */
 static int bxt_d0i3_target_state(struct sst_dsp *ctx)
 {
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         struct skl_d0i3_data *d0i3 = &skl->d0i3;
 
         if (skl->cores.state[SKL_DSP_CORE0_ID] != SKL_DSP_RUNNING)
@@ -288,8 +288,8 @@ static void bxt_set_dsp_D0i3(struct work_struct *work)
 {
         int ret;
         struct skl_ipc_d0ix_msg msg;
-        struct skl_sst *skl = container_of(work,
-                        struct skl_sst, d0i3.work.work);
+        struct skl_dev *skl = container_of(work,
+                        struct skl_dev, d0i3.work.work);
         struct sst_dsp *ctx = skl->dsp;
         struct skl_d0i3_data *d0i3 = &skl->d0i3;
         int target_state;
@@ -331,7 +331,7 @@ static void bxt_set_dsp_D0i3(struct work_struct *work)
 
 static int bxt_schedule_dsp_D0i3(struct sst_dsp *ctx)
 {
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         struct skl_d0i3_data *d0i3 = &skl->d0i3;
 
         /* Schedule D0i3 only if the usecase ref counts are appropriate */
@@ -350,7 +350,7 @@ static int bxt_set_dsp_D0i0(struct sst_dsp *ctx)
 {
         int ret;
         struct skl_ipc_d0ix_msg msg;
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
 
         dev_dbg(ctx->dev, "In %s:\n", __func__);
 
@@ -389,7 +389,7 @@ static int bxt_set_dsp_D0i0(struct sst_dsp *ctx)
 
 static int bxt_set_dsp_D0(struct sst_dsp *ctx, unsigned int core_id)
 {
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         int ret;
         struct skl_ipc_dxstate_info dx;
         unsigned int core_mask = SKL_DSP_CORE_MASK(core_id);
@@ -486,7 +486,7 @@ static int bxt_set_dsp_D3(struct sst_dsp *ctx, unsigned int core_id)
 {
         int ret;
         struct skl_ipc_dxstate_info dx;
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         unsigned int core_mask = SKL_DSP_CORE_MASK(core_id);
 
         dx.core_mask = core_mask;
@@ -548,9 +548,9 @@ static struct sst_dsp_device skl_dev = {
 
 int bxt_sst_dsp_init(struct device *dev, void __iomem *mmio_base, int irq,
                         const char *fw_name, struct skl_dsp_loader_ops dsp_ops,
-                        struct skl_sst **dsp)
+                        struct skl_dev **dsp)
 {
-        struct skl_sst *skl;
+        struct skl_dev *skl;
         struct sst_dsp *sst;
         int ret;
 
@@ -591,10 +591,10 @@ int bxt_sst_dsp_init(struct device *dev, void __iomem *mmio_base, int irq,
 }
 EXPORT_SYMBOL_GPL(bxt_sst_dsp_init);
 
-int bxt_sst_init_fw(struct device *dev, struct skl_sst *ctx)
+int bxt_sst_init_fw(struct device *dev, struct skl_dev *skl)
 {
         int ret;
-        struct sst_dsp *sst = ctx->dsp;
+        struct sst_dsp *sst = skl->dsp;
 
         ret = sst->fw_ops.load_fw(sst);
         if (ret < 0) {
@@ -604,29 +604,29 @@ int bxt_sst_init_fw(struct device *dev, struct skl_sst *ctx)
 
         skl_dsp_init_core_state(sst);
 
-        if (ctx->lib_count > 1) {
-                ret = sst->fw_ops.load_library(sst, ctx->lib_info,
-                                                ctx->lib_count);
+        if (skl->lib_count > 1) {
+                ret = sst->fw_ops.load_library(sst, skl->lib_info,
+                                                skl->lib_count);
                 if (ret < 0) {
                         dev_err(dev, "Load Library failed : %x\n", ret);
                         return ret;
                 }
         }
-        ctx->is_first_boot = false;
+        skl->is_first_boot = false;
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(bxt_sst_init_fw);
 
-void bxt_sst_dsp_cleanup(struct device *dev, struct skl_sst *ctx)
+void bxt_sst_dsp_cleanup(struct device *dev, struct skl_dev *skl)
 {
 
-        skl_release_library(ctx->lib_info, ctx->lib_count);
-        if (ctx->dsp->fw)
-                release_firmware(ctx->dsp->fw);
-        skl_freeup_uuid_list(ctx);
-        skl_ipc_free(&ctx->ipc);
-        ctx->dsp->ops->free(ctx->dsp);
+        skl_release_library(skl->lib_info, skl->lib_count);
+        if (skl->dsp->fw)
+                release_firmware(skl->dsp->fw);
+        skl_freeup_uuid_list(skl);
+        skl_ipc_free(&skl->ipc);
+        skl->dsp->ops->free(skl->dsp);
 }
 EXPORT_SYMBOL_GPL(bxt_sst_dsp_cleanup);
 
diff --git a/sound/soc/intel/skylake/cnl-sst-dsp.h b/sound/soc/intel/skylake/cnl-sst-dsp.h
index 426515faab52..7bd4d2a8fdfa 100644
--- a/sound/soc/intel/skylake/cnl-sst-dsp.h
+++ b/sound/soc/intel/skylake/cnl-sst-dsp.h
@@ -9,7 +9,6 @@
 #define __CNL_SST_DSP_H__
 
 struct sst_dsp;
-struct skl_sst;
 struct sst_dsp_device;
 struct sst_generic_ipc;
 
@@ -97,8 +96,8 @@ void cnl_ipc_free(struct sst_generic_ipc *ipc);
 
 int cnl_sst_dsp_init(struct device *dev, void __iomem *mmio_base, int irq,
                      const char *fw_name, struct skl_dsp_loader_ops dsp_ops,
-                     struct skl_sst **dsp);
-int cnl_sst_init_fw(struct device *dev, struct skl_sst *ctx);
-void cnl_sst_dsp_cleanup(struct device *dev, struct skl_sst *ctx);
+                     struct skl_dev **dsp);
+int cnl_sst_init_fw(struct device *dev, struct skl_dev *skl);
+void cnl_sst_dsp_cleanup(struct device *dev, struct skl_dev *skl);
 
 #endif /*__CNL_SST_DSP_H__*/
diff --git a/sound/soc/intel/skylake/cnl-sst.c b/sound/soc/intel/skylake/cnl-sst.c
index f2c09fa6ea40..4f64f097e9ae 100644
--- a/sound/soc/intel/skylake/cnl-sst.c
+++ b/sound/soc/intel/skylake/cnl-sst.c
@@ -24,8 +24,7 @@
 #include "../common/sst-dsp-priv.h"
 #include "../common/sst-ipc.h"
 #include "cnl-sst-dsp.h"
-#include "skl-sst-dsp.h"
-#include "skl-sst-ipc.h"
+#include "skl.h"
 
 #define CNL_FW_ROM_INIT         0x1
 #define CNL_FW_INIT             0x5
@@ -109,7 +108,7 @@ static int sst_transfer_fw_host_dma(struct sst_dsp *ctx)
 static int cnl_load_base_firmware(struct sst_dsp *ctx)
 {
         struct firmware stripped_fw;
-        struct skl_sst *cnl = ctx->thread_context;
+        struct skl_dev *cnl = ctx->thread_context;
         int ret;
 
         if (!ctx->fw) {
@@ -167,7 +166,7 @@ cnl_load_base_firmware_failed:
 
 static int cnl_set_dsp_D0(struct sst_dsp *ctx, unsigned int core_id)
 {
-        struct skl_sst *cnl = ctx->thread_context;
+        struct skl_dev *cnl = ctx->thread_context;
         unsigned int core_mask = SKL_DSP_CORE_MASK(core_id);
         struct skl_ipc_dxstate_info dx;
         int ret;
@@ -229,7 +228,7 @@ err:
 
 static int cnl_set_dsp_D3(struct sst_dsp *ctx, unsigned int core_id)
 {
-        struct skl_sst *cnl = ctx->thread_context;
+        struct skl_dev *cnl = ctx->thread_context;
         unsigned int core_mask = SKL_DSP_CORE_MASK(core_id);
         struct skl_ipc_dxstate_info dx;
         int ret;
@@ -293,7 +292,7 @@ static struct sst_ops cnl_ops = {
 static irqreturn_t cnl_dsp_irq_thread_handler(int irq, void *context)
 {
         struct sst_dsp *dsp = context;
-        struct skl_sst *cnl = sst_dsp_get_thread_context(dsp);
+        struct skl_dev *cnl = sst_dsp_get_thread_context(dsp);
         struct sst_generic_ipc *ipc = &cnl->ipc;
         struct skl_ipc_header header = {0};
         u32 hipcida, hipctdr, hipctdd;
@@ -367,10 +366,10 @@ static struct sst_dsp_device cnl_dev = {
 
 static void cnl_ipc_tx_msg(struct sst_generic_ipc *ipc, struct ipc_message *msg)
 {
-        struct skl_ipc_header *header = (struct skl_ipc_header *)(&msg->header);
+        struct skl_ipc_header *header = (struct skl_ipc_header *)(&msg->tx.header);
 
-        if (msg->tx_size)
-                sst_dsp_outbox_write(ipc->dsp, msg->tx_data, msg->tx_size);
+        if (msg->tx.size)
+                sst_dsp_outbox_write(ipc->dsp, msg->tx.data, msg->tx.size);
         sst_dsp_shim_write_unlocked(ipc->dsp, CNL_ADSP_REG_HIPCIDD,
                                     header->extension);
         sst_dsp_shim_write_unlocked(ipc->dsp, CNL_ADSP_REG_HIPCIDR,
@@ -386,7 +385,7 @@ static bool cnl_ipc_is_dsp_busy(struct sst_dsp *dsp)
         return (hipcidr & CNL_ADSP_REG_HIPCIDR_BUSY);
 }
 
-static int cnl_ipc_init(struct device *dev, struct skl_sst *cnl)
+static int cnl_ipc_init(struct device *dev, struct skl_dev *cnl)
 {
         struct sst_generic_ipc *ipc;
         int err;
@@ -415,9 +414,9 @@ static int cnl_ipc_init(struct device *dev, struct skl_sst *cnl)
 
 int cnl_sst_dsp_init(struct device *dev, void __iomem *mmio_base, int irq,
                      const char *fw_name, struct skl_dsp_loader_ops dsp_ops,
-                     struct skl_sst **dsp)
+                     struct skl_dev **dsp)
 {
-        struct skl_sst *cnl;
+        struct skl_dev *cnl;
         struct sst_dsp *sst;
         int ret;
 
@@ -454,12 +453,12 @@ int cnl_sst_dsp_init(struct device *dev, void __iomem *mmio_base, int irq,
 }
 EXPORT_SYMBOL_GPL(cnl_sst_dsp_init);
 
-int cnl_sst_init_fw(struct device *dev, struct skl_sst *ctx)
+int cnl_sst_init_fw(struct device *dev, struct skl_dev *skl)
 {
         int ret;
-        struct sst_dsp *sst = ctx->dsp;
+        struct sst_dsp *sst = skl->dsp;
 
-        ret = ctx->dsp->fw_ops.load_fw(sst);
+        ret = skl->dsp->fw_ops.load_fw(sst);
         if (ret < 0) {
                 dev_err(dev, "load base fw failed: %d", ret);
                 return ret;
@@ -467,21 +466,21 @@ int cnl_sst_init_fw(struct device *dev, struct skl_sst *ctx)
 
         skl_dsp_init_core_state(sst);
 
-        ctx->is_first_boot = false;
+        skl->is_first_boot = false;
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(cnl_sst_init_fw);
 
-void cnl_sst_dsp_cleanup(struct device *dev, struct skl_sst *ctx)
+void cnl_sst_dsp_cleanup(struct device *dev, struct skl_dev *skl)
 {
-        if (ctx->dsp->fw)
-                release_firmware(ctx->dsp->fw);
+        if (skl->dsp->fw)
+                release_firmware(skl->dsp->fw);
 
-        skl_freeup_uuid_list(ctx);
-        cnl_ipc_free(&ctx->ipc);
+        skl_freeup_uuid_list(skl);
+        cnl_ipc_free(&skl->ipc);
 
-        ctx->dsp->ops->free(ctx->dsp);
+        skl->dsp->ops->free(skl->dsp);
 }
 EXPORT_SYMBOL_GPL(cnl_sst_dsp_cleanup);
 
diff --git a/sound/soc/intel/skylake/skl-debug.c b/sound/soc/intel/skylake/skl-debug.c
index b9b4a72a4334..3466675f2678 100644
--- a/sound/soc/intel/skylake/skl-debug.c
+++ b/sound/soc/intel/skylake/skl-debug.c
@@ -20,7 +20,7 @@
 #define FW_REG_SIZE     0x60
 
 struct skl_debug {
-        struct skl *skl;
+        struct skl_dev *skl;
         struct device *dev;
 
         struct dentry *fs;
@@ -66,6 +66,8 @@ static ssize_t module_read(struct file *file, char __user *user_buf,
                            size_t count, loff_t *ppos)
 {
         struct skl_module_cfg *mconfig = file->private_data;
+        struct skl_module *module = mconfig->module;
+        struct skl_module_res *res = &module->resources[mconfig->res_idx];
         char *buf;
         ssize_t ret;
 
@@ -79,8 +81,8 @@ static ssize_t module_read(struct file *file, char __user *user_buf,
                         mconfig->id.pvt_id);
 
         ret += snprintf(buf + ret, MOD_BUF - ret,
-                        "Resources:\n\tMCPS %#x\n\tIBS %#x\n\tOBS %#x\t\n",
-                        mconfig->mcps, mconfig->ibs, mconfig->obs);
+                        "Resources:\n\tCPC %#x\n\tIBS %#x\n\tOBS %#x\t\n",
+                        res->cpc, res->ibs, res->obs);
 
         ret += snprintf(buf + ret, MOD_BUF - ret,
                         "Module data:\n\tCore %d\n\tIn queue %d\n\t"
@@ -162,17 +164,15 @@ void skl_debug_init_module(struct skl_debug *d,
                         struct snd_soc_dapm_widget *w,
                         struct skl_module_cfg *mconfig)
 {
-        if (!debugfs_create_file(w->name, 0444,
-                                d->modules, mconfig,
-                                &mcfg_fops))
-                dev_err(d->dev, "%s: module debugfs init failed\n", w->name);
+        debugfs_create_file(w->name, 0444, d->modules, mconfig,
+                            &mcfg_fops);
 }
 
 static ssize_t fw_softreg_read(struct file *file, char __user *user_buf,
                                size_t count, loff_t *ppos)
 {
         struct skl_debug *d = file->private_data;
-        struct sst_dsp *sst = d->skl->skl_sst->dsp;
+        struct sst_dsp *sst = d->skl->dsp;
         size_t w0_stat_sz = sst->addr.w0_stat_sz;
         void __iomem *in_base = sst->mailbox.in_base;
         void __iomem *fw_reg_addr;
@@ -188,7 +188,7 @@ static ssize_t fw_softreg_read(struct file *file, char __user *user_buf,
         memset(d->fw_read_buff, 0, FW_REG_BUF);
 
         if (w0_stat_sz > 0)
-                __iowrite32_copy(d->fw_read_buff, fw_reg_addr, w0_stat_sz >> 2);
+                __ioread32_copy(d->fw_read_buff, fw_reg_addr, w0_stat_sz >> 2);
 
         for (offset = 0; offset < FW_REG_SIZE; offset += 16) {
                 ret += snprintf(tmp + ret, FW_REG_BUF - ret, "%#.4x: ", offset);
@@ -213,7 +213,7 @@ static const struct file_operations soft_regs_ctrl_fops = {
         .llseek = default_llseek,
 };
 
-struct skl_debug *skl_debugfs_init(struct skl *skl)
+struct skl_debug *skl_debugfs_init(struct skl_dev *skl)
 {
         struct skl_debug *d;
 
@@ -222,37 +222,21 @@ struct skl_debug *skl_debugfs_init(struct skl *skl)
                 return NULL;
 
         /* create the debugfs dir with platform component's debugfs as parent */
-        d->fs = debugfs_create_dir("dsp",
-                                   skl->component->debugfs_root);
-        if (IS_ERR(d->fs) || !d->fs) {
-                dev_err(&skl->pci->dev, "debugfs root creation failed\n");
-                return NULL;
-        }
+        d->fs = debugfs_create_dir("dsp", skl->component->debugfs_root);
 
         d->skl = skl;
         d->dev = &skl->pci->dev;
 
         /* now create the module dir */
         d->modules = debugfs_create_dir("modules", d->fs);
-        if (IS_ERR(d->modules) || !d->modules) {
-                dev_err(&skl->pci->dev, "modules debugfs create failed\n");
-                goto err;
-        }
 
-        if (!debugfs_create_file("fw_soft_regs_rd", 0444, d->fs, d,
-                                 &soft_regs_ctrl_fops)) {
-                dev_err(d->dev, "fw soft regs control debugfs init failed\n");
-                goto err;
-        }
+        debugfs_create_file("fw_soft_regs_rd", 0444, d->fs, d,
+                            &soft_regs_ctrl_fops);
 
         return d;
-
-err:
-        debugfs_remove_recursive(d->fs);
-        return NULL;
 }
 
-void skl_debugfs_exit(struct skl *skl)
+void skl_debugfs_exit(struct skl_dev *skl)
 {
         struct skl_debug *d = skl->debugfs;
 
diff --git a/sound/soc/intel/skylake/skl-messages.c b/sound/soc/intel/skylake/skl-messages.c
index febc070839e0..476ef1897961 100644
--- a/sound/soc/intel/skylake/skl-messages.c
+++ b/sound/soc/intel/skylake/skl-messages.c
@@ -25,29 +25,18 @@
 static int skl_alloc_dma_buf(struct device *dev,
                 struct snd_dma_buffer *dmab, size_t size)
 {
-        struct hdac_bus *bus = dev_get_drvdata(dev);
-
-        if (!bus)
-                return -ENODEV;
-
-        return  bus->io_ops->dma_alloc_pages(bus, SNDRV_DMA_TYPE_DEV, size, dmab);
+        return snd_dma_alloc_pages(SNDRV_DMA_TYPE_DEV, dev, size, dmab);
 }
 
 static int skl_free_dma_buf(struct device *dev, struct snd_dma_buffer *dmab)
 {
-        struct hdac_bus *bus = dev_get_drvdata(dev);
-
-        if (!bus)
-                return -ENODEV;
-
-        bus->io_ops->dma_free_pages(bus, dmab);
-
+        snd_dma_free_pages(dmab);
         return 0;
 }
 
 #define SKL_ASTATE_PARAM_ID     4
 
-void skl_dsp_set_astate_cfg(struct skl_sst *ctx, u32 cnt, void *data)
+void skl_dsp_set_astate_cfg(struct skl_dev *skl, u32 cnt, void *data)
 {
         struct skl_ipc_large_config_msg msg = {0};
 
@@ -55,25 +44,7 @@ void skl_dsp_set_astate_cfg(struct skl_sst *ctx, u32 cnt, void *data)
         msg.param_data_size = (cnt * sizeof(struct skl_astate_param) +
                                 sizeof(cnt));
 
-        skl_ipc_set_large_config(&ctx->ipc, &msg, data);
-}
-
-#define NOTIFICATION_PARAM_ID 3
-#define NOTIFICATION_MASK 0xf
-
-/* disable notfication for underruns/overruns from firmware module */
-void skl_dsp_enable_notification(struct skl_sst *ctx, bool enable)
-{
-        struct notification_mask mask;
-        struct skl_ipc_large_config_msg msg = {0};
-
-        mask.notify = NOTIFICATION_MASK;
-        mask.enable = enable;
-
-        msg.large_param_id = NOTIFICATION_PARAM_ID;
-        msg.param_data_size = sizeof(mask);
-
-        skl_ipc_set_large_config(&ctx->ipc, &msg, (u32 *)&mask);
+        skl_ipc_set_large_config(&skl->ipc, &msg, data);
 }
 
 static int skl_dsp_setup_spib(struct device *dev, unsigned int size,
@@ -277,7 +248,7 @@ const struct skl_dsp_ops *skl_get_dsp_ops(int pci_id)
         return NULL;
 }
 
-int skl_init_dsp(struct skl *skl)
+int skl_init_dsp(struct skl_dev *skl)
 {
         void __iomem *mmio_base;
         struct hdac_bus *bus = skl_to_bus(skl);
@@ -307,13 +278,13 @@ int skl_init_dsp(struct skl *skl)
         loader_ops = ops->loader_ops();
         ret = ops->init(bus->dev, mmio_base, irq,
                                 skl->fw_name, loader_ops,
-                                &skl->skl_sst);
+                                &skl);
 
         if (ret < 0)
                 goto unmap_mmio;
 
-        skl->skl_sst->dsp_ops = ops;
-        cores = &skl->skl_sst->cores;
+        skl->dsp_ops = ops;
+        cores = &skl->cores;
         cores->count = ops->num_cores;
 
         cores->state = kcalloc(cores->count, sizeof(*cores->state), GFP_KERNEL);
@@ -342,21 +313,20 @@ unmap_mmio:
         return ret;
 }
 
-int skl_free_dsp(struct skl *skl)
+int skl_free_dsp(struct skl_dev *skl)
 {
         struct hdac_bus *bus = skl_to_bus(skl);
-        struct skl_sst *ctx = skl->skl_sst;
 
         /* disable  ppcap interrupt */
         snd_hdac_ext_bus_ppcap_int_enable(bus, false);
 
-        ctx->dsp_ops->cleanup(bus->dev, ctx);
+        skl->dsp_ops->cleanup(bus->dev, skl);
 
-        kfree(ctx->cores.state);
-        kfree(ctx->cores.usage_count);
+        kfree(skl->cores.state);
+        kfree(skl->cores.usage_count);
 
-        if (ctx->dsp->addr.lpe)
-                iounmap(ctx->dsp->addr.lpe);
+        if (skl->dsp->addr.lpe)
+                iounmap(skl->dsp->addr.lpe);
 
         return 0;
 }
@@ -368,15 +338,14 @@ int skl_free_dsp(struct skl *skl)
  * mode during system suspend. In the case of normal suspend, cancel
  * any pending D0i3 work.
  */
-int skl_suspend_late_dsp(struct skl *skl)
+int skl_suspend_late_dsp(struct skl_dev *skl)
 {
-        struct skl_sst *ctx = skl->skl_sst;
         struct delayed_work *dwork;
 
-        if (!ctx)
+        if (!skl)
                 return 0;
 
-        dwork = &ctx->d0i3.work;
+        dwork = &skl->d0i3.work;
 
         if (dwork->work.func) {
                 if (skl->supend_active)
@@ -388,9 +357,8 @@ int skl_suspend_late_dsp(struct skl *skl)
         return 0;
 }
 
-int skl_suspend_dsp(struct skl *skl)
+int skl_suspend_dsp(struct skl_dev *skl)
 {
-        struct skl_sst *ctx = skl->skl_sst;
         struct hdac_bus *bus = skl_to_bus(skl);
         int ret;
 
@@ -398,7 +366,7 @@ int skl_suspend_dsp(struct skl *skl)
         if (!bus->ppcap)
                 return 0;
 
-        ret = skl_dsp_sleep(ctx->dsp);
+        ret = skl_dsp_sleep(skl->dsp);
         if (ret < 0)
                 return ret;
 
@@ -409,9 +377,8 @@ int skl_suspend_dsp(struct skl *skl)
         return 0;
 }
 
-int skl_resume_dsp(struct skl *skl)
+int skl_resume_dsp(struct skl_dev *skl)
 {
-        struct skl_sst *ctx = skl->skl_sst;
         struct hdac_bus *bus = skl_to_bus(skl);
         int ret;
 
@@ -424,26 +391,24 @@ int skl_resume_dsp(struct skl *skl)
         snd_hdac_ext_bus_ppcap_int_enable(bus, true);
 
         /* check if DSP 1st boot is done */
-        if (skl->skl_sst->is_first_boot)
+        if (skl->is_first_boot)
                 return 0;
 
         /*
          * Disable dynamic clock and power gating during firmware
          * and library download
          */
-        ctx->enable_miscbdcge(ctx->dev, false);
-        ctx->clock_power_gating(ctx->dev, false);
+        skl->enable_miscbdcge(skl->dev, false);
+        skl->clock_power_gating(skl->dev, false);
 
-        ret = skl_dsp_wake(ctx->dsp);
-        ctx->enable_miscbdcge(ctx->dev, true);
-        ctx->clock_power_gating(ctx->dev, true);
+        ret = skl_dsp_wake(skl->dsp);
+        skl->enable_miscbdcge(skl->dev, true);
+        skl->clock_power_gating(skl->dev, true);
         if (ret < 0)
                 return ret;
 
-        skl_dsp_enable_notification(skl->skl_sst, false);
-
         if (skl->cfg.astate_cfg != NULL) {
-                skl_dsp_set_astate_cfg(skl->skl_sst, skl->cfg.astate_cfg->count,
+                skl_dsp_set_astate_cfg(skl, skl->cfg.astate_cfg->count,
                                         skl->cfg.astate_cfg);
         }
         return ret;
@@ -476,7 +441,7 @@ enum skl_bitdepth skl_get_bit_depth(int params)
  * which are read from widget information passed through topology binary
  * This is send when we create a module with INIT_INSTANCE IPC msg
  */
-static void skl_set_base_module_format(struct skl_sst *ctx,
+static void skl_set_base_module_format(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig,
                         struct skl_base_cfg *base_cfg)
 {
@@ -493,7 +458,7 @@ static void skl_set_base_module_format(struct skl_sst *ctx,
         base_cfg->audio_fmt.ch_cfg = format->ch_cfg;
         base_cfg->audio_fmt.sample_type = format->sample_type;
 
-        dev_dbg(ctx->dev, "bit_depth=%x valid_bd=%x ch_config=%x\n",
+        dev_dbg(skl->dev, "bit_depth=%x valid_bd=%x ch_config=%x\n",
                         format->bit_depth, format->valid_bit_depth,
                         format->ch_cfg);
 
@@ -501,7 +466,7 @@ static void skl_set_base_module_format(struct skl_sst *ctx,
 
         base_cfg->audio_fmt.interleaving = format->interleaving_style;
 
-        base_cfg->cps = res->cps;
+        base_cfg->cpc = res->cpc;
         base_cfg->ibs = res->ibs;
         base_cfg->obs = res->obs;
         base_cfg->is_pages = res->is_pages;
@@ -530,7 +495,7 @@ static void skl_copy_copier_caps(struct skl_module_cfg *mconfig,
  * Calculate the gatewat settings required for copier module, type of
  * gateway and index of gateway to use
  */
-static u32 skl_get_node_id(struct skl_sst *ctx,
+static u32 skl_get_node_id(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig)
 {
         union skl_connector_node_id node_id = {0};
@@ -587,16 +552,15 @@ static u32 skl_get_node_id(struct skl_sst *ctx,
         return node_id.val;
 }
 
-static void skl_setup_cpr_gateway_cfg(struct skl_sst *ctx,
+static void skl_setup_cpr_gateway_cfg(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig,
                         struct skl_cpr_cfg *cpr_mconfig)
 {
         u32 dma_io_buf;
         struct skl_module_res *res;
         int res_idx = mconfig->res_idx;
-        struct skl *skl = get_skl_ctx(ctx->dev);
 
-        cpr_mconfig->gtw_cfg.node_id = skl_get_node_id(ctx, mconfig);
+        cpr_mconfig->gtw_cfg.node_id = skl_get_node_id(skl, mconfig);
 
         if (cpr_mconfig->gtw_cfg.node_id == SKL_NON_GATEWAY_CPR_NODE_ID) {
                 cpr_mconfig->cpr_feature_mask = 0;
@@ -627,7 +591,7 @@ static void skl_setup_cpr_gateway_cfg(struct skl_sst *ctx,
                 break;
 
         default:
-                dev_warn(ctx->dev, "wrong connection type: %d\n",
+                dev_warn(skl->dev, "wrong connection type: %d\n",
                                 mconfig->hw_conn_type);
                 return;
         }
@@ -653,7 +617,7 @@ skip_buf_size_calc:
 #define DMA_CONTROL_ID 5
 #define DMA_I2S_BLOB_SIZE 21
 
-int skl_dsp_set_dma_control(struct skl_sst *ctx, u32 *caps,
+int skl_dsp_set_dma_control(struct skl_dev *skl, u32 *caps,
                                 u32 caps_size, u32 node_id)
 {
         struct skl_dma_control *dma_ctrl;
@@ -686,14 +650,14 @@ int skl_dsp_set_dma_control(struct skl_sst *ctx, u32 *caps,
 
         memcpy(dma_ctrl->config_data, caps, caps_size);
 
-        err = skl_ipc_set_large_config(&ctx->ipc, &msg, (u32 *)dma_ctrl);
+        err = skl_ipc_set_large_config(&skl->ipc, &msg, (u32 *)dma_ctrl);
 
         kfree(dma_ctrl);
         return err;
 }
 EXPORT_SYMBOL_GPL(skl_dsp_set_dma_control);
 
-static void skl_setup_out_format(struct skl_sst *ctx,
+static void skl_setup_out_format(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig,
                         struct skl_audio_data_format *out_fmt)
 {
@@ -711,7 +675,7 @@ static void skl_setup_out_format(struct skl_sst *ctx,
         out_fmt->interleaving = format->interleaving_style;
         out_fmt->sample_type = format->sample_type;
 
-        dev_dbg(ctx->dev, "copier out format chan=%d fre=%d bitdepth=%d\n",
+        dev_dbg(skl->dev, "copier out format chan=%d fre=%d bitdepth=%d\n",
                 out_fmt->number_of_channels, format->s_freq, format->bit_depth);
 }
 
@@ -720,7 +684,7 @@ static void skl_setup_out_format(struct skl_sst *ctx,
  * configuration and the target frequency as extra parameter passed as src
  * config
  */
-static void skl_set_src_format(struct skl_sst *ctx,
+static void skl_set_src_format(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig,
                         struct skl_src_module_cfg *src_mconfig)
 {
@@ -728,7 +692,7 @@ static void skl_set_src_format(struct skl_sst *ctx,
         struct skl_module_iface *iface = &module->formats[mconfig->fmt_idx];
         struct skl_module_fmt *fmt = &iface->outputs[0].fmt;
 
-        skl_set_base_module_format(ctx, mconfig,
+        skl_set_base_module_format(skl, mconfig,
                 (struct skl_base_cfg *)src_mconfig);
 
         src_mconfig->src_cfg = fmt->s_freq;
@@ -739,7 +703,7 @@ static void skl_set_src_format(struct skl_sst *ctx,
  * module configuration and channel configuration
  * It also take coefficients and now we have defaults applied here
  */
-static void skl_set_updown_mixer_format(struct skl_sst *ctx,
+static void skl_set_updown_mixer_format(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig,
                         struct skl_up_down_mixer_cfg *mixer_mconfig)
 {
@@ -747,7 +711,7 @@ static void skl_set_updown_mixer_format(struct skl_sst *ctx,
         struct skl_module_iface *iface = &module->formats[mconfig->fmt_idx];
         struct skl_module_fmt *fmt = &iface->outputs[0].fmt;
 
-        skl_set_base_module_format(ctx, mconfig,
+        skl_set_base_module_format(skl, mconfig,
                 (struct skl_base_cfg *)mixer_mconfig);
         mixer_mconfig->out_ch_cfg = fmt->ch_cfg;
         mixer_mconfig->ch_map = fmt->ch_map;
@@ -760,17 +724,17 @@ static void skl_set_updown_mixer_format(struct skl_sst *ctx,
  * format, gateway settings
  * copier_module_config is sent as input buffer with INIT_INSTANCE IPC msg
  */
-static void skl_set_copier_format(struct skl_sst *ctx,
+static void skl_set_copier_format(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig,
                         struct skl_cpr_cfg *cpr_mconfig)
 {
         struct skl_audio_data_format *out_fmt = &cpr_mconfig->out_fmt;
         struct skl_base_cfg *base_cfg = (struct skl_base_cfg *)cpr_mconfig;
 
-        skl_set_base_module_format(ctx, mconfig, base_cfg);
+        skl_set_base_module_format(skl, mconfig, base_cfg);
 
-        skl_setup_out_format(ctx, mconfig, out_fmt);
-        skl_setup_cpr_gateway_cfg(ctx, mconfig, cpr_mconfig);
+        skl_setup_out_format(skl, mconfig, out_fmt);
+        skl_setup_cpr_gateway_cfg(skl, mconfig, cpr_mconfig);
 }
 
 /*
@@ -778,13 +742,13 @@ static void skl_set_copier_format(struct skl_sst *ctx,
  * configuration and params
  */
 
-static void skl_set_algo_format(struct skl_sst *ctx,
+static void skl_set_algo_format(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig,
                         struct skl_algo_cfg *algo_mcfg)
 {
         struct skl_base_cfg *base_cfg = (struct skl_base_cfg *)algo_mcfg;
 
-        skl_set_base_module_format(ctx, mconfig, base_cfg);
+        skl_set_base_module_format(skl, mconfig, base_cfg);
 
         if (mconfig->formats_config.caps_size == 0)
                 return;
@@ -802,7 +766,7 @@ static void skl_set_algo_format(struct skl_sst *ctx,
  * Mic select module take base module configuration and out-format
  * configuration
  */
-static void skl_set_base_outfmt_format(struct skl_sst *ctx,
+static void skl_set_base_outfmt_format(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig,
                         struct skl_base_outfmt_cfg *base_outfmt_mcfg)
 {
@@ -810,11 +774,11 @@ static void skl_set_base_outfmt_format(struct skl_sst *ctx,
         struct skl_base_cfg *base_cfg =
                                 (struct skl_base_cfg *)base_outfmt_mcfg;
 
-        skl_set_base_module_format(ctx, mconfig, base_cfg);
-        skl_setup_out_format(ctx, mconfig, out_fmt);
+        skl_set_base_module_format(skl, mconfig, base_cfg);
+        skl_setup_out_format(skl, mconfig, out_fmt);
 }
 
-static u16 skl_get_module_param_size(struct skl_sst *ctx,
+static u16 skl_get_module_param_size(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig)
 {
         u16 param_size;
@@ -859,14 +823,14 @@ static u16 skl_get_module_param_size(struct skl_sst *ctx,
  * base module format configuration
  */
 
-static int skl_set_module_format(struct skl_sst *ctx,
+static int skl_set_module_format(struct skl_dev *skl,
                         struct skl_module_cfg *module_config,
                         u16 *module_config_size,
                         void **param_data)
 {
         u16 param_size;
 
-        param_size  = skl_get_module_param_size(ctx, module_config);
+        param_size  = skl_get_module_param_size(skl, module_config);
 
         *param_data = kzalloc(param_size, GFP_KERNEL);
         if (NULL == *param_data)
@@ -876,35 +840,36 @@ static int skl_set_module_format(struct skl_sst *ctx,
 
         switch (module_config->m_type) {
         case SKL_MODULE_TYPE_COPIER:
-                skl_set_copier_format(ctx, module_config, *param_data);
+                skl_set_copier_format(skl, module_config, *param_data);
                 break;
 
         case SKL_MODULE_TYPE_SRCINT:
-                skl_set_src_format(ctx, module_config, *param_data);
+                skl_set_src_format(skl, module_config, *param_data);
                 break;
 
         case SKL_MODULE_TYPE_UPDWMIX:
-                skl_set_updown_mixer_format(ctx, module_config, *param_data);
+                skl_set_updown_mixer_format(skl, module_config, *param_data);
                 break;
 
         case SKL_MODULE_TYPE_ALGO:
-                skl_set_algo_format(ctx, module_config, *param_data);
+                skl_set_algo_format(skl, module_config, *param_data);
                 break;
 
         case SKL_MODULE_TYPE_BASE_OUTFMT:
         case SKL_MODULE_TYPE_MIC_SELECT:
         case SKL_MODULE_TYPE_KPB:
-                skl_set_base_outfmt_format(ctx, module_config, *param_data);
+                skl_set_base_outfmt_format(skl, module_config, *param_data);
                 break;
 
         default:
-                skl_set_base_module_format(ctx, module_config, *param_data);
+                skl_set_base_module_format(skl, module_config, *param_data);
                 break;
 
         }
 
-        dev_dbg(ctx->dev, "Module type=%d config size: %d bytes\n",
-                        module_config->id.module_id, param_size);
+        dev_dbg(skl->dev, "Module type=%d id=%d config size: %d bytes\n",
+                        module_config->m_type, module_config->id.module_id,
+                        param_size);
         print_hex_dump_debug("Module params:", DUMP_PREFIX_OFFSET, 8, 4,
                         *param_data, param_size, false);
         return 0;
@@ -1004,7 +969,7 @@ static void skl_clear_module_state(struct skl_module_pin *mpin, int max,
  * We first calculate the module format, based on module type and then
  * invoke the DSP by sending IPC INIT_INSTANCE using ipc helper
  */
-int skl_init_module(struct skl_sst *ctx,
+int skl_init_module(struct skl_dev *skl,
                         struct skl_module_cfg *mconfig)
 {
         u16 module_config_size = 0;
@@ -1012,19 +977,19 @@ int skl_init_module(struct skl_sst *ctx,
         int ret;
         struct skl_ipc_init_instance_msg msg;
 
-        dev_dbg(ctx->dev, "%s: module_id = %d instance=%d\n", __func__,
+        dev_dbg(skl->dev, "%s: module_id = %d instance=%d\n", __func__,
                  mconfig->id.module_id, mconfig->id.pvt_id);
 
         if (mconfig->pipe->state != SKL_PIPE_CREATED) {
-                dev_err(ctx->dev, "Pipe not created state= %d pipe_id= %d\n",
+                dev_err(skl->dev, "Pipe not created state= %d pipe_id= %d\n",
                                  mconfig->pipe->state, mconfig->pipe->ppl_id);
                 return -EIO;
         }
 
-        ret = skl_set_module_format(ctx, mconfig,
+        ret = skl_set_module_format(skl, mconfig,
                         &module_config_size, &param_data);
         if (ret < 0) {
-                dev_err(ctx->dev, "Failed to set module format ret=%d\n", ret);
+                dev_err(skl->dev, "Failed to set module format ret=%d\n", ret);
                 return ret;
         }
 
@@ -1035,9 +1000,9 @@ int skl_init_module(struct skl_sst *ctx,
         msg.core_id = mconfig->core_id;
         msg.domain = mconfig->domain;
 
-        ret = skl_ipc_init_instance(&ctx->ipc, &msg, param_data);
+        ret = skl_ipc_init_instance(&skl->ipc, &msg, param_data);
         if (ret < 0) {
-                dev_err(ctx->dev, "Failed to init instance ret=%d\n", ret);
+                dev_err(skl->dev, "Failed to init instance ret=%d\n", ret);
                 kfree(param_data);
                 return ret;
         }
@@ -1046,15 +1011,15 @@ int skl_init_module(struct skl_sst *ctx,
         return ret;
 }
 
-static void skl_dump_bind_info(struct skl_sst *ctx, struct skl_module_cfg
+static void skl_dump_bind_info(struct skl_dev *skl, struct skl_module_cfg
         *src_module, struct skl_module_cfg *dst_module)
 {
-        dev_dbg(ctx->dev, "%s: src module_id = %d  src_instance=%d\n",
+        dev_dbg(skl->dev, "%s: src module_id = %d  src_instance=%d\n",
                 __func__, src_module->id.module_id, src_module->id.pvt_id);
-        dev_dbg(ctx->dev, "%s: dst_module=%d dst_instance=%d\n", __func__,
+        dev_dbg(skl->dev, "%s: dst_module=%d dst_instance=%d\n", __func__,
                  dst_module->id.module_id, dst_module->id.pvt_id);
 
-        dev_dbg(ctx->dev, "src_module state = %d dst module state = %d\n",
+        dev_dbg(skl->dev, "src_module state = %d dst module state = %d\n",
                 src_module->m_state, dst_module->m_state);
 }
 
@@ -1063,7 +1028,7 @@ static void skl_dump_bind_info(struct skl_sst *ctx, struct skl_module_cfg
  * it is already bind.
  * Find the pin allocated and unbind then using bind_unbind IPC
  */
-int skl_unbind_modules(struct skl_sst *ctx,
+int skl_unbind_modules(struct skl_dev *skl,
                         struct skl_module_cfg *src_mcfg,
                         struct skl_module_cfg *dst_mcfg)
 {
@@ -1075,7 +1040,7 @@ int skl_unbind_modules(struct skl_sst *ctx,
         int out_max = src_mcfg->module->max_output_pins;
         int src_index, dst_index, src_pin_state, dst_pin_state;
 
-        skl_dump_bind_info(ctx, src_mcfg, dst_mcfg);
+        skl_dump_bind_info(skl, src_mcfg, dst_mcfg);
 
         /* get src queue index */
         src_index = skl_get_queue_index(src_mcfg->m_out_pin, dst_id, out_max);
@@ -1104,7 +1069,7 @@ int skl_unbind_modules(struct skl_sst *ctx,
         msg.dst_instance_id = dst_mcfg->id.pvt_id;
         msg.bind = false;
 
-        ret = skl_ipc_bind_unbind(&ctx->ipc, &msg);
+        ret = skl_ipc_bind_unbind(&skl->ipc, &msg);
         if (!ret) {
                 /* free queue only if unbind is success */
                 skl_free_queue(src_mcfg->m_out_pin, src_index);
@@ -1142,7 +1107,7 @@ static void fill_pin_params(struct skl_audio_data_format *pin_fmt,
  * This function finds the pins and then sends bund_unbind IPC message to
  * DSP using IPC helper
  */
-int skl_bind_modules(struct skl_sst *ctx,
+int skl_bind_modules(struct skl_dev *skl,
                         struct skl_module_cfg *src_mcfg,
                         struct skl_module_cfg *dst_mcfg)
 {
@@ -1156,7 +1121,7 @@ int skl_bind_modules(struct skl_sst *ctx,
         struct skl_module *module;
         struct skl_module_iface *fmt;
 
-        skl_dump_bind_info(ctx, src_mcfg, dst_mcfg);
+        skl_dump_bind_info(skl, src_mcfg, dst_mcfg);
 
         if (src_mcfg->m_state < SKL_MODULE_INIT_DONE ||
                 dst_mcfg->m_state < SKL_MODULE_INIT_DONE)
@@ -1188,7 +1153,7 @@ int skl_bind_modules(struct skl_sst *ctx,
 
                 format = &fmt->outputs[src_index].fmt;
                 fill_pin_params(&(pin_fmt.dst_fmt), format);
-                ret = skl_set_module_params(ctx, (void *)&pin_fmt,
+                ret = skl_set_module_params(skl, (void *)&pin_fmt,
                                         sizeof(struct skl_cpr_pin_fmt),
                                         CPR_SINK_FMT_PARAM_ID, src_mcfg);
 
@@ -1198,7 +1163,7 @@ int skl_bind_modules(struct skl_sst *ctx,
 
         msg.dst_queue = dst_index;
 
-        dev_dbg(ctx->dev, "src queue = %d dst queue =%d\n",
+        dev_dbg(skl->dev, "src queue = %d dst queue =%d\n",
                          msg.src_queue, msg.dst_queue);
 
         msg.module_id = src_mcfg->id.module_id;
@@ -1207,7 +1172,7 @@ int skl_bind_modules(struct skl_sst *ctx,
         msg.dst_instance_id = dst_mcfg->id.pvt_id;
         msg.bind = true;
 
-        ret = skl_ipc_bind_unbind(&ctx->ipc, &msg);
+        ret = skl_ipc_bind_unbind(&skl->ipc, &msg);
 
         if (!ret) {
                 src_mcfg->m_state = SKL_MODULE_BIND_DONE;
@@ -1223,12 +1188,12 @@ out:
         return ret;
 }
 
-static int skl_set_pipe_state(struct skl_sst *ctx, struct skl_pipe *pipe,
+static int skl_set_pipe_state(struct skl_dev *skl, struct skl_pipe *pipe,
         enum skl_ipc_pipeline_state state)
 {
-        dev_dbg(ctx->dev, "%s: pipe_state = %d\n", __func__, state);
+        dev_dbg(skl->dev, "%s: pipe_state = %d\n", __func__, state);
 
-        return skl_ipc_set_pipeline_state(&ctx->ipc, pipe->ppl_id, state);
+        return skl_ipc_set_pipeline_state(&skl->ipc, pipe->ppl_id, state);
 }
 
 /*
@@ -1237,17 +1202,17 @@ static int skl_set_pipe_state(struct skl_sst *ctx, struct skl_pipe *pipe,
  * This function creates pipeline, by sending create pipeline IPC messages
  * to FW
  */
-int skl_create_pipeline(struct skl_sst *ctx, struct skl_pipe *pipe)
+int skl_create_pipeline(struct skl_dev *skl, struct skl_pipe *pipe)
 {
         int ret;
 
-        dev_dbg(ctx->dev, "%s: pipe_id = %d\n", __func__, pipe->ppl_id);
+        dev_dbg(skl->dev, "%s: pipe_id = %d\n", __func__, pipe->ppl_id);
 
-        ret = skl_ipc_create_pipeline(&ctx->ipc, pipe->memory_pages,
+        ret = skl_ipc_create_pipeline(&skl->ipc, pipe->memory_pages,
                                 pipe->pipe_priority, pipe->ppl_id,
                                 pipe->lp_mode);
         if (ret < 0) {
-                dev_err(ctx->dev, "Failed to create pipeline\n");
+                dev_err(skl->dev, "Failed to create pipeline\n");
                 return ret;
         }
 
@@ -1262,11 +1227,11 @@ int skl_create_pipeline(struct skl_sst *ctx, struct skl_pipe *pipe)
  * reset state. Finish the procedure by sending delete pipeline IPC.
  * DSP will stop the DMA engines and release resources
  */
-int skl_delete_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
+int skl_delete_pipe(struct skl_dev *skl, struct skl_pipe *pipe)
 {
         int ret;
 
-        dev_dbg(ctx->dev, "%s: pipe = %d\n", __func__, pipe->ppl_id);
+        dev_dbg(skl->dev, "%s: pipe = %d\n", __func__, pipe->ppl_id);
 
         /* If pipe was not created in FW, do not try to delete it */
         if (pipe->state < SKL_PIPE_CREATED)
@@ -1274,9 +1239,9 @@ int skl_delete_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
 
         /* If pipe is started, do stop the pipe in FW. */
         if (pipe->state >= SKL_PIPE_STARTED) {
-                ret = skl_set_pipe_state(ctx, pipe, PPL_PAUSED);
+                ret = skl_set_pipe_state(skl, pipe, PPL_PAUSED);
                 if (ret < 0) {
-                        dev_err(ctx->dev, "Failed to stop pipeline\n");
+                        dev_err(skl->dev, "Failed to stop pipeline\n");
                         return ret;
                 }
 
@@ -1284,17 +1249,17 @@ int skl_delete_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
         }
 
         /* reset pipe state before deletion */
-        ret = skl_set_pipe_state(ctx, pipe, PPL_RESET);
+        ret = skl_set_pipe_state(skl, pipe, PPL_RESET);
         if (ret < 0) {
-                dev_err(ctx->dev, "Failed to reset pipe ret=%d\n", ret);
+                dev_err(skl->dev, "Failed to reset pipe ret=%d\n", ret);
                 return ret;
         }
 
         pipe->state = SKL_PIPE_RESET;
 
-        ret = skl_ipc_delete_pipeline(&ctx->ipc, pipe->ppl_id);
+        ret = skl_ipc_delete_pipeline(&skl->ipc, pipe->ppl_id);
         if (ret < 0) {
-                dev_err(ctx->dev, "Failed to delete pipeline\n");
+                dev_err(skl->dev, "Failed to delete pipeline\n");
                 return ret;
         }
 
@@ -1308,28 +1273,28 @@ int skl_delete_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
  * For processing data the pipe need to be run by sending IPC set pipe state
  * to DSP
  */
-int skl_run_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
+int skl_run_pipe(struct skl_dev *skl, struct skl_pipe *pipe)
 {
         int ret;
 
-        dev_dbg(ctx->dev, "%s: pipe = %d\n", __func__, pipe->ppl_id);
+        dev_dbg(skl->dev, "%s: pipe = %d\n", __func__, pipe->ppl_id);
 
         /* If pipe was not created in FW, do not try to pause or delete */
         if (pipe->state < SKL_PIPE_CREATED)
                 return 0;
 
         /* Pipe has to be paused before it is started */
-        ret = skl_set_pipe_state(ctx, pipe, PPL_PAUSED);
+        ret = skl_set_pipe_state(skl, pipe, PPL_PAUSED);
         if (ret < 0) {
-                dev_err(ctx->dev, "Failed to pause pipe\n");
+                dev_err(skl->dev, "Failed to pause pipe\n");
                 return ret;
         }
 
         pipe->state = SKL_PIPE_PAUSED;
 
-        ret = skl_set_pipe_state(ctx, pipe, PPL_RUNNING);
+        ret = skl_set_pipe_state(skl, pipe, PPL_RUNNING);
         if (ret < 0) {
-                dev_err(ctx->dev, "Failed to start pipe\n");
+                dev_err(skl->dev, "Failed to start pipe\n");
                 return ret;
         }
 
@@ -1342,19 +1307,19 @@ int skl_run_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
  * Stop the pipeline by sending set pipe state IPC
  * DSP doesnt implement stop so we always send pause message
  */
-int skl_stop_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
+int skl_stop_pipe(struct skl_dev *skl, struct skl_pipe *pipe)
 {
         int ret;
 
-        dev_dbg(ctx->dev, "In %s pipe=%d\n", __func__, pipe->ppl_id);
+        dev_dbg(skl->dev, "In %s pipe=%d\n", __func__, pipe->ppl_id);
 
         /* If pipe was not created in FW, do not try to pause or delete */
         if (pipe->state < SKL_PIPE_PAUSED)
                 return 0;
 
-        ret = skl_set_pipe_state(ctx, pipe, PPL_PAUSED);
+        ret = skl_set_pipe_state(skl, pipe, PPL_PAUSED);
         if (ret < 0) {
-                dev_dbg(ctx->dev, "Failed to stop pipe\n");
+                dev_dbg(skl->dev, "Failed to stop pipe\n");
                 return ret;
         }
 
@@ -1367,7 +1332,7 @@ int skl_stop_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
  * Reset the pipeline by sending set pipe state IPC this will reset the DMA
  * from the DSP side
  */
-int skl_reset_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
+int skl_reset_pipe(struct skl_dev *skl, struct skl_pipe *pipe)
 {
         int ret;
 
@@ -1375,9 +1340,9 @@ int skl_reset_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
         if (pipe->state < SKL_PIPE_PAUSED)
                 return 0;
 
-        ret = skl_set_pipe_state(ctx, pipe, PPL_RESET);
+        ret = skl_set_pipe_state(skl, pipe, PPL_RESET);
         if (ret < 0) {
-                dev_dbg(ctx->dev, "Failed to reset pipe ret=%d\n", ret);
+                dev_dbg(skl->dev, "Failed to reset pipe ret=%d\n", ret);
                 return ret;
         }
 
@@ -1387,7 +1352,7 @@ int skl_reset_pipe(struct skl_sst *ctx, struct skl_pipe *pipe)
 }
 
 /* Algo parameter set helper function */
-int skl_set_module_params(struct skl_sst *ctx, u32 *params, int size,
+int skl_set_module_params(struct skl_dev *skl, u32 *params, int size,
                                 u32 param_id, struct skl_module_cfg *mcfg)
 {
         struct skl_ipc_large_config_msg msg;
@@ -1397,18 +1362,19 @@ int skl_set_module_params(struct skl_sst *ctx, u32 *params, int size,
         msg.param_data_size = size;
         msg.large_param_id = param_id;
 
-        return skl_ipc_set_large_config(&ctx->ipc, &msg, params);
+        return skl_ipc_set_large_config(&skl->ipc, &msg, params);
 }
 
-int skl_get_module_params(struct skl_sst *ctx, u32 *params, int size,
+int skl_get_module_params(struct skl_dev *skl, u32 *params, int size,
                           u32 param_id, struct skl_module_cfg *mcfg)
 {
         struct skl_ipc_large_config_msg msg;
+        size_t bytes = size;
 
         msg.module_id = mcfg->id.module_id;
         msg.instance_id = mcfg->id.pvt_id;
         msg.param_data_size = size;
         msg.large_param_id = param_id;
 
-        return skl_ipc_get_large_config(&ctx->ipc, &msg, params);
+        return skl_ipc_get_large_config(&skl->ipc, &msg, &params, &bytes);
 }
diff --git a/sound/soc/intel/skylake/skl-nhlt.c b/sound/soc/intel/skylake/skl-nhlt.c
index 1132109cb992..19f328d71f24 100644
--- a/sound/soc/intel/skylake/skl-nhlt.c
+++ b/sound/soc/intel/skylake/skl-nhlt.c
@@ -9,57 +9,10 @@
  * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
  */
 #include <linux/pci.h>
+#include <sound/intel-nhlt.h>
 #include "skl.h"
 #include "skl-i2s.h"
 
-#define NHLT_ACPI_HEADER_SIG    "NHLT"
-
-/* Unique identification for getting NHLT blobs */
-static guid_t osc_guid =
-        GUID_INIT(0xA69F886E, 0x6CEB, 0x4594,
-                  0xA4, 0x1F, 0x7B, 0x5D, 0xCE, 0x24, 0xC5, 0x53);
-
-
-struct nhlt_acpi_table *skl_nhlt_init(struct device *dev)
-{
-        acpi_handle handle;
-        union acpi_object *obj;
-        struct nhlt_resource_desc  *nhlt_ptr = NULL;
-        struct nhlt_acpi_table *nhlt_table = NULL;
-
-        handle = ACPI_HANDLE(dev);
-        if (!handle) {
-                dev_err(dev, "Didn't find ACPI_HANDLE\n");
-                return NULL;
-        }
-
-        obj = acpi_evaluate_dsm(handle, &osc_guid, 1, 1, NULL);
-        if (obj && obj->type == ACPI_TYPE_BUFFER) {
-                nhlt_ptr = (struct nhlt_resource_desc  *)obj->buffer.pointer;
-                if (nhlt_ptr->length)
-                        nhlt_table = (struct nhlt_acpi_table *)
-                                memremap(nhlt_ptr->min_addr, nhlt_ptr->length,
-                                MEMREMAP_WB);
-                ACPI_FREE(obj);
-                if (nhlt_table && (strncmp(nhlt_table->header.signature,
-                                        NHLT_ACPI_HEADER_SIG,
-                                        strlen(NHLT_ACPI_HEADER_SIG)) != 0)) {
-                        memunmap(nhlt_table);
-                        dev_err(dev, "NHLT ACPI header signature incorrect\n");
-                        return NULL;
-                }
-                return nhlt_table;
-        }
-
-        dev_err(dev, "device specific method to extract NHLT blob failed\n");
-        return NULL;
-}
-
-void skl_nhlt_free(struct nhlt_acpi_table *nhlt)
-{
-        memunmap((void *) nhlt);
-}
-
 static struct nhlt_specific_cfg *skl_get_specific_cfg(
                 struct device *dev, struct nhlt_fmt *fmt,
                 u8 no_ch, u32 rate, u16 bps, u8 linktype)
@@ -126,7 +79,7 @@ static bool skl_check_ep_match(struct device *dev, struct nhlt_endpoint *epnt,
 }
 
 struct nhlt_specific_cfg
-*skl_get_ep_blob(struct skl *skl, u32 instance, u8 link_type,
+*skl_get_ep_blob(struct skl_dev *skl, u32 instance, u8 link_type,
                         u8 s_fmt, u8 num_ch, u32 s_rate,
                         u8 dirn, u8 dev_type)
 {
@@ -162,48 +115,6 @@ struct nhlt_specific_cfg
         return NULL;
 }
 
-int skl_get_dmic_geo(struct skl *skl)
-{
-        struct nhlt_acpi_table *nhlt = (struct nhlt_acpi_table *)skl->nhlt;
-        struct nhlt_endpoint *epnt;
-        struct nhlt_dmic_array_config *cfg;
-        struct device *dev = &skl->pci->dev;
-        unsigned int dmic_geo = 0;
-        u8 j;
-
-        if (!nhlt)
-                return 0;
-
-        epnt = (struct nhlt_endpoint *)nhlt->desc;
-
-        for (j = 0; j < nhlt->endpoint_count; j++) {
-                if (epnt->linktype == NHLT_LINK_DMIC) {
-                        cfg = (struct nhlt_dmic_array_config  *)
-                                        (epnt->config.caps);
-                        switch (cfg->array_type) {
-                        case NHLT_MIC_ARRAY_2CH_SMALL:
-                        case NHLT_MIC_ARRAY_2CH_BIG:
-                                dmic_geo |= MIC_ARRAY_2CH;
-                                break;
-
-                        case NHLT_MIC_ARRAY_4CH_1ST_GEOM:
-                        case NHLT_MIC_ARRAY_4CH_L_SHAPED:
-                        case NHLT_MIC_ARRAY_4CH_2ND_GEOM:
-                                dmic_geo |= MIC_ARRAY_4CH;
-                                break;
-
-                        default:
-                                dev_warn(dev, "undefined DMIC array_type 0x%0x\n",
-                                                cfg->array_type);
-
-                        }
-                }
-                epnt = (struct nhlt_endpoint *)((u8 *)epnt + epnt->length);
-        }
-
-        return dmic_geo;
-}
-
 static void skl_nhlt_trim_space(char *trim)
 {
         char *s = trim;
@@ -219,13 +130,13 @@ static void skl_nhlt_trim_space(char *trim)
         s[cnt] = '\0';
 }
 
-int skl_nhlt_update_topology_bin(struct skl *skl)
+int skl_nhlt_update_topology_bin(struct skl_dev *skl)
 {
         struct nhlt_acpi_table *nhlt = (struct nhlt_acpi_table *)skl->nhlt;
         struct hdac_bus *bus = skl_to_bus(skl);
         struct device *dev = bus->dev;
 
-        dev_dbg(dev, "oem_id %.6s, oem_table_id %8s oem_revision %d\n",
+        dev_dbg(dev, "oem_id %.6s, oem_table_id %.8s oem_revision %d\n",
                 nhlt->header.oem_id, nhlt->header.oem_table_id,
                 nhlt->header.oem_revision);
 
@@ -243,7 +154,7 @@ static ssize_t skl_nhlt_platform_id_show(struct device *dev,
 {
         struct pci_dev *pci = to_pci_dev(dev);
         struct hdac_bus *bus = pci_get_drvdata(pci);
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         struct nhlt_acpi_table *nhlt = (struct nhlt_acpi_table *)skl->nhlt;
         char platform_id[32];
 
@@ -257,7 +168,7 @@ static ssize_t skl_nhlt_platform_id_show(struct device *dev,
 
 static DEVICE_ATTR(platform_id, 0444, skl_nhlt_platform_id_show, NULL);
 
-int skl_nhlt_create_sysfs(struct skl *skl)
+int skl_nhlt_create_sysfs(struct skl_dev *skl)
 {
         struct device *dev = &skl->pci->dev;
 
@@ -267,7 +178,7 @@ int skl_nhlt_create_sysfs(struct skl *skl)
         return 0;
 }
 
-void skl_nhlt_remove_sysfs(struct skl *skl)
+void skl_nhlt_remove_sysfs(struct skl_dev *skl)
 {
         struct device *dev = &skl->pci->dev;
 
@@ -279,7 +190,7 @@ void skl_nhlt_remove_sysfs(struct skl *skl)
  * stores all possible rates supported in a rate table for the corresponding
  * sclk/sclkfs.
  */
-static void skl_get_ssp_clks(struct skl *skl, struct skl_ssp_clk *ssp_clks,
+static void skl_get_ssp_clks(struct skl_dev *skl, struct skl_ssp_clk *ssp_clks,
                                 struct nhlt_fmt *fmt, u8 id)
 {
         struct skl_i2s_config_blob_ext *i2s_config_ext;
@@ -377,7 +288,7 @@ static void skl_get_ssp_clks(struct skl *skl, struct skl_ssp_clk *ssp_clks,
         }
 }
 
-static void skl_get_mclk(struct skl *skl, struct skl_ssp_clk *mclk,
+static void skl_get_mclk(struct skl_dev *skl, struct skl_ssp_clk *mclk,
                                 struct nhlt_fmt *fmt, u8 id)
 {
         struct skl_i2s_config_blob_ext *i2s_config_ext;
@@ -421,7 +332,7 @@ static void skl_get_mclk(struct skl *skl, struct skl_ssp_clk *mclk,
         mclk[id].parent_name = parent->name;
 }
 
-void skl_get_clks(struct skl *skl, struct skl_ssp_clk *ssp_clks)
+void skl_get_clks(struct skl_dev *skl, struct skl_ssp_clk *ssp_clks)
 {
         struct nhlt_acpi_table *nhlt = (struct nhlt_acpi_table *)skl->nhlt;
         struct nhlt_endpoint *epnt;
diff --git a/sound/soc/intel/skylake/skl-nhlt.h b/sound/soc/intel/skylake/skl-nhlt.h
deleted file mode 100644
index f85fbf9c7ce4..000000000000
--- a/sound/soc/intel/skylake/skl-nhlt.h
+++ /dev/null
@@ -1,119 +0,0 @@
-/* SPDX-License-Identifier: GPL-2.0-only */
-/*
- *  skl-nhlt.h - Intel HDA Platform NHLT header
- *
- *  Copyright (C) 2015 Intel Corp
- *  Author: Sanjiv Kumar <sanjiv.kumar@intel.com>
- *  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- *
- * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
- */
-#ifndef __SKL_NHLT_H__
-#define __SKL_NHLT_H__
-
-#include <linux/acpi.h>
-
-struct wav_fmt {
-        u16 fmt_tag;
-        u16 channels;
-        u32 samples_per_sec;
-        u32 avg_bytes_per_sec;
-        u16 block_align;
-        u16 bits_per_sample;
-        u16 cb_size;
-} __packed;
-
-struct wav_fmt_ext {
-        struct wav_fmt fmt;
-        union samples {
-                u16 valid_bits_per_sample;
-                u16 samples_per_block;
-                u16 reserved;
-        } sample;
-        u32 channel_mask;
-        u8 sub_fmt[16];
-} __packed;
-
-enum nhlt_link_type {
-        NHLT_LINK_HDA = 0,
-        NHLT_LINK_DSP = 1,
-        NHLT_LINK_DMIC = 2,
-        NHLT_LINK_SSP = 3,
-        NHLT_LINK_INVALID
-};
-
-enum nhlt_device_type {
-        NHLT_DEVICE_BT = 0,
-        NHLT_DEVICE_DMIC = 1,
-        NHLT_DEVICE_I2S = 4,
-        NHLT_DEVICE_INVALID
-};
-
-struct nhlt_specific_cfg {
-        u32 size;
-        u8 caps[0];
-} __packed;
-
-struct nhlt_fmt_cfg {
-        struct wav_fmt_ext fmt_ext;
-        struct nhlt_specific_cfg config;
-} __packed;
-
-struct nhlt_fmt {
-        u8 fmt_count;
-        struct nhlt_fmt_cfg fmt_config[0];
-} __packed;
-
-struct nhlt_endpoint {
-        u32  length;
-        u8   linktype;
-        u8   instance_id;
-        u16  vendor_id;
-        u16  device_id;
-        u16  revision_id;
-        u32  subsystem_id;
-        u8   device_type;
-        u8   direction;
-        u8   virtual_bus_id;
-        struct nhlt_specific_cfg config;
-} __packed;
-
-struct nhlt_acpi_table {
-        struct acpi_table_header header;
-        u8 endpoint_count;
-        struct nhlt_endpoint desc[0];
-} __packed;
-
-struct nhlt_resource_desc  {
-        u32 extra;
-        u16 flags;
-        u64 addr_spc_gra;
-        u64 min_addr;
-        u64 max_addr;
-        u64 addr_trans_offset;
-        u64 length;
-} __packed;
-
-#define MIC_ARRAY_2CH 2
-#define MIC_ARRAY_4CH 4
-
-struct nhlt_tdm_config {
-        u8 virtual_slot;
-        u8 config_type;
-} __packed;
-
-struct nhlt_dmic_array_config {
-        struct nhlt_tdm_config tdm_config;
-        u8 array_type;
-} __packed;
-
-enum {
-        NHLT_MIC_ARRAY_2CH_SMALL = 0xa,
-        NHLT_MIC_ARRAY_2CH_BIG = 0xb,
-        NHLT_MIC_ARRAY_4CH_1ST_GEOM = 0xc,
-        NHLT_MIC_ARRAY_4CH_L_SHAPED = 0xd,
-        NHLT_MIC_ARRAY_4CH_2ND_GEOM = 0xe,
-        NHLT_MIC_ARRAY_VENDOR_DEFINED = 0xf,
-};
-
-#endif
diff --git a/sound/soc/intel/skylake/skl-pcm.c b/sound/soc/intel/skylake/skl-pcm.c
index 760bbcf9a469..7f287424af9b 100644
--- a/sound/soc/intel/skylake/skl-pcm.c
+++ b/sound/soc/intel/skylake/skl-pcm.c
@@ -116,7 +116,7 @@ static void skl_set_suspend_active(struct snd_pcm_substream *substream,
 {
         struct hdac_bus *bus = dev_get_drvdata(dai->dev);
         struct snd_soc_dapm_widget *w;
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
 
         if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK)
                 w = dai->playback_widget;
@@ -132,7 +132,7 @@ static void skl_set_suspend_active(struct snd_pcm_substream *substream,
 int skl_pcm_host_dma_prepare(struct device *dev, struct skl_pipe_params *params)
 {
         struct hdac_bus *bus = dev_get_drvdata(dev);
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         unsigned int format_val;
         struct hdac_stream *hstream;
         struct hdac_ext_stream *stream;
@@ -224,7 +224,7 @@ static int skl_pcm_open(struct snd_pcm_substream *substream,
         struct hdac_ext_stream *stream;
         struct snd_pcm_runtime *runtime = substream->runtime;
         struct skl_dma_params *dma_params;
-        struct skl *skl = get_skl_ctx(dai->dev);
+        struct skl_dev *skl = get_skl_ctx(dai->dev);
         struct skl_module_cfg *mconfig;
 
         dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
@@ -271,7 +271,7 @@ static int skl_pcm_open(struct snd_pcm_substream *substream,
 static int skl_pcm_prepare(struct snd_pcm_substream *substream,
                 struct snd_soc_dai *dai)
 {
-        struct skl *skl = get_skl_ctx(dai->dev);
+        struct skl_dev *skl = get_skl_ctx(dai->dev);
         struct skl_module_cfg *mconfig;
         int ret;
 
@@ -288,7 +288,7 @@ static int skl_pcm_prepare(struct snd_pcm_substream *substream,
                  mconfig->pipe->state == SKL_PIPE_CREATED ||
                  mconfig->pipe->state == SKL_PIPE_PAUSED)) {
 
-                ret = skl_reset_pipe(skl->skl_sst, mconfig->pipe);
+                ret = skl_reset_pipe(skl, mconfig->pipe);
 
                 if (ret < 0)
                         return ret;
@@ -350,7 +350,7 @@ static void skl_pcm_close(struct snd_pcm_substream *substream,
         struct hdac_ext_stream *stream = get_hdac_ext_stream(substream);
         struct hdac_bus *bus = dev_get_drvdata(dai->dev);
         struct skl_dma_params *dma_params = NULL;
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         struct skl_module_cfg *mconfig;
 
         dev_dbg(dai->dev, "%s: %s\n", __func__, dai->name);
@@ -370,9 +370,9 @@ static void skl_pcm_close(struct snd_pcm_substream *substream,
          * CGCTL.MISCBDCGE if disabled by driver
          */
         if (!strncmp(dai->name, "Reference Pin", 13) &&
-                        skl->skl_sst->miscbdcg_disabled) {
-                skl->skl_sst->enable_miscbdcge(dai->dev, true);
-                skl->skl_sst->miscbdcg_disabled = false;
+                        skl->miscbdcg_disabled) {
+                skl->enable_miscbdcge(dai->dev, true);
+                skl->miscbdcg_disabled = false;
         }
 
         mconfig = skl_tplg_fe_get_cpr_module(dai, substream->stream);
@@ -387,7 +387,7 @@ static int skl_pcm_hw_free(struct snd_pcm_substream *substream,
 {
         struct hdac_bus *bus = dev_get_drvdata(dai->dev);
         struct hdac_ext_stream *stream = get_hdac_ext_stream(substream);
-        struct skl *skl = get_skl_ctx(dai->dev);
+        struct skl_dev *skl = get_skl_ctx(dai->dev);
         struct skl_module_cfg *mconfig;
         int ret;
 
@@ -396,7 +396,7 @@ static int skl_pcm_hw_free(struct snd_pcm_substream *substream,
         mconfig = skl_tplg_fe_get_cpr_module(dai, substream->stream);
 
         if (mconfig) {
-                ret = skl_reset_pipe(skl->skl_sst, mconfig->pipe);
+                ret = skl_reset_pipe(skl, mconfig->pipe);
                 if (ret < 0)
                         dev_err(dai->dev, "%s:Reset failed ret =%d",
                                                 __func__, ret);
@@ -471,8 +471,7 @@ static int skl_decoupled_trigger(struct snd_pcm_substream *substream,
 static int skl_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
                 struct snd_soc_dai *dai)
 {
-        struct skl *skl = get_skl_ctx(dai->dev);
-        struct skl_sst *ctx = skl->skl_sst;
+        struct skl_dev *skl = get_skl_ctx(dai->dev);
         struct skl_module_cfg *mconfig;
         struct hdac_bus *bus = get_bus_ctx(substream);
         struct hdac_ext_stream *stream = get_hdac_ext_stream(substream);
@@ -515,7 +514,7 @@ static int skl_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
                 ret = skl_decoupled_trigger(substream, cmd);
                 if (ret < 0)
                         return ret;
-                return skl_run_pipe(ctx, mconfig->pipe);
+                return skl_run_pipe(skl, mconfig->pipe);
                 break;
 
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
@@ -526,7 +525,7 @@ static int skl_pcm_trigger(struct snd_pcm_substream *substream, int cmd,
                  * there are no underrun/overrun in the case if there is a delay
                  * between the two operations.
                  */
-                ret = skl_stop_pipe(ctx, mconfig->pipe);
+                ret = skl_stop_pipe(skl, mconfig->pipe);
                 if (ret < 0)
                         return ret;
 
@@ -602,14 +601,14 @@ static int skl_link_hw_params(struct snd_pcm_substream *substream,
 static int skl_link_pcm_prepare(struct snd_pcm_substream *substream,
                 struct snd_soc_dai *dai)
 {
-        struct skl *skl = get_skl_ctx(dai->dev);
+        struct skl_dev *skl = get_skl_ctx(dai->dev);
         struct skl_module_cfg *mconfig = NULL;
 
         /* In case of XRUN recovery, reset the FW pipe to clean state */
         mconfig = skl_tplg_be_get_cpr_module(dai, substream->stream);
         if (mconfig && !mconfig->pipe->passthru &&
                 (substream->runtime->status->state == SNDRV_PCM_STATE_XRUN))
-                skl_reset_pipe(skl->skl_sst, mconfig->pipe);
+                skl_reset_pipe(skl, mconfig->pipe);
 
         return 0;
 }
@@ -1301,7 +1300,7 @@ static int skl_pcm_new(struct snd_soc_pcm_runtime *rtd)
         struct hdac_bus *bus = dev_get_drvdata(dai->dev);
         struct snd_pcm *pcm = rtd->pcm;
         unsigned int size;
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
 
         if (dai->driver->playback.channels_min ||
                 dai->driver->capture.channels_min) {
@@ -1318,9 +1317,9 @@ static int skl_pcm_new(struct snd_soc_pcm_runtime *rtd)
         return 0;
 }
 
-static int skl_get_module_info(struct skl *skl, struct skl_module_cfg *mconfig)
+static int skl_get_module_info(struct skl_dev *skl,
+                struct skl_module_cfg *mconfig)
 {
-        struct skl_sst *ctx = skl->skl_sst;
         struct skl_module_inst_id *pin_id;
         guid_t *uuid_mod, *uuid_tplg;
         struct skl_module *skl_module;
@@ -1329,12 +1328,12 @@ static int skl_get_module_info(struct skl *skl, struct skl_module_cfg *mconfig)
 
         uuid_mod = (guid_t *)mconfig->guid;
 
-        if (list_empty(&ctx->uuid_list)) {
-                dev_err(ctx->dev, "Module list is empty\n");
+        if (list_empty(&skl->uuid_list)) {
+                dev_err(skl->dev, "Module list is empty\n");
                 return -EIO;
         }
 
-        list_for_each_entry(module, &ctx->uuid_list, list) {
+        list_for_each_entry(module, &skl->uuid_list, list) {
                 if (guid_equal(uuid_mod, &module->uuid)) {
                         mconfig->id.module_id = module->id;
                         if (mconfig->module)
@@ -1361,7 +1360,7 @@ static int skl_get_module_info(struct skl *skl, struct skl_module_cfg *mconfig)
         if (skl->nr_modules && ret)
                 return ret;
 
-        list_for_each_entry(module, &ctx->uuid_list, list) {
+        list_for_each_entry(module, &skl->uuid_list, list) {
                 for (i = 0; i < MAX_IN_QUEUE; i++) {
                         pin_id = &mconfig->m_in_pin[i].id;
                         if (guid_equal(&pin_id->mod_uuid, &module->uuid))
@@ -1378,7 +1377,7 @@ static int skl_get_module_info(struct skl *skl, struct skl_module_cfg *mconfig)
         return 0;
 }
 
-static int skl_populate_modules(struct skl *skl)
+static int skl_populate_modules(struct skl_dev *skl)
 {
         struct skl_pipeline *p;
         struct skl_pipe_module *m;
@@ -1393,7 +1392,7 @@ static int skl_populate_modules(struct skl *skl)
 
                         ret = skl_get_module_info(skl, mconfig);
                         if (ret < 0) {
-                                dev_err(skl->skl_sst->dev,
+                                dev_err(skl->dev,
                                         "query module info failed\n");
                                 return ret;
                         }
@@ -1408,7 +1407,7 @@ static int skl_populate_modules(struct skl *skl)
 static int skl_platform_soc_probe(struct snd_soc_component *component)
 {
         struct hdac_bus *bus = dev_get_drvdata(component->dev);
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         const struct skl_dsp_ops *ops;
         int ret;
 
@@ -1434,22 +1433,21 @@ static int skl_platform_soc_probe(struct snd_soc_component *component)
                  * Disable dynamic clock and power gating during firmware
                  * and library download
                  */
-                skl->skl_sst->enable_miscbdcge(component->dev, false);
-                skl->skl_sst->clock_power_gating(component->dev, false);
+                skl->enable_miscbdcge(component->dev, false);
+                skl->clock_power_gating(component->dev, false);
 
-                ret = ops->init_fw(component->dev, skl->skl_sst);
-                skl->skl_sst->enable_miscbdcge(component->dev, true);
-                skl->skl_sst->clock_power_gating(component->dev, true);
+                ret = ops->init_fw(component->dev, skl);
+                skl->enable_miscbdcge(component->dev, true);
+                skl->clock_power_gating(component->dev, true);
                 if (ret < 0) {
                         dev_err(component->dev, "Failed to boot first fw: %d\n", ret);
                         return ret;
                 }
                 skl_populate_modules(skl);
-                skl->skl_sst->update_d0i3c = skl_update_d0i3c;
-                skl_dsp_enable_notification(skl->skl_sst, false);
+                skl->update_d0i3c = skl_update_d0i3c;
 
                 if (skl->cfg.astate_cfg != NULL) {
-                        skl_dsp_set_astate_cfg(skl->skl_sst,
+                        skl_dsp_set_astate_cfg(skl,
                                         skl->cfg.astate_cfg->count,
                                         skl->cfg.astate_cfg);
                 }
@@ -1463,7 +1461,7 @@ static int skl_platform_soc_probe(struct snd_soc_component *component)
 static void skl_pcm_remove(struct snd_soc_component *component)
 {
         struct hdac_bus *bus = dev_get_drvdata(component->dev);
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
 
         skl_tplg_exit(component, bus);
 
@@ -1486,7 +1484,7 @@ int skl_platform_register(struct device *dev)
         struct snd_soc_dai_driver *dais;
         int num_dais = ARRAY_SIZE(skl_platform_dai);
         struct hdac_bus *bus = dev_get_drvdata(dev);
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
 
         skl->dais = kmemdup(skl_platform_dai, sizeof(skl_platform_dai),
                             GFP_KERNEL);
@@ -1520,7 +1518,7 @@ err:
 int skl_platform_unregister(struct device *dev)
 {
         struct hdac_bus *bus = dev_get_drvdata(dev);
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         struct skl_module_deferred_bind *modules, *tmp;
 
         if (!list_empty(&skl->bind_list)) {
diff --git a/sound/soc/intel/skylake/skl-ssp-clk.c b/sound/soc/intel/skylake/skl-ssp-clk.c
index 5bb6e40d4d3e..1c0e5226cb5b 100644
--- a/sound/soc/intel/skylake/skl-ssp-clk.c
+++ b/sound/soc/intel/skylake/skl-ssp-clk.c
@@ -11,6 +11,7 @@
 #include <linux/platform_device.h>
 #include <linux/clk-provider.h>
 #include <linux/clkdev.h>
+#include <sound/intel-nhlt.h>
 #include "skl.h"
 #include "skl-ssp-clk.h"
 #include "skl-topology.h"
@@ -101,7 +102,7 @@ static void skl_fill_clk_ipc(struct skl_clk_rate_cfg_table *rcfg, u8 clk_type)
 }
 
 /* Sends dma control IPC to turn the clock ON/OFF */
-static int skl_send_clk_dma_control(struct skl *skl,
+static int skl_send_clk_dma_control(struct skl_dev *skl,
                                 struct skl_clk_rate_cfg_table *rcfg,
                                 u32 vbus_id, u8 clk_type,
                                 bool enable)
@@ -152,7 +153,7 @@ static int skl_send_clk_dma_control(struct skl *skl,
         memcpy(i2s_config + sp_cfg->size, data, size);
 
         node_id = ((SKL_DMA_I2S_LINK_INPUT_CLASS << 8) | (vbus_id << 4));
-        ret = skl_dsp_set_dma_control(skl->skl_sst, (u32 *)i2s_config,
+        ret = skl_dsp_set_dma_control(skl, (u32 *)i2s_config,
                                         i2s_config_size, node_id);
         kfree(i2s_config);
 
diff --git a/sound/soc/intel/skylake/skl-sst-dsp.c b/sound/soc/intel/skylake/skl-sst-dsp.c
index 36590c5b4673..225706d148d8 100644
--- a/sound/soc/intel/skylake/skl-sst-dsp.c
+++ b/sound/soc/intel/skylake/skl-sst-dsp.c
@@ -12,7 +12,7 @@
 #include "../common/sst-dsp.h"
 #include "../common/sst-ipc.h"
 #include "../common/sst-dsp-priv.h"
-#include "skl-sst-ipc.h"
+#include "skl.h"
 
 /* various timeout values */
 #define SKL_DSP_PU_TO           50
@@ -33,7 +33,7 @@ void skl_dsp_set_state_locked(struct sst_dsp *ctx, int state)
  */
 void skl_dsp_init_core_state(struct sst_dsp *ctx)
 {
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         int i;
 
         skl->cores.state[SKL_DSP_CORE0_ID] = SKL_DSP_RUNNING;
@@ -48,7 +48,7 @@ void skl_dsp_init_core_state(struct sst_dsp *ctx)
 /* Get the mask for all enabled cores */
 unsigned int skl_dsp_get_enabled_cores(struct sst_dsp *ctx)
 {
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         unsigned int core_mask, en_cores_mask;
         u32 val;
 
@@ -335,7 +335,7 @@ irqreturn_t skl_dsp_sst_interrupt(int irq, void *dev_id)
  */
 int skl_dsp_get_core(struct sst_dsp *ctx, unsigned int core_id)
 {
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         int ret = 0;
 
         if (core_id >= skl->cores.count) {
@@ -364,7 +364,7 @@ EXPORT_SYMBOL_GPL(skl_dsp_get_core);
 
 int skl_dsp_put_core(struct sst_dsp *ctx, unsigned int core_id)
 {
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         int ret = 0;
 
         if (core_id >= skl->cores.count) {
diff --git a/sound/soc/intel/skylake/skl-sst-dsp.h b/sound/soc/intel/skylake/skl-sst-dsp.h
index a80219562036..cdfec0fca577 100644
--- a/sound/soc/intel/skylake/skl-sst-dsp.h
+++ b/sound/soc/intel/skylake/skl-sst-dsp.h
@@ -15,9 +15,9 @@
 #include "skl-sst-cldma.h"
 
 struct sst_dsp;
-struct skl_sst;
 struct sst_dsp_device;
 struct skl_lib_info;
+struct skl_dev;
 
 /* Intel HD Audio General DSP Registers */
 #define SKL_ADSP_GEN_BASE               0x0
@@ -222,32 +222,31 @@ int skl_dsp_put_core(struct sst_dsp *ctx, unsigned int core_id);
 int skl_dsp_boot(struct sst_dsp *ctx);
 int skl_sst_dsp_init(struct device *dev, void __iomem *mmio_base, int irq,
                 const char *fw_name, struct skl_dsp_loader_ops dsp_ops,
-                struct skl_sst **dsp);
+                struct skl_dev **dsp);
 int bxt_sst_dsp_init(struct device *dev, void __iomem *mmio_base, int irq,
                 const char *fw_name, struct skl_dsp_loader_ops dsp_ops,
-                struct skl_sst **dsp);
-int skl_sst_init_fw(struct device *dev, struct skl_sst *ctx);
-int bxt_sst_init_fw(struct device *dev, struct skl_sst *ctx);
-void skl_sst_dsp_cleanup(struct device *dev, struct skl_sst *ctx);
-void bxt_sst_dsp_cleanup(struct device *dev, struct skl_sst *ctx);
+                struct skl_dev **dsp);
+int skl_sst_init_fw(struct device *dev, struct skl_dev *skl);
+int bxt_sst_init_fw(struct device *dev, struct skl_dev *skl);
+void skl_sst_dsp_cleanup(struct device *dev, struct skl_dev *skl);
+void bxt_sst_dsp_cleanup(struct device *dev, struct skl_dev *skl);
 
 int snd_skl_parse_uuids(struct sst_dsp *ctx, const struct firmware *fw,
                                 unsigned int offset, int index);
-int skl_get_pvt_id(struct skl_sst *ctx, guid_t *uuid_mod, int instance_id);
-int skl_put_pvt_id(struct skl_sst *ctx, guid_t *uuid_mod, int *pvt_id);
-int skl_get_pvt_instance_id_map(struct skl_sst *ctx,
+int skl_get_pvt_id(struct skl_dev *skl, guid_t *uuid_mod, int instance_id);
+int skl_put_pvt_id(struct skl_dev *skl, guid_t *uuid_mod, int *pvt_id);
+int skl_get_pvt_instance_id_map(struct skl_dev *skl,
                                 int module_id, int instance_id);
-void skl_freeup_uuid_list(struct skl_sst *ctx);
+void skl_freeup_uuid_list(struct skl_dev *skl);
 
 int skl_dsp_strip_extended_manifest(struct firmware *fw);
-void skl_dsp_enable_notification(struct skl_sst *ctx, bool enable);
 
-void skl_dsp_set_astate_cfg(struct skl_sst *ctx, u32 cnt, void *data);
+void skl_dsp_set_astate_cfg(struct skl_dev *skl, u32 cnt, void *data);
 
 int skl_sst_ctx_init(struct device *dev, int irq, const char *fw_name,
-                struct skl_dsp_loader_ops dsp_ops, struct skl_sst **dsp,
+                struct skl_dsp_loader_ops dsp_ops, struct skl_dev **dsp,
                 struct sst_dsp_device *skl_dev);
-int skl_prepare_lib_load(struct skl_sst *skl, struct skl_lib_info *linfo,
+int skl_prepare_lib_load(struct skl_dev *skl, struct skl_lib_info *linfo,
                         struct firmware *stripped_fw,
                         unsigned int hdr_offset, int index);
 void skl_release_library(struct skl_lib_info *linfo, int lib_count);
diff --git a/sound/soc/intel/skylake/skl-sst-ipc.c b/sound/soc/intel/skylake/skl-sst-ipc.c
index 2cc8f7d2d319..667cdddc289f 100644
--- a/sound/soc/intel/skylake/skl-sst-ipc.c
+++ b/sound/soc/intel/skylake/skl-sst-ipc.c
@@ -281,7 +281,7 @@ void skl_ipc_tx_data_copy(struct ipc_message *msg, char *tx_data,
                 size_t tx_size)
 {
         if (tx_size)
-                memcpy(msg->tx_data, tx_data, tx_size);
+                memcpy(msg->tx.data, tx_data, tx_size);
 }
 
 static bool skl_ipc_is_dsp_busy(struct sst_dsp *dsp)
@@ -295,10 +295,10 @@ static bool skl_ipc_is_dsp_busy(struct sst_dsp *dsp)
 /* Lock to be held by caller */
 static void skl_ipc_tx_msg(struct sst_generic_ipc *ipc, struct ipc_message *msg)
 {
-        struct skl_ipc_header *header = (struct skl_ipc_header *)(&msg->header);
+        struct skl_ipc_header *header = (struct skl_ipc_header *)(&msg->tx.header);
 
-        if (msg->tx_size)
-                sst_dsp_outbox_write(ipc->dsp, msg->tx_data, msg->tx_size);
+        if (msg->tx.size)
+                sst_dsp_outbox_write(ipc->dsp, msg->tx.data, msg->tx.size);
         sst_dsp_shim_write_unlocked(ipc->dsp, SKL_ADSP_REG_HIPCIE,
                                                 header->extension);
         sst_dsp_shim_write_unlocked(ipc->dsp, SKL_ADSP_REG_HIPCI,
@@ -345,7 +345,7 @@ out:
 int skl_ipc_process_notification(struct sst_generic_ipc *ipc,
                 struct skl_ipc_header header)
 {
-        struct skl_sst *skl = container_of(ipc, struct skl_sst, ipc);
+        struct skl_dev *skl = container_of(ipc, struct skl_dev, ipc);
 
         if (IPC_GLB_NOTIFY_MSG_TYPE(header.primary)) {
                 switch (IPC_GLB_NOTIFY_TYPE(header.primary)) {
@@ -436,7 +436,7 @@ void skl_ipc_process_reply(struct sst_generic_ipc *ipc,
         struct ipc_message *msg;
         u32 reply = header.primary & IPC_GLB_REPLY_STATUS_MASK;
         u64 *ipc_header = (u64 *)(&header);
-        struct skl_sst *skl = container_of(ipc, struct skl_sst, ipc);
+        struct skl_dev *skl = container_of(ipc, struct skl_dev, ipc);
         unsigned long flags;
 
         spin_lock_irqsave(&ipc->dsp->spinlock, flags);
@@ -447,11 +447,12 @@ void skl_ipc_process_reply(struct sst_generic_ipc *ipc,
                 return;
         }
 
+        msg->rx.header = *ipc_header;
         /* first process the header */
         if (reply == IPC_GLB_REPLY_SUCCESS) {
                 dev_dbg(ipc->dev, "ipc FW reply %x: success\n", header.primary);
                 /* copy the rx data from the mailbox */
-                sst_dsp_inbox_read(ipc->dsp, msg->rx_data, msg->rx_size);
+                sst_dsp_inbox_read(ipc->dsp, msg->rx.data, msg->rx.size);
                 switch (IPC_GLB_NOTIFY_MSG_TYPE(header.primary)) {
                 case IPC_GLB_LOAD_MULTIPLE_MODS:
                 case IPC_GLB_LOAD_LIBRARY:
@@ -488,7 +489,7 @@ void skl_ipc_process_reply(struct sst_generic_ipc *ipc,
 irqreturn_t skl_dsp_irq_thread_handler(int irq, void *context)
 {
         struct sst_dsp *dsp = context;
-        struct skl_sst *skl = sst_dsp_get_thread_context(dsp);
+        struct skl_dev *skl = sst_dsp_get_thread_context(dsp);
         struct sst_generic_ipc *ipc = &skl->ipc;
         struct skl_ipc_header header = {0};
         u32 hipcie, hipct, hipcte;
@@ -595,7 +596,7 @@ bool skl_ipc_int_status(struct sst_dsp *ctx)
                         SKL_ADSP_REG_ADSPIS) & SKL_ADSPIS_IPC;
 }
 
-int skl_ipc_init(struct device *dev, struct skl_sst *skl)
+int skl_ipc_init(struct device *dev, struct skl_dev *skl)
 {
         struct sst_generic_ipc *ipc;
         int err;
@@ -635,7 +636,7 @@ int skl_ipc_create_pipeline(struct sst_generic_ipc *ipc,
                 u16 ppl_mem_size, u8 ppl_type, u8 instance_id, u8 lp_mode)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request = {0};
         int ret;
 
         header.primary = IPC_MSG_TARGET(IPC_FW_GEN_MSG);
@@ -646,9 +647,10 @@ int skl_ipc_create_pipeline(struct sst_generic_ipc *ipc,
         header.primary |= IPC_PPL_MEM_SIZE(ppl_mem_size);
 
         header.extension = IPC_PPL_LP_MODE(lp_mode);
+        request.header = *(u64 *)(&header);
 
         dev_dbg(ipc->dev, "In %s header=%d\n", __func__, header.primary);
-        ret = sst_ipc_tx_message_wait(ipc, *ipc_header, NULL, 0, NULL, 0);
+        ret = sst_ipc_tx_message_wait(ipc, request, NULL);
         if (ret < 0) {
                 dev_err(ipc->dev, "ipc: create pipeline fail, err: %d\n", ret);
                 return ret;
@@ -661,16 +663,17 @@ EXPORT_SYMBOL_GPL(skl_ipc_create_pipeline);
 int skl_ipc_delete_pipeline(struct sst_generic_ipc *ipc, u8 instance_id)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request = {0};
         int ret;
 
         header.primary = IPC_MSG_TARGET(IPC_FW_GEN_MSG);
         header.primary |= IPC_MSG_DIR(IPC_MSG_REQUEST);
         header.primary |= IPC_GLB_TYPE(IPC_GLB_DELETE_PPL);
         header.primary |= IPC_INSTANCE_ID(instance_id);
+        request.header = *(u64 *)(&header);
 
         dev_dbg(ipc->dev, "In %s header=%d\n", __func__, header.primary);
-        ret = sst_ipc_tx_message_wait(ipc, *ipc_header, NULL, 0, NULL, 0);
+        ret = sst_ipc_tx_message_wait(ipc, request, NULL);
         if (ret < 0) {
                 dev_err(ipc->dev, "ipc: delete pipeline failed, err %d\n", ret);
                 return ret;
@@ -684,7 +687,7 @@ int skl_ipc_set_pipeline_state(struct sst_generic_ipc *ipc,
                 u8 instance_id, enum skl_ipc_pipeline_state state)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request = {0};
         int ret;
 
         header.primary = IPC_MSG_TARGET(IPC_FW_GEN_MSG);
@@ -692,9 +695,10 @@ int skl_ipc_set_pipeline_state(struct sst_generic_ipc *ipc,
         header.primary |= IPC_GLB_TYPE(IPC_GLB_SET_PPL_STATE);
         header.primary |= IPC_INSTANCE_ID(instance_id);
         header.primary |= IPC_PPL_STATE(state);
+        request.header = *(u64 *)(&header);
 
         dev_dbg(ipc->dev, "In %s header=%d\n", __func__, header.primary);
-        ret = sst_ipc_tx_message_wait(ipc, *ipc_header, NULL, 0, NULL, 0);
+        ret = sst_ipc_tx_message_wait(ipc, request, NULL);
         if (ret < 0) {
                 dev_err(ipc->dev, "ipc: set pipeline state failed, err: %d\n", ret);
                 return ret;
@@ -707,7 +711,7 @@ int
 skl_ipc_save_pipeline(struct sst_generic_ipc *ipc, u8 instance_id, int dma_id)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request = {0};
         int ret;
 
         header.primary = IPC_MSG_TARGET(IPC_FW_GEN_MSG);
@@ -716,8 +720,10 @@ skl_ipc_save_pipeline(struct sst_generic_ipc *ipc, u8 instance_id, int dma_id)
         header.primary |= IPC_INSTANCE_ID(instance_id);
 
         header.extension = IPC_DMA_ID(dma_id);
+        request.header = *(u64 *)(&header);
+
         dev_dbg(ipc->dev, "In %s header=%d\n", __func__, header.primary);
-        ret = sst_ipc_tx_message_wait(ipc, *ipc_header, NULL, 0, NULL, 0);
+        ret = sst_ipc_tx_message_wait(ipc, request, NULL);
         if (ret < 0) {
                 dev_err(ipc->dev, "ipc: save pipeline failed, err: %d\n", ret);
                 return ret;
@@ -730,16 +736,17 @@ EXPORT_SYMBOL_GPL(skl_ipc_save_pipeline);
 int skl_ipc_restore_pipeline(struct sst_generic_ipc *ipc, u8 instance_id)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request = {0};
         int ret;
 
         header.primary = IPC_MSG_TARGET(IPC_FW_GEN_MSG);
         header.primary |= IPC_MSG_DIR(IPC_MSG_REQUEST);
         header.primary |= IPC_GLB_TYPE(IPC_GLB_RESTORE_PPL);
         header.primary |= IPC_INSTANCE_ID(instance_id);
+        request.header = *(u64 *)(&header);
 
         dev_dbg(ipc->dev, "In %s header=%d\n", __func__, header.primary);
-        ret = sst_ipc_tx_message_wait(ipc, *ipc_header, NULL, 0, NULL, 0);
+        ret = sst_ipc_tx_message_wait(ipc, request, NULL);
         if (ret < 0) {
                 dev_err(ipc->dev, "ipc: restore  pipeline failed, err: %d\n", ret);
                 return ret;
@@ -753,7 +760,7 @@ int skl_ipc_set_dx(struct sst_generic_ipc *ipc, u8 instance_id,
                 u16 module_id, struct skl_ipc_dxstate_info *dx)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request;
         int ret;
 
         header.primary = IPC_MSG_TARGET(IPC_MOD_MSG);
@@ -762,10 +769,13 @@ int skl_ipc_set_dx(struct sst_generic_ipc *ipc, u8 instance_id,
         header.primary |= IPC_MOD_INSTANCE_ID(instance_id);
         header.primary |= IPC_MOD_ID(module_id);
 
+        request.header = *(u64 *)(&header);
+        request.data = dx;
+        request.size = sizeof(*dx);
+
         dev_dbg(ipc->dev, "In %s primary =%x ext=%x\n", __func__,
                          header.primary, header.extension);
-        ret = sst_ipc_tx_message_wait(ipc, *ipc_header,
-                                dx, sizeof(*dx), NULL, 0);
+        ret = sst_ipc_tx_message_wait(ipc, request, NULL);
         if (ret < 0) {
                 dev_err(ipc->dev, "ipc: set dx failed, err %d\n", ret);
                 return ret;
@@ -779,7 +789,7 @@ int skl_ipc_init_instance(struct sst_generic_ipc *ipc,
                 struct skl_ipc_init_instance_msg *msg, void *param_data)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request;
         int ret;
         u32 *buffer = (u32 *)param_data;
          /* param_block_size must be in dwords */
@@ -799,10 +809,13 @@ int skl_ipc_init_instance(struct sst_generic_ipc *ipc,
         header.extension |= IPC_PARAM_BLOCK_SIZE(param_block_size);
         header.extension |= IPC_DOMAIN(msg->domain);
 
+        request.header = *(u64 *)(&header);
+        request.data = param_data;
+        request.size = msg->param_data_size;
+
         dev_dbg(ipc->dev, "In %s primary =%x ext=%x\n", __func__,
                          header.primary, header.extension);
-        ret = sst_ipc_tx_message_wait(ipc, *ipc_header, param_data,
-                        msg->param_data_size, NULL, 0);
+        ret = sst_ipc_tx_message_wait(ipc, request, NULL);
 
         if (ret < 0) {
                 dev_err(ipc->dev, "ipc: init instance failed\n");
@@ -817,7 +830,7 @@ int skl_ipc_bind_unbind(struct sst_generic_ipc *ipc,
                 struct skl_ipc_bind_unbind_msg *msg)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request = {0};
         u8 bind_unbind = msg->bind ? IPC_MOD_BIND : IPC_MOD_UNBIND;
         int ret;
 
@@ -831,10 +844,11 @@ int skl_ipc_bind_unbind(struct sst_generic_ipc *ipc,
         header.extension |= IPC_DST_MOD_INSTANCE_ID(msg->dst_instance_id);
         header.extension |= IPC_DST_QUEUE(msg->dst_queue);
         header.extension |= IPC_SRC_QUEUE(msg->src_queue);
+        request.header = *(u64 *)(&header);
 
         dev_dbg(ipc->dev, "In %s hdr=%x ext=%x\n", __func__, header.primary,
                          header.extension);
-        ret = sst_ipc_tx_message_wait(ipc, *ipc_header, NULL, 0, NULL, 0);
+        ret = sst_ipc_tx_message_wait(ipc, request, NULL);
         if (ret < 0) {
                 dev_err(ipc->dev, "ipc: bind/unbind failed\n");
                 return ret;
@@ -854,7 +868,7 @@ int skl_ipc_load_modules(struct sst_generic_ipc *ipc,
                                 u8 module_cnt, void *data)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request;
         int ret;
 
         header.primary = IPC_MSG_TARGET(IPC_FW_GEN_MSG);
@@ -862,8 +876,11 @@ int skl_ipc_load_modules(struct sst_generic_ipc *ipc,
         header.primary |= IPC_GLB_TYPE(IPC_GLB_LOAD_MULTIPLE_MODS);
         header.primary |= IPC_LOAD_MODULE_CNT(module_cnt);
 
-        ret = sst_ipc_tx_message_nowait(ipc, *ipc_header, data,
-                                (sizeof(u16) * module_cnt));
+        request.header = *(u64 *)(&header);
+        request.data = data;
+        request.size = sizeof(u16) * module_cnt;
+
+        ret = sst_ipc_tx_message_nowait(ipc, request);
         if (ret < 0)
                 dev_err(ipc->dev, "ipc: load modules failed :%d\n", ret);
 
@@ -875,7 +892,7 @@ int skl_ipc_unload_modules(struct sst_generic_ipc *ipc, u8 module_cnt,
                                                         void *data)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request;
         int ret;
 
         header.primary = IPC_MSG_TARGET(IPC_FW_GEN_MSG);
@@ -883,8 +900,11 @@ int skl_ipc_unload_modules(struct sst_generic_ipc *ipc, u8 module_cnt,
         header.primary |= IPC_GLB_TYPE(IPC_GLB_UNLOAD_MULTIPLE_MODS);
         header.primary |= IPC_LOAD_MODULE_CNT(module_cnt);
 
-        ret = sst_ipc_tx_message_wait(ipc, *ipc_header, data,
-                                (sizeof(u16) * module_cnt), NULL, 0);
+        request.header = *(u64 *)(&header);
+        request.data = data;
+        request.size = sizeof(u16) * module_cnt;
+
+        ret = sst_ipc_tx_message_wait(ipc, request, NULL);
         if (ret < 0)
                 dev_err(ipc->dev, "ipc: unload modules failed :%d\n", ret);
 
@@ -896,7 +916,7 @@ int skl_ipc_set_large_config(struct sst_generic_ipc *ipc,
                 struct skl_ipc_large_config_msg *msg, u32 *param)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request;
         int ret = 0;
         size_t sz_remaining, tx_size, data_offset;
 
@@ -923,9 +943,11 @@ int skl_ipc_set_large_config(struct sst_generic_ipc *ipc,
                         header.primary, header.extension);
                 dev_dbg(ipc->dev, "transmitting offset: %#x, size: %#x\n",
                         (unsigned)data_offset, (unsigned)tx_size);
-                ret = sst_ipc_tx_message_wait(ipc, *ipc_header,
-                                          ((char *)param) + data_offset,
-                                          tx_size, NULL, 0);
+
+                request.header = *(u64 *)(&header);
+                request.data = ((char *)param) + data_offset;
+                request.size = tx_size;
+                ret = sst_ipc_tx_message_wait(ipc, request, NULL);
                 if (ret < 0) {
                         dev_err(ipc->dev,
                                 "ipc: set large config fail, err: %d\n", ret);
@@ -947,12 +969,17 @@ int skl_ipc_set_large_config(struct sst_generic_ipc *ipc,
 EXPORT_SYMBOL_GPL(skl_ipc_set_large_config);
 
 int skl_ipc_get_large_config(struct sst_generic_ipc *ipc,
-                struct skl_ipc_large_config_msg *msg, u32 *param)
+                struct skl_ipc_large_config_msg *msg,
+                u32 **payload, size_t *bytes)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
-        int ret = 0;
-        size_t sz_remaining, rx_size, data_offset;
+        struct sst_ipc_message request, reply = {0};
+        unsigned int *buf;
+        int ret;
+
+        reply.data = kzalloc(SKL_ADSP_W1_SZ, GFP_KERNEL);
+        if (!reply.data)
+                return -ENOMEM;
 
         header.primary = IPC_MSG_TARGET(IPC_MOD_MSG);
         header.primary |= IPC_MSG_DIR(IPC_MSG_REQUEST);
@@ -965,33 +992,21 @@ int skl_ipc_get_large_config(struct sst_generic_ipc *ipc,
         header.extension |= IPC_FINAL_BLOCK(1);
         header.extension |= IPC_INITIAL_BLOCK(1);
 
-        sz_remaining = msg->param_data_size;
-        data_offset = 0;
+        request.header = *(u64 *)&header;
+        request.data = *payload;
+        request.size = *bytes;
+        reply.size = SKL_ADSP_W1_SZ;
 
-        while (sz_remaining != 0) {
-                rx_size = sz_remaining > SKL_ADSP_W1_SZ
-                                ? SKL_ADSP_W1_SZ : sz_remaining;
-                if (rx_size == sz_remaining)
-                        header.extension |= IPC_FINAL_BLOCK(1);
-
-                ret = sst_ipc_tx_message_wait(ipc, *ipc_header, NULL, 0,
-                                              ((char *)param) + data_offset,
-                                              msg->param_data_size);
-                if (ret < 0) {
-                        dev_err(ipc->dev,
-                                "ipc: get large config fail, err: %d\n", ret);
-                        return ret;
-                }
-                sz_remaining -= rx_size;
-                data_offset = msg->param_data_size - sz_remaining;
+        ret = sst_ipc_tx_message_wait(ipc, request, &reply);
+        if (ret < 0)
+                dev_err(ipc->dev, "ipc: get large config fail, err: %d\n", ret);
 
-                /* clear the fields */
-                header.extension &= IPC_INITIAL_BLOCK_CLEAR;
-                header.extension &= IPC_DATA_OFFSET_SZ_CLEAR;
-                /* fill the fields */
-                header.extension |= IPC_INITIAL_BLOCK(1);
-                header.extension |= IPC_DATA_OFFSET_SZ(data_offset);
-        }
+        reply.size = (reply.header >> 32) & IPC_DATA_OFFSET_SZ_MASK;
+        buf = krealloc(reply.data, reply.size, GFP_KERNEL);
+        if (!buf)
+                return -ENOMEM;
+        *payload = buf;
+        *bytes = reply.size;
 
         return ret;
 }
@@ -1001,7 +1016,7 @@ int skl_sst_ipc_load_library(struct sst_generic_ipc *ipc,
                                 u8 dma_id, u8 table_id, bool wait)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request = {0};
         int ret = 0;
 
         header.primary = IPC_MSG_TARGET(IPC_FW_GEN_MSG);
@@ -1009,12 +1024,12 @@ int skl_sst_ipc_load_library(struct sst_generic_ipc *ipc,
         header.primary |= IPC_GLB_TYPE(IPC_GLB_LOAD_LIBRARY);
         header.primary |= IPC_MOD_INSTANCE_ID(table_id);
         header.primary |= IPC_MOD_ID(dma_id);
+        request.header = *(u64 *)(&header);
 
         if (wait)
-                ret = sst_ipc_tx_message_wait(ipc, *ipc_header,
-                                        NULL, 0, NULL, 0);
+                ret = sst_ipc_tx_message_wait(ipc, request, NULL);
         else
-                ret = sst_ipc_tx_message_nowait(ipc, *ipc_header, NULL, 0);
+                ret = sst_ipc_tx_message_nowait(ipc, request);
 
         if (ret < 0)
                 dev_err(ipc->dev, "ipc: load lib failed\n");
@@ -1026,7 +1041,7 @@ EXPORT_SYMBOL_GPL(skl_sst_ipc_load_library);
 int skl_ipc_set_d0ix(struct sst_generic_ipc *ipc, struct skl_ipc_d0ix_msg *msg)
 {
         struct skl_ipc_header header = {0};
-        u64 *ipc_header = (u64 *)(&header);
+        struct sst_ipc_message request = {0};
         int ret;
 
         header.primary = IPC_MSG_TARGET(IPC_MOD_MSG);
@@ -1037,6 +1052,7 @@ int skl_ipc_set_d0ix(struct sst_generic_ipc *ipc, struct skl_ipc_d0ix_msg *msg)
 
         header.extension = IPC_D0IX_WAKE(msg->wake);
         header.extension |= IPC_D0IX_STREAMING(msg->streaming);
+        request.header = *(u64 *)(&header);
 
         dev_dbg(ipc->dev, "In %s primary=%x ext=%x\n", __func__,
                         header.primary, header.extension);
@@ -1044,7 +1060,7 @@ int skl_ipc_set_d0ix(struct sst_generic_ipc *ipc, struct skl_ipc_d0ix_msg *msg)
         /*
          * Use the nopm IPC here as we dont want it checking for D0iX
          */
-        ret = sst_ipc_tx_message_nopm(ipc, *ipc_header, NULL, 0, NULL, 0);
+        ret = sst_ipc_tx_message_nopm(ipc, request, NULL);
         if (ret < 0)
                 dev_err(ipc->dev, "ipc: set d0ix failed, err %d\n", ret);
 
diff --git a/sound/soc/intel/skylake/skl-sst-ipc.h b/sound/soc/intel/skylake/skl-sst-ipc.h
index 9c31a48e99dd..08ac31778325 100644
--- a/sound/soc/intel/skylake/skl-sst-ipc.h
+++ b/sound/soc/intel/skylake/skl-sst-ipc.h
@@ -10,9 +10,9 @@
 
 #include <linux/irqreturn.h>
 #include "../common/sst-ipc.h"
+#include "skl-sst-dsp.h"
 
 struct sst_dsp;
-struct skl_sst;
 struct sst_generic_ipc;
 
 enum skl_ipc_pipeline_state {
@@ -67,54 +67,6 @@ struct skl_lib_info {
         const struct firmware *fw;
 };
 
-struct skl_sst {
-        struct device *dev;
-        struct sst_dsp *dsp;
-
-        /* boot */
-        wait_queue_head_t boot_wait;
-        bool boot_complete;
-
-        /* module load */
-        wait_queue_head_t mod_load_wait;
-        bool mod_load_complete;
-        bool mod_load_status;
-
-        /* IPC messaging */
-        struct sst_generic_ipc ipc;
-
-        /* callback for miscbdge */
-        void (*enable_miscbdcge)(struct device *dev, bool enable);
-        /* Is CGCTL.MISCBDCGE disabled */
-        bool miscbdcg_disabled;
-
-        /* Populate module information */
-        struct list_head uuid_list;
-
-        /* Is firmware loaded */
-        bool fw_loaded;
-
-        /* first boot ? */
-        bool is_first_boot;
-
-        /* multi-core */
-        struct skl_dsp_cores cores;
-
-        /* library info */
-        struct skl_lib_info  lib_info[SKL_MAX_LIB];
-        int lib_count;
-
-        /* Callback to update D0i3C register */
-        void (*update_d0i3c)(struct device *dev, bool enable);
-
-        struct skl_d0i3_data d0i3;
-
-        const struct skl_dsp_ops *dsp_ops;
-
-        /* Callback to update dynamic clock and power gating registers */
-        void (*clock_power_gating)(struct device *dev, bool enable);
-};
-
 struct skl_ipc_init_instance_msg {
         u32 module_id;
         u32 instance_id;
@@ -187,7 +139,8 @@ int skl_ipc_set_large_config(struct sst_generic_ipc *ipc,
                 struct skl_ipc_large_config_msg *msg, u32 *param);
 
 int skl_ipc_get_large_config(struct sst_generic_ipc *ipc,
-                struct skl_ipc_large_config_msg *msg, u32 *param);
+                struct skl_ipc_large_config_msg *msg,
+                u32 **payload, size_t *bytes);
 
 int skl_sst_ipc_load_library(struct sst_generic_ipc *ipc,
                         u8 dma_id, u8 table_id, bool wait);
@@ -204,7 +157,7 @@ void skl_ipc_int_disable(struct sst_dsp *dsp);
 
 bool skl_ipc_int_status(struct sst_dsp *dsp);
 void skl_ipc_free(struct sst_generic_ipc *ipc);
-int skl_ipc_init(struct device *dev, struct skl_sst *skl);
+int skl_ipc_init(struct device *dev, struct skl_dev *skl);
 void skl_clear_module_cnt(struct sst_dsp *ctx);
 
 void skl_ipc_process_reply(struct sst_generic_ipc *ipc,
diff --git a/sound/soc/intel/skylake/skl-sst-utils.c b/sound/soc/intel/skylake/skl-sst-utils.c
index 928c677b506c..d43cbf4a71ef 100644
--- a/sound/soc/intel/skylake/skl-sst-utils.c
+++ b/sound/soc/intel/skylake/skl-sst-utils.c
@@ -8,10 +8,9 @@
 #include <linux/device.h>
 #include <linux/slab.h>
 #include <linux/uuid.h>
-#include "skl-sst-dsp.h"
 #include "../common/sst-dsp.h"
 #include "../common/sst-dsp-priv.h"
-#include "skl-sst-ipc.h"
+#include "skl.h"
 
 #define DEFAULT_HASH_SHA256_LEN 32
 
@@ -99,12 +98,12 @@ static int skl_get_pvtid_map(struct uuid_module *module, int instance_id)
         return -EINVAL;
 }
 
-int skl_get_pvt_instance_id_map(struct skl_sst *ctx,
+int skl_get_pvt_instance_id_map(struct skl_dev *skl,
                                 int module_id, int instance_id)
 {
         struct uuid_module *module;
 
-        list_for_each_entry(module, &ctx->uuid_list, list) {
+        list_for_each_entry(module, &skl->uuid_list, list) {
                 if (module->id == module_id)
                         return skl_get_pvtid_map(module, instance_id);
         }
@@ -163,19 +162,19 @@ static inline int skl_pvtid_128(struct uuid_module *module)
 /**
  * skl_get_pvt_id: generate a private id for use as module id
  *
- * @ctx: driver context
+ * @skl: driver context
  * @uuid_mod: module's uuid
  * @instance_id: module's instance id
  *
  * This generates a 128 bit private unique id for a module TYPE so that
  * module instance is unique
  */
-int skl_get_pvt_id(struct skl_sst *ctx, guid_t *uuid_mod, int instance_id)
+int skl_get_pvt_id(struct skl_dev *skl, guid_t *uuid_mod, int instance_id)
 {
         struct uuid_module *module;
         int pvt_id;
 
-        list_for_each_entry(module, &ctx->uuid_list, list) {
+        list_for_each_entry(module, &skl->uuid_list, list) {
                 if (guid_equal(uuid_mod, &module->uuid)) {
 
                         pvt_id = skl_pvtid_128(module);
@@ -194,18 +193,18 @@ EXPORT_SYMBOL_GPL(skl_get_pvt_id);
 /**
  * skl_put_pvt_id: free up the private id allocated
  *
- * @ctx: driver context
+ * @skl: driver context
  * @uuid_mod: module's uuid
  * @pvt_id: module pvt id
  *
  * This frees a 128 bit private unique id previously generated
  */
-int skl_put_pvt_id(struct skl_sst *ctx, guid_t *uuid_mod, int *pvt_id)
+int skl_put_pvt_id(struct skl_dev *skl, guid_t *uuid_mod, int *pvt_id)
 {
         int i;
         struct uuid_module *module;
 
-        list_for_each_entry(module, &ctx->uuid_list, list) {
+        list_for_each_entry(module, &skl->uuid_list, list) {
                 if (guid_equal(uuid_mod, &module->uuid)) {
 
                         if (*pvt_id != 0)
@@ -234,7 +233,7 @@ int snd_skl_parse_uuids(struct sst_dsp *ctx, const struct firmware *fw,
         struct adsp_module_entry *mod_entry;
         int i, num_entry, size;
         const char *buf;
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         struct uuid_module *module;
         struct firmware stripped_fw;
         unsigned int safe_file;
@@ -317,11 +316,11 @@ free_uuid_list:
         return ret;
 }
 
-void skl_freeup_uuid_list(struct skl_sst *ctx)
+void skl_freeup_uuid_list(struct skl_dev *skl)
 {
         struct uuid_module *uuid, *_uuid;
 
-        list_for_each_entry_safe(uuid, _uuid, &ctx->uuid_list, list) {
+        list_for_each_entry_safe(uuid, _uuid, &skl->uuid_list, list) {
                 list_del(&uuid->list);
                 kfree(uuid);
         }
@@ -355,16 +354,12 @@ int skl_dsp_strip_extended_manifest(struct firmware *fw)
 }
 
 int skl_sst_ctx_init(struct device *dev, int irq, const char *fw_name,
-        struct skl_dsp_loader_ops dsp_ops, struct skl_sst **dsp,
+        struct skl_dsp_loader_ops dsp_ops, struct skl_dev **dsp,
         struct sst_dsp_device *skl_dev)
 {
-        struct skl_sst *skl;
+        struct skl_dev *skl = *dsp;
         struct sst_dsp *sst;
 
-        skl = devm_kzalloc(dev, sizeof(*skl), GFP_KERNEL);
-        if (skl == NULL)
-                return -ENOMEM;
-
         skl->dev = dev;
         skl_dev->thread_context = skl;
         INIT_LIST_HEAD(&skl->uuid_list);
@@ -381,13 +376,11 @@ int skl_sst_ctx_init(struct device *dev, int irq, const char *fw_name,
         INIT_LIST_HEAD(&sst->module_list);
 
         skl->is_first_boot = true;
-        if (dsp)
-                *dsp = skl;
 
         return 0;
 }
 
-int skl_prepare_lib_load(struct skl_sst *skl, struct skl_lib_info *linfo,
+int skl_prepare_lib_load(struct skl_dev *skl, struct skl_lib_info *linfo,
                 struct firmware *stripped_fw,
                 unsigned int hdr_offset, int index)
 {
diff --git a/sound/soc/intel/skylake/skl-sst.c b/sound/soc/intel/skylake/skl-sst.c
index 70c3a604c381..61a8e4756a2b 100644
--- a/sound/soc/intel/skylake/skl-sst.c
+++ b/sound/soc/intel/skylake/skl-sst.c
@@ -16,7 +16,7 @@
 #include "../common/sst-dsp.h"
 #include "../common/sst-dsp-priv.h"
 #include "../common/sst-ipc.h"
-#include "skl-sst-ipc.h"
+#include "skl.h"
 
 #define SKL_BASEFW_TIMEOUT      300
 #define SKL_INIT_TIMEOUT        1000
@@ -66,7 +66,7 @@ static int skl_transfer_firmware(struct sst_dsp *ctx,
 static int skl_load_base_firmware(struct sst_dsp *ctx)
 {
         int ret = 0, i;
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         struct firmware stripped_fw;
         u32 reg;
 
@@ -161,7 +161,7 @@ static int skl_set_dsp_D0(struct sst_dsp *ctx, unsigned int core_id)
 {
         int ret;
         struct skl_ipc_dxstate_info dx;
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         unsigned int core_mask = SKL_DSP_CORE_MASK(core_id);
 
         /* If core0 is being turned on, we need to load the FW */
@@ -215,7 +215,7 @@ static int skl_set_dsp_D3(struct sst_dsp *ctx, unsigned int core_id)
 {
         int ret;
         struct skl_ipc_dxstate_info dx;
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         unsigned int core_mask = SKL_DSP_CORE_MASK(core_id);
 
         dx.core_mask = core_mask;
@@ -332,7 +332,7 @@ static int skl_transfer_module(struct sst_dsp *ctx, const void *data,
                         u32 size, u16 mod_id, u8 table_id, bool is_module)
 {
         int ret, bytes_left, curr_pos;
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         skl->mod_load_complete = false;
 
         bytes_left = ctx->cl_dev.ops.cl_copy_to_dmabuf(ctx, data, size, false);
@@ -384,7 +384,7 @@ out:
 static int
 skl_load_library(struct sst_dsp *ctx, struct skl_lib_info *linfo, int lib_count)
 {
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         struct firmware stripped_fw;
         int ret, i;
 
@@ -413,8 +413,7 @@ static int skl_load_module(struct sst_dsp *ctx, u16 mod_id, u8 *guid)
         int ret = 0;
         char mod_name[64]; /* guid str = 32 chars + 4 hyphens */
 
-        snprintf(mod_name, sizeof(mod_name), "%s%pUL%s",
-                                             "intel/dsp_fw_", guid, ".bin");
+        snprintf(mod_name, sizeof(mod_name), "intel/dsp_fw_%pUL.bin", guid);
 
         module_entry = skl_module_get_from_id(ctx, mod_id);
         if (module_entry == NULL) {
@@ -443,7 +442,7 @@ static int skl_load_module(struct sst_dsp *ctx, u16 mod_id, u8 *guid)
 static int skl_unload_module(struct sst_dsp *ctx, u16 mod_id)
 {
         int usage_cnt;
-        struct skl_sst *skl = ctx->thread_context;
+        struct skl_dev *skl = ctx->thread_context;
         int ret = 0;
 
         usage_cnt = skl_put_module(ctx, mod_id);
@@ -518,9 +517,10 @@ static struct sst_dsp_device skl_dev = {
 };
 
 int skl_sst_dsp_init(struct device *dev, void __iomem *mmio_base, int irq,
-                const char *fw_name, struct skl_dsp_loader_ops dsp_ops, struct skl_sst **dsp)
+                const char *fw_name, struct skl_dsp_loader_ops dsp_ops,
+                struct skl_dev **dsp)
 {
-        struct skl_sst *skl;
+        struct skl_dev *skl;
         struct sst_dsp *sst;
         int ret;
 
@@ -554,10 +554,10 @@ int skl_sst_dsp_init(struct device *dev, void __iomem *mmio_base, int irq,
 }
 EXPORT_SYMBOL_GPL(skl_sst_dsp_init);
 
-int skl_sst_init_fw(struct device *dev, struct skl_sst *ctx)
+int skl_sst_init_fw(struct device *dev, struct skl_dev *skl)
 {
         int ret;
-        struct sst_dsp *sst = ctx->dsp;
+        struct sst_dsp *sst = skl->dsp;
 
         ret = sst->fw_ops.load_fw(sst);
         if (ret < 0) {
@@ -567,32 +567,32 @@ int skl_sst_init_fw(struct device *dev, struct skl_sst *ctx)
 
         skl_dsp_init_core_state(sst);
 
-        if (ctx->lib_count > 1) {
-                ret = sst->fw_ops.load_library(sst, ctx->lib_info,
-                                                ctx->lib_count);
+        if (skl->lib_count > 1) {
+                ret = sst->fw_ops.load_library(sst, skl->lib_info,
+                                                skl->lib_count);
                 if (ret < 0) {
                         dev_err(dev, "Load Library failed : %x\n", ret);
                         return ret;
                 }
         }
-        ctx->is_first_boot = false;
+        skl->is_first_boot = false;
 
         return 0;
 }
 EXPORT_SYMBOL_GPL(skl_sst_init_fw);
 
-void skl_sst_dsp_cleanup(struct device *dev, struct skl_sst *ctx)
+void skl_sst_dsp_cleanup(struct device *dev, struct skl_dev *skl)
 {
 
-        if (ctx->dsp->fw)
-                release_firmware(ctx->dsp->fw);
-        skl_clear_module_table(ctx->dsp);
-        skl_freeup_uuid_list(ctx);
-        skl_ipc_free(&ctx->ipc);
-        ctx->dsp->ops->free(ctx->dsp);
-        if (ctx->boot_complete) {
-                ctx->dsp->cl_dev.ops.cl_cleanup_controller(ctx->dsp);
-                skl_cldma_int_disable(ctx->dsp);
+        if (skl->dsp->fw)
+                release_firmware(skl->dsp->fw);
+        skl_clear_module_table(skl->dsp);
+        skl_freeup_uuid_list(skl);
+        skl_ipc_free(&skl->ipc);
+        skl->dsp->ops->free(skl->dsp);
+        if (skl->boot_complete) {
+                skl->dsp->cl_dev.ops.cl_cleanup_controller(skl->dsp);
+                skl_cldma_int_disable(skl->dsp);
         }
 }
 EXPORT_SYMBOL_GPL(skl_sst_dsp_cleanup);
diff --git a/sound/soc/intel/skylake/skl-topology.c b/sound/soc/intel/skylake/skl-topology.c
index 6241e35213af..69cd7a81bf2a 100644
--- a/sound/soc/intel/skylake/skl-topology.c
+++ b/sound/soc/intel/skylake/skl-topology.c
@@ -12,6 +12,7 @@
 #include <linux/types.h>
 #include <linux/firmware.h>
 #include <linux/uuid.h>
+#include <sound/intel-nhlt.h>
 #include <sound/soc.h>
 #include <sound/soc-topology.h>
 #include <uapi/sound/snd_sst_tokens.h>
@@ -45,9 +46,9 @@ static const int mic_quatro_list[][SKL_CH_QUATRO] = {
 #define CHECK_HW_PARAMS(ch, freq, bps, prm_ch, prm_freq, prm_bps) \
         ((ch == prm_ch) && (bps == prm_bps) && (freq == prm_freq))
 
-void skl_tplg_d0i3_get(struct skl *skl, enum d0i3_capability caps)
+void skl_tplg_d0i3_get(struct skl_dev *skl, enum d0i3_capability caps)
 {
-        struct skl_d0i3_data *d0i3 =  &skl->skl_sst->d0i3;
+        struct skl_d0i3_data *d0i3 =  &skl->d0i3;
 
         switch (caps) {
         case SKL_D0I3_NONE:
@@ -64,9 +65,9 @@ void skl_tplg_d0i3_get(struct skl *skl, enum d0i3_capability caps)
         }
 }
 
-void skl_tplg_d0i3_put(struct skl *skl, enum d0i3_capability caps)
+void skl_tplg_d0i3_put(struct skl_dev *skl, enum d0i3_capability caps)
 {
-        struct skl_d0i3_data *d0i3 =  &skl->skl_sst->d0i3;
+        struct skl_d0i3_data *d0i3 =  &skl->d0i3;
 
         switch (caps) {
         case SKL_D0I3_NONE:
@@ -109,118 +110,23 @@ static int is_skl_dsp_widget_type(struct snd_soc_dapm_widget *w,
         }
 }
 
-/*
- * Each pipelines needs memory to be allocated. Check if we have free memory
- * from available pool.
- */
-static bool skl_is_pipe_mem_avail(struct skl *skl,
-                                struct skl_module_cfg *mconfig)
-{
-        struct skl_sst *ctx = skl->skl_sst;
-
-        if (skl->resource.mem + mconfig->pipe->memory_pages >
-                                skl->resource.max_mem) {
-                dev_err(ctx->dev,
-                                "%s: module_id %d instance %d\n", __func__,
-                                mconfig->id.module_id,
-                                mconfig->id.instance_id);
-                dev_err(ctx->dev,
-                                "exceeds ppl memory available %d mem %d\n",
-                                skl->resource.max_mem, skl->resource.mem);
-                return false;
-        } else {
-                return true;
-        }
-}
-
-/*
- * Add the mem to the mem pool. This is freed when pipe is deleted.
- * Note: DSP does actual memory management we only keep track for complete
- * pool
- */
-static void skl_tplg_alloc_pipe_mem(struct skl *skl,
-                                struct skl_module_cfg *mconfig)
-{
-        skl->resource.mem += mconfig->pipe->memory_pages;
-}
-
-/*
- * Pipeline needs needs DSP CPU resources for computation, this is
- * quantified in MCPS (Million Clocks Per Second) required for module/pipe
- *
- * Each pipelines needs mcps to be allocated. Check if we have mcps for this
- * pipe.
- */
-
-static bool skl_is_pipe_mcps_avail(struct skl *skl,
-                                struct skl_module_cfg *mconfig)
-{
-        struct skl_sst *ctx = skl->skl_sst;
-        u8 res_idx = mconfig->res_idx;
-        struct skl_module_res *res = &mconfig->module->resources[res_idx];
-
-        if (skl->resource.mcps + res->cps > skl->resource.max_mcps) {
-                dev_err(ctx->dev,
-                        "%s: module_id %d instance %d\n", __func__,
-                        mconfig->id.module_id, mconfig->id.instance_id);
-                dev_err(ctx->dev,
-                        "exceeds ppl mcps available %d > mem %d\n",
-                        skl->resource.max_mcps, skl->resource.mcps);
-                return false;
-        } else {
-                return true;
-        }
-}
-
-static void skl_tplg_alloc_pipe_mcps(struct skl *skl,
-                                struct skl_module_cfg *mconfig)
-{
-        u8 res_idx = mconfig->res_idx;
-        struct skl_module_res *res = &mconfig->module->resources[res_idx];
-
-        skl->resource.mcps += res->cps;
-}
-
-/*
- * Free the mcps when tearing down
- */
-static void
-skl_tplg_free_pipe_mcps(struct skl *skl, struct skl_module_cfg *mconfig)
-{
-        u8 res_idx = mconfig->res_idx;
-        struct skl_module_res *res = &mconfig->module->resources[res_idx];
-
-        skl->resource.mcps -= res->cps;
-}
-
-/*
- * Free the memory when tearing down
- */
-static void
-skl_tplg_free_pipe_mem(struct skl *skl, struct skl_module_cfg *mconfig)
-{
-        skl->resource.mem -= mconfig->pipe->memory_pages;
-}
-
-
-static void skl_dump_mconfig(struct skl_sst *ctx,
-                                        struct skl_module_cfg *mcfg)
+static void skl_dump_mconfig(struct skl_dev *skl, struct skl_module_cfg *mcfg)
 {
         struct skl_module_iface *iface = &mcfg->module->formats[0];
 
-        dev_dbg(ctx->dev, "Dumping config\n");
-        dev_dbg(ctx->dev, "Input Format:\n");
-        dev_dbg(ctx->dev, "channels = %d\n", iface->inputs[0].fmt.channels);
-        dev_dbg(ctx->dev, "s_freq = %d\n", iface->inputs[0].fmt.s_freq);
-        dev_dbg(ctx->dev, "ch_cfg = %d\n", iface->inputs[0].fmt.ch_cfg);
-        dev_dbg(ctx->dev, "valid bit depth = %d\n",
+        dev_dbg(skl->dev, "Dumping config\n");
+        dev_dbg(skl->dev, "Input Format:\n");
+        dev_dbg(skl->dev, "channels = %d\n", iface->inputs[0].fmt.channels);
+        dev_dbg(skl->dev, "s_freq = %d\n", iface->inputs[0].fmt.s_freq);
+        dev_dbg(skl->dev, "ch_cfg = %d\n", iface->inputs[0].fmt.ch_cfg);
+        dev_dbg(skl->dev, "valid bit depth = %d\n",
                                 iface->inputs[0].fmt.valid_bit_depth);
-        dev_dbg(ctx->dev, "Output Format:\n");
-        dev_dbg(ctx->dev, "channels = %d\n", iface->outputs[0].fmt.channels);
-        dev_dbg(ctx->dev, "s_freq = %d\n", iface->outputs[0].fmt.s_freq);
-        dev_dbg(ctx->dev, "valid bit depth = %d\n",
+        dev_dbg(skl->dev, "Output Format:\n");
+        dev_dbg(skl->dev, "channels = %d\n", iface->outputs[0].fmt.channels);
+        dev_dbg(skl->dev, "s_freq = %d\n", iface->outputs[0].fmt.s_freq);
+        dev_dbg(skl->dev, "valid bit depth = %d\n",
                                 iface->outputs[0].fmt.valid_bit_depth);
-        dev_dbg(ctx->dev, "ch_cfg = %d\n", iface->outputs[0].fmt.ch_cfg);
+        dev_dbg(skl->dev, "ch_cfg = %d\n", iface->outputs[0].fmt.ch_cfg);
 }
 
 static void skl_tplg_update_chmap(struct skl_module_fmt *fmt, int chs)
@@ -322,7 +228,7 @@ static void skl_tplg_update_params_fixup(struct skl_module_cfg *m_cfg,
  * params, so once we have calculate params, we need buffer calculation as
  * well.
  */
-static void skl_tplg_update_buffer_size(struct skl_sst *ctx,
+static void skl_tplg_update_buffer_size(struct skl_dev *skl,
                                 struct skl_module_cfg *mcfg)
 {
         int multiplier = 1;
@@ -374,13 +280,12 @@ static u8 skl_tplg_be_dev_type(int dev_type)
 }
 
 static int skl_tplg_update_be_blob(struct snd_soc_dapm_widget *w,
-                                                struct skl_sst *ctx)
+                                                struct skl_dev *skl)
 {
         struct skl_module_cfg *m_cfg = w->priv;
         int link_type, dir;
         u32 ch, s_freq, s_fmt;
         struct nhlt_specific_cfg *cfg;
-        struct skl *skl = get_skl_ctx(ctx->dev);
         u8 dev_type = skl_tplg_be_dev_type(m_cfg->dev_type);
         int fmt_idx = m_cfg->fmt_idx;
         struct skl_module_iface *m_iface = &m_cfg->module->formats[fmt_idx];
@@ -389,7 +294,7 @@ static int skl_tplg_update_be_blob(struct snd_soc_dapm_widget *w,
         if (m_cfg->formats_config.caps_size > 0)
                 return 0;
 
-        dev_dbg(ctx->dev, "Applying default cfg blob\n");
+        dev_dbg(skl->dev, "Applying default cfg blob\n");
         switch (m_cfg->dev_type) {
         case SKL_DEVICE_DMIC:
                 link_type = NHLT_LINK_DMIC;
@@ -425,9 +330,9 @@ static int skl_tplg_update_be_blob(struct snd_soc_dapm_widget *w,
                 m_cfg->formats_config.caps_size = cfg->size;
                 m_cfg->formats_config.caps = (u32 *) &cfg->caps;
         } else {
-                dev_err(ctx->dev, "Blob NULL for id %x type %d dirn %d\n",
+                dev_err(skl->dev, "Blob NULL for id %x type %d dirn %d\n",
                                         m_cfg->vbus_id, link_type, dir);
-                dev_err(ctx->dev, "PCM: ch %d, freq %d, fmt %d\n",
+                dev_err(skl->dev, "PCM: ch %d, freq %d, fmt %d\n",
                                         ch, s_freq, s_fmt);
                 return -EIO;
         }
@@ -436,7 +341,7 @@ static int skl_tplg_update_be_blob(struct snd_soc_dapm_widget *w,
 }
 
 static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w,
-                                                        struct skl_sst *ctx)
+                                                        struct skl_dev *skl)
 {
         struct skl_module_cfg *m_cfg = w->priv;
         struct skl_pipe_params *params = m_cfg->pipe->p_params;
@@ -446,10 +351,10 @@ static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w,
         if (!m_cfg->params_fixup)
                 return;
 
-        dev_dbg(ctx->dev, "Mconfig for widget=%s BEFORE updation\n",
+        dev_dbg(skl->dev, "Mconfig for widget=%s BEFORE updation\n",
                                 w->name);
 
-        skl_dump_mconfig(ctx, m_cfg);
+        skl_dump_mconfig(skl, m_cfg);
 
         if (p_conn_type == SKL_PIPE_CONN_TYPE_FE)
                 is_fe = true;
@@ -457,12 +362,12 @@ static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w,
                 is_fe = false;
 
         skl_tplg_update_params_fixup(m_cfg, params, is_fe);
-        skl_tplg_update_buffer_size(ctx, m_cfg);
+        skl_tplg_update_buffer_size(skl, m_cfg);
 
-        dev_dbg(ctx->dev, "Mconfig for widget=%s AFTER updation\n",
+        dev_dbg(skl->dev, "Mconfig for widget=%s AFTER updation\n",
                                 w->name);
 
-        skl_dump_mconfig(ctx, m_cfg);
+        skl_dump_mconfig(skl, m_cfg);
 }
 
 /*
@@ -471,7 +376,7 @@ static void skl_tplg_update_module_params(struct snd_soc_dapm_widget *w,
  * set module params will be done after module is initialised.
  */
 static int skl_tplg_set_module_params(struct snd_soc_dapm_widget *w,
-                                                struct skl_sst *ctx)
+                                                struct skl_dev *skl)
 {
         int i, ret;
         struct skl_module_cfg *mconfig = w->priv;
@@ -483,7 +388,7 @@ static int skl_tplg_set_module_params(struct snd_soc_dapm_widget *w,
         if (mconfig->formats_config.caps_size > 0 &&
                 mconfig->formats_config.set_params == SKL_PARAM_SET) {
                 sp_cfg = &mconfig->formats_config;
-                ret = skl_set_module_params(ctx, sp_cfg->caps,
+                ret = skl_set_module_params(skl, sp_cfg->caps,
                                         sp_cfg->caps_size,
                                         sp_cfg->param_id, mconfig);
                 if (ret < 0)
@@ -497,7 +402,7 @@ static int skl_tplg_set_module_params(struct snd_soc_dapm_widget *w,
                         bc = (struct skl_algo_data *)sb->dobj.private;
 
                         if (bc->set_params == SKL_PARAM_SET) {
-                                ret = skl_set_module_params(ctx,
+                                ret = skl_set_module_params(skl,
                                                 (u32 *)bc->params, bc->size,
                                                 bc->param_id, mconfig);
                                 if (ret < 0)
@@ -542,15 +447,15 @@ static int skl_tplg_set_module_init_data(struct snd_soc_dapm_widget *w)
         return 0;
 }
 
-static int skl_tplg_module_prepare(struct skl_sst *ctx, struct skl_pipe *pipe,
+static int skl_tplg_module_prepare(struct skl_dev *skl, struct skl_pipe *pipe,
                 struct snd_soc_dapm_widget *w, struct skl_module_cfg *mcfg)
 {
         switch (mcfg->dev_type) {
         case SKL_DEVICE_HDAHOST:
-                return skl_pcm_host_dma_prepare(ctx->dev, pipe->p_params);
+                return skl_pcm_host_dma_prepare(skl->dev, pipe->p_params);
 
         case SKL_DEVICE_HDALINK:
-                return skl_pcm_link_dma_prepare(ctx->dev, pipe->p_params);
+                return skl_pcm_link_dma_prepare(skl->dev, pipe->p_params);
         }
 
         return 0;
@@ -562,12 +467,11 @@ static int skl_tplg_module_prepare(struct skl_sst *ctx, struct skl_pipe *pipe,
  * skl_init_module() routine, so invoke that for all modules in a pipeline
  */
 static int
-skl_tplg_init_pipe_modules(struct skl *skl, struct skl_pipe *pipe)
+skl_tplg_init_pipe_modules(struct skl_dev *skl, struct skl_pipe *pipe)
 {
         struct skl_pipe_module *w_module;
         struct snd_soc_dapm_widget *w;
         struct skl_module_cfg *mconfig;
-        struct skl_sst *ctx = skl->skl_sst;
         u8 cfg_idx;
         int ret = 0;
 
@@ -578,7 +482,7 @@ skl_tplg_init_pipe_modules(struct skl *skl, struct skl_pipe *pipe)
 
                 /* check if module ids are populated */
                 if (mconfig->id.module_id < 0) {
-                        dev_err(skl->skl_sst->dev,
+                        dev_err(skl->dev,
                                         "module %pUL id not populated\n",
                                         (guid_t *)mconfig->guid);
                         return -EIO;
@@ -588,12 +492,8 @@ skl_tplg_init_pipe_modules(struct skl *skl, struct skl_pipe *pipe)
                 mconfig->fmt_idx = mconfig->mod_cfg[cfg_idx].fmt_idx;
                 mconfig->res_idx = mconfig->mod_cfg[cfg_idx].res_idx;
 
-                /* check resource available */
-                if (!skl_is_pipe_mcps_avail(skl, mconfig))
-                        return -ENOMEM;
-
-                if (mconfig->module->loadable && ctx->dsp->fw_ops.load_mod) {
-                        ret = ctx->dsp->fw_ops.load_mod(ctx->dsp,
+                if (mconfig->module->loadable && skl->dsp->fw_ops.load_mod) {
+                        ret = skl->dsp->fw_ops.load_mod(skl->dsp,
                                 mconfig->id.module_id, mconfig->guid);
                         if (ret < 0)
                                 return ret;
@@ -602,50 +502,50 @@ skl_tplg_init_pipe_modules(struct skl *skl, struct skl_pipe *pipe)
                 }
 
                 /* prepare the DMA if the module is gateway cpr */
-                ret = skl_tplg_module_prepare(ctx, pipe, w, mconfig);
+                ret = skl_tplg_module_prepare(skl, pipe, w, mconfig);
                 if (ret < 0)
                         return ret;
 
                 /* update blob if blob is null for be with default value */
-                skl_tplg_update_be_blob(w, ctx);
+                skl_tplg_update_be_blob(w, skl);
 
                 /*
                  * apply fix/conversion to module params based on
                  * FE/BE params
                  */
-                skl_tplg_update_module_params(w, ctx);
+                skl_tplg_update_module_params(w, skl);
                 uuid_mod = (guid_t *)mconfig->guid;
-                mconfig->id.pvt_id = skl_get_pvt_id(ctx, uuid_mod,
+                mconfig->id.pvt_id = skl_get_pvt_id(skl, uuid_mod,
                                                 mconfig->id.instance_id);
                 if (mconfig->id.pvt_id < 0)
                         return ret;
                 skl_tplg_set_module_init_data(w);
 
-                ret = skl_dsp_get_core(ctx->dsp, mconfig->core_id);
+                ret = skl_dsp_get_core(skl->dsp, mconfig->core_id);
                 if (ret < 0) {
-                        dev_err(ctx->dev, "Failed to wake up core %d ret=%d\n",
+                        dev_err(skl->dev, "Failed to wake up core %d ret=%d\n",
                                                 mconfig->core_id, ret);
                         return ret;
                 }
 
-                ret = skl_init_module(ctx, mconfig);
+                ret = skl_init_module(skl, mconfig);
                 if (ret < 0) {
-                        skl_put_pvt_id(ctx, uuid_mod, &mconfig->id.pvt_id);
+                        skl_put_pvt_id(skl, uuid_mod, &mconfig->id.pvt_id);
                         goto err;
                 }
-                skl_tplg_alloc_pipe_mcps(skl, mconfig);
-                ret = skl_tplg_set_module_params(w, ctx);
+
+                ret = skl_tplg_set_module_params(w, skl);
                 if (ret < 0)
                         goto err;
         }
 
         return 0;
 err:
-        skl_dsp_put_core(ctx->dsp, mconfig->core_id);
+        skl_dsp_put_core(skl->dsp, mconfig->core_id);
         return ret;
 }
 
-static int skl_tplg_unload_pipe_modules(struct skl_sst *ctx,
+static int skl_tplg_unload_pipe_modules(struct skl_dev *skl,
          struct skl_pipe *pipe)
 {
         int ret = 0;
@@ -657,19 +557,19 @@ static int skl_tplg_unload_pipe_modules(struct skl_sst *ctx,
                 mconfig  = w_module->w->priv;
                 uuid_mod = (guid_t *)mconfig->guid;
 
-                if (mconfig->module->loadable && ctx->dsp->fw_ops.unload_mod &&
+                if (mconfig->module->loadable && skl->dsp->fw_ops.unload_mod &&
                         mconfig->m_state > SKL_MODULE_UNINIT) {
-                        ret = ctx->dsp->fw_ops.unload_mod(ctx->dsp,
+                        ret = skl->dsp->fw_ops.unload_mod(skl->dsp,
                                                 mconfig->id.module_id);
                         if (ret < 0)
                                 return -EIO;
                 }
-                skl_put_pvt_id(ctx, uuid_mod, &mconfig->id.pvt_id);
+                skl_put_pvt_id(skl, uuid_mod, &mconfig->id.pvt_id);
 
-                ret = skl_dsp_put_core(ctx->dsp, mconfig->core_id);
+                ret = skl_dsp_put_core(skl->dsp, mconfig->core_id);
                 if (ret < 0) {
                         /* don't return; continue with other modules */
-                        dev_err(ctx->dev, "Failed to sleep core %d ret=%d\n",
+                        dev_err(skl->dev, "Failed to sleep core %d ret=%d\n",
                                 mconfig->core_id, ret);
                 }
         }
@@ -686,9 +586,8 @@ static int skl_tplg_unload_pipe_modules(struct skl_sst *ctx,
  * 0th configuratation by default for such pipes.
  */
 static int
-skl_tplg_get_pipe_config(struct skl *skl, struct skl_module_cfg *mconfig)
+skl_tplg_get_pipe_config(struct skl_dev *skl, struct skl_module_cfg *mconfig)
 {
-        struct skl_sst *ctx = skl->skl_sst;
         struct skl_pipe *pipe = mconfig->pipe;
         struct skl_pipe_params *params = pipe->p_params;
         struct skl_path_config *pconfig = &pipe->configs[0];
@@ -702,7 +601,7 @@ skl_tplg_get_pipe_config(struct skl *skl, struct skl_module_cfg *mconfig)
         }
 
         if (pipe->conn_type == SKL_PIPE_CONN_TYPE_NONE) {
-                dev_dbg(ctx->dev, "No conn_type detected, take 0th config\n");
+                dev_dbg(skl->dev, "No conn_type detected, take 0th config\n");
                 pipe->cur_config_idx = 0;
                 pipe->memory_pages = pconfig->mem_pages;
 
@@ -726,13 +625,13 @@ skl_tplg_get_pipe_config(struct skl *skl, struct skl_module_cfg *mconfig)
                                     fmt->channels, fmt->freq, fmt->bps)) {
                         pipe->cur_config_idx = i;
                         pipe->memory_pages = pconfig->mem_pages;
-                        dev_dbg(ctx->dev, "Using pipe config: %d\n", i);
+                        dev_dbg(skl->dev, "Using pipe config: %d\n", i);
 
                         return 0;
                 }
         }
 
-        dev_err(ctx->dev, "Invalid pipe config: %d %d %d for pipe: %d\n",
+        dev_err(skl->dev, "Invalid pipe config: %d %d %d for pipe: %d\n",
                 params->ch, params->s_freq, params->s_fmt, pipe->ppl_id);
         return -EINVAL;
 }
@@ -740,44 +639,32 @@ skl_tplg_get_pipe_config(struct skl *skl, struct skl_module_cfg *mconfig)
 /*
  * Mixer module represents a pipeline. So in the Pre-PMU event of mixer we
  * need create the pipeline. So we do following:
- *   - check the resources
  *   - Create the pipeline
  *   - Initialize the modules in pipeline
  *   - finally bind all modules together
  */
 static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
-                                                        struct skl *skl)
+                                                        struct skl_dev *skl)
 {
         int ret;
         struct skl_module_cfg *mconfig = w->priv;
         struct skl_pipe_module *w_module;
         struct skl_pipe *s_pipe = mconfig->pipe;
         struct skl_module_cfg *src_module = NULL, *dst_module, *module;
-        struct skl_sst *ctx = skl->skl_sst;
         struct skl_module_deferred_bind *modules;
 
         ret = skl_tplg_get_pipe_config(skl, mconfig);
         if (ret < 0)
                 return ret;
 
-        /* check resource available */
-        if (!skl_is_pipe_mcps_avail(skl, mconfig))
-                return -EBUSY;
-
-        if (!skl_is_pipe_mem_avail(skl, mconfig))
-                return -ENOMEM;
-
         /*
          * Create a list of modules for pipe.
          * This list contains modules from source to sink
          */
-        ret = skl_create_pipeline(ctx, mconfig->pipe);
+        ret = skl_create_pipeline(skl, mconfig->pipe);
         if (ret < 0)
                 return ret;
 
-        skl_tplg_alloc_pipe_mem(skl, mconfig);
-        skl_tplg_alloc_pipe_mcps(skl, mconfig);
-
         /* Init all pipe modules from source to sink */
         ret = skl_tplg_init_pipe_modules(skl, s_pipe);
         if (ret < 0)
@@ -792,7 +679,7 @@ static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
                         continue;
                 }
 
-                ret = skl_bind_modules(ctx, src_module, dst_module);
+                ret = skl_bind_modules(skl, src_module, dst_module);
                 if (ret < 0)
                         return ret;
 
@@ -810,7 +697,7 @@ static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
                 list_for_each_entry(modules, &skl->bind_list, node) {
                         module = w_module->w->priv;
                         if (modules->dst == module)
-                                skl_bind_modules(ctx, modules->src,
+                                skl_bind_modules(skl, modules->src,
                                                         modules->dst);
                 }
         }
@@ -818,7 +705,7 @@ static int skl_tplg_mixer_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
         return 0;
 }
 
-static int skl_fill_sink_instance_id(struct skl_sst *ctx, u32 *params,
+static int skl_fill_sink_instance_id(struct skl_dev *skl, u32 *params,
                                 int size, struct skl_module_cfg *mcfg)
 {
         int i, pvt_id;
@@ -829,7 +716,7 @@ static int skl_fill_sink_instance_id(struct skl_sst *ctx, u32 *params,
                 struct skl_mod_inst_map *inst = kpb_params->u.map;
 
                 for (i = 0; i < kpb_params->num_modules; i++) {
-                        pvt_id = skl_get_pvt_instance_id_map(ctx, inst->mod_id,
+                        pvt_id = skl_get_pvt_instance_id_map(skl, inst->mod_id,
                                                                 inst->inst_id);
                         if (pvt_id < 0)
                                 return -EINVAL;
@@ -849,7 +736,7 @@ static int skl_fill_sink_instance_id(struct skl_sst *ctx, u32 *params,
  * send params after binding
  */
 static int skl_tplg_set_module_bind_params(struct snd_soc_dapm_widget *w,
-                        struct skl_module_cfg *mcfg, struct skl_sst *ctx)
+                        struct skl_module_cfg *mcfg, struct skl_dev *skl)
 {
         int i, ret;
         struct skl_module_cfg *mconfig = w->priv;
@@ -876,7 +763,7 @@ static int skl_tplg_set_module_bind_params(struct snd_soc_dapm_widget *w,
         if (mconfig->formats_config.caps_size > 0 &&
                 mconfig->formats_config.set_params == SKL_PARAM_BIND) {
                 sp_cfg = &mconfig->formats_config;
-                ret = skl_set_module_params(ctx, sp_cfg->caps,
+                ret = skl_set_module_params(skl, sp_cfg->caps,
                                         sp_cfg->caps_size,
                                         sp_cfg->param_id, mconfig);
                 if (ret < 0)
@@ -894,10 +781,10 @@ static int skl_tplg_set_module_bind_params(struct snd_soc_dapm_widget *w,
                                 if (!params)
                                         return -ENOMEM;
 
-                                skl_fill_sink_instance_id(ctx, params, bc->max,
+                                skl_fill_sink_instance_id(skl, params, bc->max,
                                                                 mconfig);
 
-                                ret = skl_set_module_params(ctx, params,
+                                ret = skl_set_module_params(skl, params,
                                                 bc->max, bc->param_id, mconfig);
                                 kfree(params);
 
@@ -910,11 +797,11 @@ static int skl_tplg_set_module_bind_params(struct snd_soc_dapm_widget *w,
         return 0;
 }
 
-static int skl_get_module_id(struct skl_sst *ctx, guid_t *uuid)
+static int skl_get_module_id(struct skl_dev *skl, guid_t *uuid)
 {
         struct uuid_module *module;
 
-        list_for_each_entry(module, &ctx->uuid_list, list) {
+        list_for_each_entry(module, &skl->uuid_list, list) {
                 if (guid_equal(uuid, &module->uuid))
                         return module->id;
         }
@@ -922,7 +809,7 @@ static int skl_get_module_id(struct skl_sst *ctx, guid_t *uuid)
         return -EINVAL;
 }
 
-static int skl_tplg_find_moduleid_from_uuid(struct skl *skl,
+static int skl_tplg_find_moduleid_from_uuid(struct skl_dev *skl,
                                         const struct snd_kcontrol_new *k)
 {
         struct soc_bytes_ext *sb = (void *) k->private_value;
@@ -942,7 +829,7 @@ static int skl_tplg_find_moduleid_from_uuid(struct skl *skl,
                 params->num_modules = uuid_params->num_modules;
 
                 for (i = 0; i < uuid_params->num_modules; i++) {
-                        module_id = skl_get_module_id(skl->skl_sst,
+                        module_id = skl_get_module_id(skl,
                                 &uuid_params->u.map_uuid[i].mod_uuid);
                         if (module_id < 0) {
                                 devm_kfree(bus->dev, params);
@@ -966,7 +853,7 @@ static int skl_tplg_find_moduleid_from_uuid(struct skl *skl,
  * Retrieve the module id from UUID mentioned in the
  * post bind params
  */
-void skl_tplg_add_moduleid_in_bind_params(struct skl *skl,
+void skl_tplg_add_moduleid_in_bind_params(struct skl_dev *skl,
                                 struct snd_soc_dapm_widget *w)
 {
         struct skl_module_cfg *mconfig = w->priv;
@@ -985,12 +872,12 @@ void skl_tplg_add_moduleid_in_bind_params(struct skl *skl,
                         SNDRV_CTL_ELEM_ACCESS_TLV_CALLBACK) &&
                         (skl_tplg_find_moduleid_from_uuid(skl,
                         &w->kcontrol_news[i]) < 0))
-                        dev_err(skl->skl_sst->dev,
+                        dev_err(skl->dev,
                                 "%s: invalid kpb post bind params\n",
                                 __func__);
 }
 
-static int skl_tplg_module_add_deferred_bind(struct skl *skl,
+static int skl_tplg_module_add_deferred_bind(struct skl_dev *skl,
         struct skl_module_cfg *src, struct skl_module_cfg *dst)
 {
         struct skl_module_deferred_bind *m_list, *modules;
@@ -1028,26 +915,27 @@ static int skl_tplg_module_add_deferred_bind(struct skl *skl,
 }
 
 static int skl_tplg_bind_sinks(struct snd_soc_dapm_widget *w,
-                                struct skl *skl,
+                                struct skl_dev *skl,
                                 struct snd_soc_dapm_widget *src_w,
                                 struct skl_module_cfg *src_mconfig)
 {
         struct snd_soc_dapm_path *p;
         struct snd_soc_dapm_widget *sink = NULL, *next_sink = NULL;
         struct skl_module_cfg *sink_mconfig;
-        struct skl_sst *ctx = skl->skl_sst;
         int ret;
 
         snd_soc_dapm_widget_for_each_sink_path(w, p) {
                 if (!p->connect)
                         continue;
 
-                dev_dbg(ctx->dev, "%s: src widget=%s\n", __func__, w->name);
-                dev_dbg(ctx->dev, "%s: sink widget=%s\n", __func__, p->sink->name);
+                dev_dbg(skl->dev,
+                        "%s: src widget=%s\n", __func__, w->name);
+                dev_dbg(skl->dev,
+                        "%s: sink widget=%s\n", __func__, p->sink->name);
 
                 next_sink = p->sink;
 
-                if (!is_skl_dsp_widget_type(p->sink, ctx->dev))
+                if (!is_skl_dsp_widget_type(p->sink, skl->dev))
                         return skl_tplg_bind_sinks(p->sink, skl, src_w, src_mconfig);
 
                 /*
@@ -1056,7 +944,7 @@ static int skl_tplg_bind_sinks(struct snd_soc_dapm_widget *w,
                  * they are ones used for SKL so check that first
                  */
                 if ((p->sink->priv != NULL) &&
-                                is_skl_dsp_widget_type(p->sink, ctx->dev)) {
+                                is_skl_dsp_widget_type(p->sink, skl->dev)) {
 
                         sink = p->sink;
                         sink_mconfig = sink->priv;
@@ -1088,19 +976,21 @@ static int skl_tplg_bind_sinks(struct snd_soc_dapm_widget *w,
                                 continue;
 
                         /* Bind source to sink, mixin is always source */
-                        ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
+                        ret = skl_bind_modules(skl, src_mconfig, sink_mconfig);
                         if (ret)
                                 return ret;
 
                         /* set module params after bind */
-                        skl_tplg_set_module_bind_params(src_w, src_mconfig, ctx);
-                        skl_tplg_set_module_bind_params(sink, sink_mconfig, ctx);
+                        skl_tplg_set_module_bind_params(src_w,
+                                        src_mconfig, skl);
+                        skl_tplg_set_module_bind_params(sink,
+                                        sink_mconfig, skl);
 
                         /* Start sinks pipe first */
                         if (sink_mconfig->pipe->state != SKL_PIPE_STARTED) {
                                 if (sink_mconfig->pipe->conn_type !=
                                                         SKL_PIPE_CONN_TYPE_FE)
-                                        ret = skl_run_pipe(ctx,
+                                        ret = skl_run_pipe(skl,
                                                         sink_mconfig->pipe);
                                 if (ret)
                                         return ret;
@@ -1125,10 +1015,9 @@ static int skl_tplg_bind_sinks(struct snd_soc_dapm_widget *w,
  *   - Then run current pipe
  */
 static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
-                                                                struct skl *skl)
+                                                        struct skl_dev *skl)
 {
         struct skl_module_cfg *src_mconfig;
-        struct skl_sst *ctx = skl->skl_sst;
         int ret = 0;
 
         src_mconfig = w->priv;
@@ -1144,25 +1033,24 @@ static int skl_tplg_pga_dapm_pre_pmu_event(struct snd_soc_dapm_widget *w,
 
         /* Start source pipe last after starting all sinks */
         if (src_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
-                return skl_run_pipe(ctx, src_mconfig->pipe);
+                return skl_run_pipe(skl, src_mconfig->pipe);
 
         return 0;
 }
 
 static struct snd_soc_dapm_widget *skl_get_src_dsp_widget(
-                struct snd_soc_dapm_widget *w, struct skl *skl)
+                struct snd_soc_dapm_widget *w, struct skl_dev *skl)
 {
         struct snd_soc_dapm_path *p;
         struct snd_soc_dapm_widget *src_w = NULL;
-        struct skl_sst *ctx = skl->skl_sst;
 
         snd_soc_dapm_widget_for_each_source_path(w, p) {
                 src_w = p->source;
                 if (!p->connect)
                         continue;
 
-                dev_dbg(ctx->dev, "sink widget=%s\n", w->name);
-                dev_dbg(ctx->dev, "src widget=%s\n", p->source->name);
+                dev_dbg(skl->dev, "sink widget=%s\n", w->name);
+                dev_dbg(skl->dev, "src widget=%s\n", p->source->name);
 
                 /*
                  * here we will check widgets in sink pipelines, so that can
@@ -1170,7 +1058,7 @@ static struct snd_soc_dapm_widget *skl_get_src_dsp_widget(
                  * ones used for SKL so check that first
                  */
                 if ((p->source->priv != NULL) &&
-                                is_skl_dsp_widget_type(p->source, ctx->dev)) {
+                                is_skl_dsp_widget_type(p->source, skl->dev)) {
                         return p->source;
                 }
         }
@@ -1191,12 +1079,11 @@ static struct snd_soc_dapm_widget *skl_get_src_dsp_widget(
  *      - start this pipeline
  */
 static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w,
-                                                        struct skl *skl)
+                                                        struct skl_dev *skl)
 {
         int ret = 0;
         struct snd_soc_dapm_widget *source, *sink;
         struct skl_module_cfg *src_mconfig, *sink_mconfig;
-        struct skl_sst *ctx = skl->skl_sst;
         int src_pipe_started = 0;
 
         sink = w;
@@ -1222,16 +1109,16 @@ static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w,
         }
 
         if (src_pipe_started) {
-                ret = skl_bind_modules(ctx, src_mconfig, sink_mconfig);
+                ret = skl_bind_modules(skl, src_mconfig, sink_mconfig);
                 if (ret)
                         return ret;
 
                 /* set module params after bind */
-                skl_tplg_set_module_bind_params(source, src_mconfig, ctx);
-                skl_tplg_set_module_bind_params(sink, sink_mconfig, ctx);
+                skl_tplg_set_module_bind_params(source, src_mconfig, skl);
+                skl_tplg_set_module_bind_params(sink, sink_mconfig, skl);
 
                 if (sink_mconfig->pipe->conn_type != SKL_PIPE_CONN_TYPE_FE)
-                        ret = skl_run_pipe(ctx, sink_mconfig->pipe);
+                        ret = skl_run_pipe(skl, sink_mconfig->pipe);
         }
 
         return ret;
@@ -1244,16 +1131,15 @@ static int skl_tplg_mixer_dapm_post_pmu_event(struct snd_soc_dapm_widget *w,
  *   - unbind with source pipelines if still connected
  */
 static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w,
-                                                        struct skl *skl)
+                                                        struct skl_dev *skl)
 {
         struct skl_module_cfg *src_mconfig, *sink_mconfig;
         int ret = 0, i;
-        struct skl_sst *ctx = skl->skl_sst;
 
         sink_mconfig = w->priv;
 
         /* Stop the pipe */
-        ret = skl_stop_pipe(ctx, sink_mconfig->pipe);
+        ret = skl_stop_pipe(skl, sink_mconfig->pipe);
         if (ret)
                 return ret;
 
@@ -1263,7 +1149,7 @@ static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w,
                         if (!src_mconfig)
                                 continue;
 
-                        ret = skl_unbind_modules(ctx,
+                        ret = skl_unbind_modules(skl,
                                                 src_mconfig, sink_mconfig);
                 }
         }
@@ -1273,28 +1159,22 @@ static int skl_tplg_mixer_dapm_pre_pmd_event(struct snd_soc_dapm_widget *w,
 
 /*
  * in the Post-PMD event of mixer we need to do following:
- *   - Free the mcps used
- *   - Free the mem used
  *   - Unbind the modules within the pipeline
  *   - Delete the pipeline (modules are not required to be explicitly
  *     deleted, pipeline delete is enough here
  */
 static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
-                                                        struct skl *skl)
+                                                        struct skl_dev *skl)
 {
         struct skl_module_cfg *mconfig = w->priv;
         struct skl_pipe_module *w_module;
         struct skl_module_cfg *src_module = NULL, *dst_module;
-        struct skl_sst *ctx = skl->skl_sst;
         struct skl_pipe *s_pipe = mconfig->pipe;
         struct skl_module_deferred_bind *modules, *tmp;
 
         if (s_pipe->state == SKL_PIPE_INVALID)
                 return -EINVAL;
 
-        skl_tplg_free_pipe_mcps(skl, mconfig);
-        skl_tplg_free_pipe_mem(skl, mconfig);
-
         list_for_each_entry(w_module, &s_pipe->w_list, node) {
                 if (list_empty(&skl->bind_list))
                         break;
@@ -1307,7 +1187,7 @@ static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
                          * modules from deferred bind list.
                          */
                         if (modules->dst == src_module) {
-                                skl_unbind_modules(ctx, modules->src,
+                                skl_unbind_modules(skl, modules->src,
                                                 modules->dst);
                         }
 
@@ -1327,44 +1207,40 @@ static int skl_tplg_mixer_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
         list_for_each_entry(w_module, &s_pipe->w_list, node) {
                 dst_module = w_module->w->priv;
 
-                if (mconfig->m_state >= SKL_MODULE_INIT_DONE)
-                        skl_tplg_free_pipe_mcps(skl, dst_module);
                 if (src_module == NULL) {
                         src_module = dst_module;
                         continue;
                 }
 
-                skl_unbind_modules(ctx, src_module, dst_module);
+                skl_unbind_modules(skl, src_module, dst_module);
                 src_module = dst_module;
         }
 
-        skl_delete_pipe(ctx, mconfig->pipe);
+        skl_delete_pipe(skl, mconfig->pipe);
 
         list_for_each_entry(w_module, &s_pipe->w_list, node) {
                 src_module = w_module->w->priv;
                 src_module->m_state = SKL_MODULE_UNINIT;
         }
 
-        return skl_tplg_unload_pipe_modules(ctx, s_pipe);
+        return skl_tplg_unload_pipe_modules(skl, s_pipe);
 }
 
 /*
  * in the Post-PMD event of PGA we need to do following:
- *   - Free the mcps used
  *   - Stop the pipeline
  *   - In source pipe is connected, unbind with source pipelines
  */
 static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
-                                                                struct skl *skl)
+                                                        struct skl_dev *skl)
 {
         struct skl_module_cfg *src_mconfig, *sink_mconfig;
         int ret = 0, i;
-        struct skl_sst *ctx = skl->skl_sst;
 
         src_mconfig = w->priv;
 
         /* Stop the pipe since this is a mixin module */
-        ret = skl_stop_pipe(ctx, src_mconfig->pipe);
+        ret = skl_stop_pipe(skl, src_mconfig->pipe);
         if (ret)
                 return ret;
 
@@ -1377,7 +1253,7 @@ static int skl_tplg_pga_dapm_post_pmd_event(struct snd_soc_dapm_widget *w,
                          * This is a connecter and if path is found that means
                          * unbind between source and sink has not happened yet
                          */
-                        ret = skl_unbind_modules(ctx, src_mconfig,
+                        ret = skl_unbind_modules(skl, src_mconfig,
                                                         sink_mconfig);
                 }
         }
@@ -1395,7 +1271,7 @@ static int skl_tplg_mixer_event(struct snd_soc_dapm_widget *w,
                                 struct snd_kcontrol *k, int event)
 {
         struct snd_soc_dapm_context *dapm = w->dapm;
-        struct skl *skl = get_skl_ctx(dapm->dev);
+        struct skl_dev *skl = get_skl_ctx(dapm->dev);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
@@ -1425,7 +1301,7 @@ static int skl_tplg_pga_event(struct snd_soc_dapm_widget *w,
 
 {
         struct snd_soc_dapm_context *dapm = w->dapm;
-        struct skl *skl = get_skl_ctx(dapm->dev);
+        struct skl_dev *skl = get_skl_ctx(dapm->dev);
 
         switch (event) {
         case SND_SOC_DAPM_PRE_PMU:
@@ -1446,10 +1322,10 @@ static int skl_tplg_tlv_control_get(struct snd_kcontrol *kcontrol,
         struct skl_algo_data *bc = (struct skl_algo_data *)sb->dobj.private;
         struct snd_soc_dapm_widget *w = snd_soc_dapm_kcontrol_widget(kcontrol);
         struct skl_module_cfg *mconfig = w->priv;
-        struct skl *skl = get_skl_ctx(w->dapm->dev);
+        struct skl_dev *skl = get_skl_ctx(w->dapm->dev);
 
         if (w->power)
-                skl_get_module_params(skl->skl_sst, (u32 *)bc->params,
+                skl_get_module_params(skl, (u32 *)bc->params,
                                       bc->size, bc->param_id, mconfig);
 
         /* decrement size for TLV header */
@@ -1481,7 +1357,7 @@ static int skl_tplg_tlv_control_set(struct snd_kcontrol *kcontrol,
         struct soc_bytes_ext *sb =
                         (struct soc_bytes_ext *)kcontrol->private_value;
         struct skl_algo_data *ac = (struct skl_algo_data *)sb->dobj.private;
-        struct skl *skl = get_skl_ctx(w->dapm->dev);
+        struct skl_dev *skl = get_skl_ctx(w->dapm->dev);
 
         if (ac->params) {
                 /*
@@ -1498,7 +1374,7 @@ static int skl_tplg_tlv_control_set(struct snd_kcontrol *kcontrol,
                         return -EFAULT;
 
                 if (w->power)
-                        return skl_set_module_params(skl->skl_sst,
+                        return skl_set_module_params(skl,
                                                 (u32 *)ac->params, ac->size,
                                                 ac->param_id, mconfig);
         }
@@ -1659,7 +1535,7 @@ int skl_tplg_update_pipe_params(struct device *dev,
                         struct skl_pipe_params *params)
 {
         struct skl_module_res *res = &mconfig->module->resources[0];
-        struct skl *skl = get_skl_ctx(dev);
+        struct skl_dev *skl = get_skl_ctx(dev);
         struct skl_module_fmt *format = NULL;
         u8 cfg_idx = mconfig->pipe->cur_config_idx;
 
@@ -1856,7 +1732,7 @@ static int skl_tplg_be_fill_pipe_params(struct snd_soc_dai *dai,
                                 struct skl_pipe_params *params)
 {
         struct nhlt_specific_cfg *cfg;
-        struct skl *skl = get_skl_ctx(dai->dev);
+        struct skl_dev *skl = get_skl_ctx(dai->dev);
         int link_type = skl_tplg_be_link_type(mconfig->dev_type);
         u8 dev_type = skl_tplg_be_dev_type(mconfig->dev_type);
 
@@ -2070,7 +1946,7 @@ static int skl_tplg_fill_pipe_tkn(struct device *dev,
  * Return an existing pipe if the pipe already exists.
  */
 static int skl_tplg_add_pipe(struct device *dev,
-                struct skl_module_cfg *mconfig, struct skl *skl,
+                struct skl_module_cfg *mconfig, struct skl_dev *skl,
                 struct snd_soc_tplg_vendor_value_elem *tkn_elem)
 {
         struct skl_pipeline *ppl;
@@ -2330,10 +2206,6 @@ static int skl_tplg_fill_res_tkn(struct device *dev,
                 return -EINVAL;
 
         switch (tkn_elem->token) {
-        case SKL_TKN_MM_U32_CPS:
-                res->cps = tkn_elem->value;
-                break;
-
         case SKL_TKN_MM_U32_DMA_SIZE:
                 res->dma_buffer_size = tkn_elem->value;
                 break;
@@ -2354,10 +2226,6 @@ static int skl_tplg_fill_res_tkn(struct device *dev,
                 res->ibs = tkn_elem->value;
                 break;
 
-        case SKL_TKN_U32_MAX_MCPS:
-                res->cps = tkn_elem->value;
-                break;
-
         case SKL_TKN_MM_U32_RES_PIN_ID:
         case SKL_TKN_MM_U32_PIN_BUF:
                 ret = skl_tplg_manifest_pin_res_tkn(dev, tkn_elem, res,
@@ -2366,6 +2234,11 @@ static int skl_tplg_fill_res_tkn(struct device *dev,
                         return ret;
                 break;
 
+        case SKL_TKN_MM_U32_CPS:
+        case SKL_TKN_U32_MAX_MCPS:
+                /* ignore unused tokens */
+                break;
+
         default:
                 dev_err(dev, "Not a res type token: %d", tkn_elem->token);
                 return -EINVAL;
@@ -2381,7 +2254,7 @@ static int skl_tplg_fill_res_tkn(struct device *dev,
  */
 static int skl_tplg_get_token(struct device *dev,
                 struct snd_soc_tplg_vendor_value_elem *tkn_elem,
-                struct skl *skl, struct skl_module_cfg *mconfig)
+                struct skl_dev *skl, struct skl_module_cfg *mconfig)
 {
         int tkn_count = 0;
         int ret;
@@ -2631,7 +2504,7 @@ static int skl_tplg_get_token(struct device *dev,
  * module private data
  */
 static int skl_tplg_get_tokens(struct device *dev,
-                char *pvt_data, struct skl *skl,
+                char *pvt_data, struct skl_dev *skl,
                 struct skl_module_cfg *mconfig, int block_size)
 {
         struct snd_soc_tplg_vendor_array *array;
@@ -2727,8 +2600,8 @@ static int skl_tplg_get_desc_blocks(struct device *dev,
  * Otherwise we create a new instance and add into driver list
  */
 static int skl_tplg_add_pipe_v4(struct device *dev,
-                                struct skl_module_cfg *mconfig, struct skl *skl,
-                                struct skl_dfw_v4_pipe *dfw_pipe)
+                        struct skl_module_cfg *mconfig, struct skl_dev *skl,
+                        struct skl_dfw_v4_pipe *dfw_pipe)
 {
         struct skl_pipeline *ppl;
         struct skl_pipe *pipe;
@@ -2804,7 +2677,7 @@ static void skl_tplg_fill_fmt_v4(struct skl_module_pin_fmt *dst_fmt,
 }
 
 static int skl_tplg_get_pvt_data_v4(struct snd_soc_tplg_dapm_widget *tplg_w,
-                                    struct skl *skl, struct device *dev,
+                                    struct skl_dev *skl, struct device *dev,
                                     struct skl_module_cfg *mconfig)
 {
         struct skl_dfw_v4_module *dfw =
@@ -2818,7 +2691,7 @@ static int skl_tplg_get_pvt_data_v4(struct snd_soc_tplg_dapm_widget *tplg_w,
                 return ret;
         mconfig->id.module_id = -1;
         mconfig->id.instance_id = dfw->instance_id;
-        mconfig->module->resources[0].cps = dfw->max_mcps;
+        mconfig->module->resources[0].cpc = dfw->max_mcps / 1000;
         mconfig->module->resources[0].ibs = dfw->ibs;
         mconfig->module->resources[0].obs = dfw->obs;
         mconfig->core_id = dfw->core_id;
@@ -2886,7 +2759,7 @@ static int skl_tplg_get_pvt_data_v4(struct snd_soc_tplg_dapm_widget *tplg_w,
  * for the type and size of the suceeding data block.
  */
 static int skl_tplg_get_pvt_data(struct snd_soc_tplg_dapm_widget *tplg_w,
-                                struct skl *skl, struct device *dev,
+                                struct skl_dev *skl, struct device *dev,
                                 struct skl_module_cfg *mconfig)
 {
         struct snd_soc_tplg_vendor_array *array;
@@ -2981,9 +2854,8 @@ static void skl_clear_pin_config(struct snd_soc_component *component,
         }
 }
 
-void skl_cleanup_resources(struct skl *skl)
+void skl_cleanup_resources(struct skl_dev *skl)
 {
-        struct skl_sst *ctx = skl->skl_sst;
         struct snd_soc_component *soc_component = skl->component;
         struct snd_soc_dapm_widget *w;
         struct snd_soc_card *card;
@@ -2995,15 +2867,12 @@ void skl_cleanup_resources(struct skl *skl)
         if (!card || !card->instantiated)
                 return;
 
-        skl->resource.mem = 0;
-        skl->resource.mcps = 0;
-
         list_for_each_entry(w, &card->widgets, list) {
-                if (is_skl_dsp_widget_type(w, ctx->dev) && w->priv != NULL)
+                if (is_skl_dsp_widget_type(w, skl->dev) && w->priv != NULL)
                         skl_clear_pin_config(soc_component, w);
         }
 
-        skl_clear_module_cnt(ctx->dsp);
+        skl_clear_module_cnt(skl->dsp);
 }
 
 /*
@@ -3019,7 +2888,7 @@ static int skl_tplg_widget_load(struct snd_soc_component *cmpnt, int index,
 {
         int ret;
         struct hdac_bus *bus = snd_soc_component_get_drvdata(cmpnt);
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         struct skl_module_cfg *mconfig;
 
         if (!tplg_w->priv.size)
@@ -3163,21 +3032,21 @@ static int skl_tplg_control_load(struct snd_soc_component *cmpnt,
 
 static int skl_tplg_fill_str_mfest_tkn(struct device *dev,
                 struct snd_soc_tplg_vendor_string_elem *str_elem,
-                struct skl *skl)
+                struct skl_dev *skl)
 {
         int tkn_count = 0;
         static int ref_count;
 
         switch (str_elem->token) {
         case SKL_TKN_STR_LIB_NAME:
-                if (ref_count > skl->skl_sst->lib_count - 1) {
+                if (ref_count > skl->lib_count - 1) {
                         ref_count = 0;
                         return -EINVAL;
                 }
 
-                strncpy(skl->skl_sst->lib_info[ref_count].name,
+                strncpy(skl->lib_info[ref_count].name,
                         str_elem->string,
-                        ARRAY_SIZE(skl->skl_sst->lib_info[ref_count].name));
+                        ARRAY_SIZE(skl->lib_info[ref_count].name));
                 ref_count++;
                 break;
 
@@ -3192,7 +3061,7 @@ static int skl_tplg_fill_str_mfest_tkn(struct device *dev,
 
 static int skl_tplg_get_str_tkn(struct device *dev,
                 struct snd_soc_tplg_vendor_array *array,
-                struct skl *skl)
+                struct skl_dev *skl)
 {
         int tkn_count = 0, ret;
         struct snd_soc_tplg_vendor_string_elem *str_elem;
@@ -3299,7 +3168,7 @@ static int skl_tplg_fill_mod_info(struct device *dev,
 
 static int skl_tplg_get_int_tkn(struct device *dev,
                 struct snd_soc_tplg_vendor_value_elem *tkn_elem,
-                struct skl *skl)
+                struct skl_dev *skl)
 {
         int tkn_count = 0, ret;
         static int mod_idx, res_val_idx, intf_val_idx, dir, pin_idx;
@@ -3319,7 +3188,7 @@ static int skl_tplg_get_int_tkn(struct device *dev,
 
         switch (tkn_elem->token) {
         case SKL_TKN_U32_LIB_COUNT:
-                skl->skl_sst->lib_count = tkn_elem->value;
+                skl->lib_count = tkn_elem->value;
                 break;
 
         case SKL_TKN_U8_NUM_MOD:
@@ -3465,35 +3334,17 @@ static int skl_tplg_get_int_tkn(struct device *dev,
         return tkn_count;
 }
 
-static int skl_tplg_get_manifest_uuid(struct device *dev,
-                                struct skl *skl,
-                                struct snd_soc_tplg_vendor_uuid_elem *uuid_tkn)
-{
-        static int ref_count;
-        struct skl_module *mod;
-
-        if (uuid_tkn->token == SKL_TKN_UUID) {
-                mod = skl->modules[ref_count];
-                guid_copy(&mod->uuid, (guid_t *)&uuid_tkn->uuid);
-                ref_count++;
-        } else {
-                dev_err(dev, "Not an UUID token tkn %d\n", uuid_tkn->token);
-                return -EINVAL;
-        }
-
-        return 0;
-}
-
 /*
  * Fill the manifest structure by parsing the tokens based on the
  * type.
  */
 static int skl_tplg_get_manifest_tkn(struct device *dev,
-                char *pvt_data, struct skl *skl,
+                char *pvt_data, struct skl_dev *skl,
                 int block_size)
 {
         int tkn_count = 0, ret;
         int off = 0, tuple_size = 0;
+        u8 uuid_index = 0;
         struct snd_soc_tplg_vendor_array *array;
         struct snd_soc_tplg_vendor_value_elem *tkn_elem;
 
@@ -3516,9 +3367,17 @@ static int skl_tplg_get_manifest_tkn(struct device *dev,
                         continue;
 
                 case SND_SOC_TPLG_TUPLE_TYPE_UUID:
-                        ret = skl_tplg_get_manifest_uuid(dev, skl, array->uuid);
-                        if (ret < 0)
-                                return ret;
+                        if (array->uuid->token != SKL_TKN_UUID) {
+                                dev_err(dev, "Not an UUID token: %d\n",
+                                        array->uuid->token);
+                                return -EINVAL;
+                        }
+                        if (uuid_index >= skl->nr_modules) {
+                                dev_err(dev, "Too many UUID tokens\n");
+                                return -EINVAL;
+                        }
+                        guid_copy(&skl->modules[uuid_index++]->uuid,
+                                  (guid_t *)&array->uuid->uuid);
 
                         tuple_size += sizeof(*array->uuid);
                         continue;
@@ -3550,7 +3409,7 @@ static int skl_tplg_get_manifest_tkn(struct device *dev,
  * preceded by descriptors for type and size of data block.
  */
 static int skl_tplg_get_manifest_data(struct snd_soc_tplg_manifest *manifest,
-                        struct device *dev, struct skl *skl)
+                        struct device *dev, struct skl_dev *skl)
 {
         struct snd_soc_tplg_vendor_array *array;
         int num_blocks, block_size = 0, block_type, off = 0;
@@ -3612,7 +3471,7 @@ static int skl_manifest_load(struct snd_soc_component *cmpnt, int index,
                                 struct snd_soc_tplg_manifest *manifest)
 {
         struct hdac_bus *bus = snd_soc_component_get_drvdata(cmpnt);
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
 
         /* proceed only if we have private data defined */
         if (manifest->priv.size == 0)
@@ -3620,9 +3479,9 @@ static int skl_manifest_load(struct snd_soc_component *cmpnt, int index,
 
         skl_tplg_get_manifest_data(manifest, bus->dev, skl);
 
-        if (skl->skl_sst->lib_count > SKL_MAX_LIB) {
+        if (skl->lib_count > SKL_MAX_LIB) {
                 dev_err(bus->dev, "Exceeding max Library count. Got:%d\n",
-                                        skl->skl_sst->lib_count);
+                                        skl->lib_count);
                 return  -EINVAL;
         }
 
@@ -3671,7 +3530,7 @@ static int skl_tplg_create_pipe_widget_list(struct snd_soc_component *component)
         return 0;
 }
 
-static void skl_tplg_set_pipe_type(struct skl *skl, struct skl_pipe *pipe)
+static void skl_tplg_set_pipe_type(struct skl_dev *skl, struct skl_pipe *pipe)
 {
         struct skl_pipe_module *w_module;
         struct snd_soc_dapm_widget *w;
@@ -3694,10 +3553,6 @@ static void skl_tplg_set_pipe_type(struct skl *skl, struct skl_pipe *pipe)
                 pipe->passthru = false;
 }
 
-/* This will be read from topology manifest, currently defined here */
-#define SKL_MAX_MCPS 30000000
-#define SKL_FW_MAX_MEM 1000000
-
 /*
  * SKL topology init routine
  */
@@ -3705,7 +3560,7 @@ int skl_tplg_init(struct snd_soc_component *component, struct hdac_bus *bus)
 {
         int ret;
         const struct firmware *fw;
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         struct skl_pipeline *ppl;
 
         ret = request_firmware(&fw, skl->tplg_name, bus->dev);
@@ -3724,31 +3579,30 @@ int skl_tplg_init(struct snd_soc_component *component, struct hdac_bus *bus)
          * The complete tplg for SKL is loaded as index 0, we don't use
          * any other index
          */
-        ret = snd_soc_tplg_component_load(component,
-                                        &skl_tplg_ops, fw, 0);
+        ret = snd_soc_tplg_component_load(component, &skl_tplg_ops, fw, 0);
         if (ret < 0) {
                 dev_err(bus->dev, "tplg component load failed%d\n", ret);
-                release_firmware(fw);
-                return -EINVAL;
+                goto err;
         }
 
-        skl->resource.max_mcps = SKL_MAX_MCPS;
-        skl->resource.max_mem = SKL_FW_MAX_MEM;
-
-        skl->tplg = fw;
         ret = skl_tplg_create_pipe_widget_list(component);
-        if (ret < 0)
-                return ret;
+        if (ret < 0) {
+                dev_err(bus->dev, "tplg create pipe widget list failed%d\n",
+                                ret);
+                goto err;
+        }
 
         list_for_each_entry(ppl, &skl->ppl_list, node)
                 skl_tplg_set_pipe_type(skl, ppl->pipe);
 
-        return 0;
+err:
+        release_firmware(fw);
+        return ret;
 }
 
 void skl_tplg_exit(struct snd_soc_component *component, struct hdac_bus *bus)
 {
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         struct skl_pipeline *ppl, *tmp;
 
         if (!list_empty(&skl->ppl_list))
@@ -3757,6 +3611,4 @@ void skl_tplg_exit(struct snd_soc_component *component, struct hdac_bus *bus)
 
         /* clean up topology */
         snd_soc_tplg_component_remove(component, SND_SOC_TPLG_INDEX_ALL);
-
-        release_firmware(skl->tplg);
 }
diff --git a/sound/soc/intel/skylake/skl-topology.h b/sound/soc/intel/skylake/skl-topology.h
index 665e35cee50d..e967800dbb62 100644
--- a/sound/soc/intel/skylake/skl-topology.h
+++ b/sound/soc/intel/skylake/skl-topology.h
@@ -101,7 +101,7 @@ struct skl_audio_data_format {
 } __packed;
 
 struct skl_base_cfg {
-        u32 cps;
+        u32 cpc;
         u32 ibs;
         u32 obs;
         u32 is_pages;
@@ -140,11 +140,6 @@ struct skl_src_module_cfg {
         enum skl_s_freq src_cfg;
 } __packed;
 
-struct notification_mask {
-        u32 notify;
-        u32 enable;
-} __packed;
-
 struct skl_up_down_mixer_cfg {
         struct skl_base_cfg base_cfg;
         enum skl_ch_cfg out_ch_cfg;
@@ -348,7 +343,6 @@ struct skl_module_pin_resources {
 struct skl_module_res {
         u8 id;
         u32 is_pages;
-        u32 cps;
         u32 ibs;
         u32 obs;
         u32 dma_buffer_size;
@@ -389,9 +383,6 @@ struct skl_module_cfg {
         u8 out_queue_mask;
         u8 in_queue;
         u8 out_queue;
-        u32 mcps;
-        u32 ibs;
-        u32 obs;
         u8 is_loadable;
         u8 core_id;
         u8 dev_type;
@@ -447,7 +438,7 @@ enum skl_channel {
         SKL_CH_QUATRO = 4,
 };
 
-static inline struct skl *get_skl_ctx(struct device *dev)
+static inline struct skl_dev *get_skl_ctx(struct device *dev)
 {
         struct hdac_bus *bus = dev_get_drvdata(dev);
 
@@ -456,7 +447,7 @@ static inline struct skl *get_skl_ctx(struct device *dev)
 
 int skl_tplg_be_update_params(struct snd_soc_dai *dai,
         struct skl_pipe_params *params);
-int skl_dsp_set_dma_control(struct skl_sst *ctx, u32 *caps,
+int skl_dsp_set_dma_control(struct skl_dev *skl, u32 *caps,
                         u32 caps_size, u32 node_id);
 void skl_tplg_set_be_dmic_config(struct snd_soc_dai *dai,
         struct skl_pipe_params *params, int stream);
@@ -469,32 +460,32 @@ struct skl_module_cfg *skl_tplg_fe_get_cpr_module(
 int skl_tplg_update_pipe_params(struct device *dev,
                 struct skl_module_cfg *mconfig, struct skl_pipe_params *params);
 
-void skl_tplg_d0i3_get(struct skl *skl, enum d0i3_capability caps);
-void skl_tplg_d0i3_put(struct skl *skl, enum d0i3_capability caps);
+void skl_tplg_d0i3_get(struct skl_dev *skl, enum d0i3_capability caps);
+void skl_tplg_d0i3_put(struct skl_dev *skl, enum d0i3_capability caps);
 
-int skl_create_pipeline(struct skl_sst *ctx, struct skl_pipe *pipe);
+int skl_create_pipeline(struct skl_dev *skl, struct skl_pipe *pipe);
 
-int skl_run_pipe(struct skl_sst *ctx, struct skl_pipe *pipe);
+int skl_run_pipe(struct skl_dev *skl, struct skl_pipe *pipe);
 
-int skl_pause_pipe(struct skl_sst *ctx, struct skl_pipe *pipe);
+int skl_pause_pipe(struct skl_dev *skl, struct skl_pipe *pipe);
 
-int skl_delete_pipe(struct skl_sst *ctx, struct skl_pipe *pipe);
+int skl_delete_pipe(struct skl_dev *skl, struct skl_pipe *pipe);
 
-int skl_stop_pipe(struct skl_sst *ctx, struct skl_pipe *pipe);
+int skl_stop_pipe(struct skl_dev *skl, struct skl_pipe *pipe);
 
-int skl_reset_pipe(struct skl_sst *ctx, struct skl_pipe *pipe);
+int skl_reset_pipe(struct skl_dev *skl, struct skl_pipe *pipe);
 
-int skl_init_module(struct skl_sst *ctx, struct skl_module_cfg *module_config);
+int skl_init_module(struct skl_dev *skl, struct skl_module_cfg *module_config);
 
-int skl_bind_modules(struct skl_sst *ctx, struct skl_module_cfg
+int skl_bind_modules(struct skl_dev *skl, struct skl_module_cfg
         *src_module, struct skl_module_cfg *dst_module);
 
-int skl_unbind_modules(struct skl_sst *ctx, struct skl_module_cfg
+int skl_unbind_modules(struct skl_dev *skl, struct skl_module_cfg
         *src_module, struct skl_module_cfg *dst_module);
 
-int skl_set_module_params(struct skl_sst *ctx, u32 *params, int size,
+int skl_set_module_params(struct skl_dev *skl, u32 *params, int size,
                         u32 param_id, struct skl_module_cfg *mcfg);
-int skl_get_module_params(struct skl_sst *ctx, u32 *params, int size,
+int skl_get_module_params(struct skl_dev *skl, u32 *params, int size,
                           u32 param_id, struct skl_module_cfg *mcfg);
 
 struct skl_module_cfg *skl_tplg_be_get_cpr_module(struct snd_soc_dai *dai,
@@ -508,6 +499,6 @@ int skl_pcm_link_dma_prepare(struct device *dev,
 int skl_dai_load(struct snd_soc_component *cmp, int index,
                 struct snd_soc_dai_driver *dai_drv,
                 struct snd_soc_tplg_pcm *pcm, struct snd_soc_dai *dai);
-void skl_tplg_add_moduleid_in_bind_params(struct skl *skl,
+void skl_tplg_add_moduleid_in_bind_params(struct skl_dev *skl,
                                 struct snd_soc_dapm_widget *w);
 #endif
diff --git a/sound/soc/intel/skylake/skl.c b/sound/soc/intel/skylake/skl.c
index 3362e71b4563..141dbbf975ac 100644
--- a/sound/soc/intel/skylake/skl.c
+++ b/sound/soc/intel/skylake/skl.c
@@ -26,9 +26,11 @@
 #include <sound/hdaudio.h>
 #include <sound/hda_i915.h>
 #include <sound/hda_codec.h>
+#include <sound/intel-nhlt.h>
 #include "skl.h"
 #include "skl-sst-dsp.h"
 #include "skl-sst-ipc.h"
+
 #if IS_ENABLED(CONFIG_SND_SOC_INTEL_SKYLAKE_HDAUDIO_CODEC)
 #include "../../../soc/codecs/hdac_hda.h"
 #endif
@@ -50,7 +52,7 @@ static void skl_update_pci_byte(struct pci_dev *pci, unsigned int reg,
         pci_write_config_byte(pci, reg, data);
 }
 
-static void skl_init_pci(struct skl *skl)
+static void skl_init_pci(struct skl_dev *skl)
 {
         struct hdac_bus *bus = skl_to_bus(skl);
 
@@ -132,7 +134,7 @@ static int skl_init_chip(struct hdac_bus *bus, bool full_reset)
 
         /* Reset stream-to-link mapping */
         list_for_each_entry(hlink, &bus->hlink_list, list)
-                bus->io_ops->reg_writel(0, hlink->ml_addr + AZX_REG_ML_LOSIDV);
+                writel(0, hlink->ml_addr + AZX_REG_ML_LOSIDV);
 
         skl_enable_miscbdcge(bus->dev, true);
 
@@ -252,7 +254,7 @@ static irqreturn_t skl_threaded_handler(int irq, void *dev_id)
 
 static int skl_acquire_irq(struct hdac_bus *bus, int do_disconnect)
 {
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         int ret;
 
         ret = request_threaded_irq(skl->pci->irq, skl_interrupt,
@@ -276,7 +278,7 @@ static int skl_suspend_late(struct device *dev)
 {
         struct pci_dev *pci = to_pci_dev(dev);
         struct hdac_bus *bus = pci_get_drvdata(pci);
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
 
         return skl_suspend_late_dsp(skl);
 }
@@ -284,7 +286,7 @@ static int skl_suspend_late(struct device *dev)
 #ifdef CONFIG_PM
 static int _skl_suspend(struct hdac_bus *bus)
 {
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         struct pci_dev *pci = to_pci_dev(bus->dev);
         int ret;
 
@@ -307,7 +309,7 @@ static int _skl_suspend(struct hdac_bus *bus)
 
 static int _skl_resume(struct hdac_bus *bus)
 {
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
 
         skl_init_pci(skl);
         skl_dum_set(bus);
@@ -325,7 +327,7 @@ static int skl_suspend(struct device *dev)
 {
         struct pci_dev *pci = to_pci_dev(dev);
         struct hdac_bus *bus = pci_get_drvdata(pci);
-        struct skl *skl  = bus_to_skl(bus);
+        struct skl_dev *skl  = bus_to_skl(bus);
         int ret;
 
         /*
@@ -345,7 +347,7 @@ static int skl_suspend(struct device *dev)
                 ret = _skl_suspend(bus);
                 if (ret < 0)
                         return ret;
-                skl->skl_sst->fw_loaded = false;
+                skl->fw_loaded = false;
         }
 
         return 0;
@@ -355,7 +357,7 @@ static int skl_resume(struct device *dev)
 {
         struct pci_dev *pci = to_pci_dev(dev);
         struct hdac_bus *bus = pci_get_drvdata(pci);
-        struct skl *skl  = bus_to_skl(bus);
+        struct skl_dev *skl  = bus_to_skl(bus);
         struct hdac_ext_link *hlink = NULL;
         int ret;
 
@@ -430,7 +432,7 @@ static const struct dev_pm_ops skl_pm = {
  */
 static int skl_free(struct hdac_bus *bus)
 {
-        struct skl *skl  = bus_to_skl(bus);
+        struct skl_dev *skl  = bus_to_skl(bus);
 
         skl->init_done = 0; /* to be sure */
 
@@ -475,7 +477,7 @@ static struct skl_ssp_clk skl_ssp_clks[] = {
                                                 {.name = "ssp5_sclkfs"},
 };
 
-static struct snd_soc_acpi_mach *skl_find_hda_machine(struct skl *skl,
+static struct snd_soc_acpi_mach *skl_find_hda_machine(struct skl_dev *skl,
                                         struct snd_soc_acpi_mach *machines)
 {
         struct hdac_bus *bus = skl_to_bus(skl);
@@ -494,7 +496,7 @@ static struct snd_soc_acpi_mach *skl_find_hda_machine(struct skl *skl,
         return mach;
 }
 
-static int skl_find_machine(struct skl *skl, void *driver_data)
+static int skl_find_machine(struct skl_dev *skl, void *driver_data)
 {
         struct hdac_bus *bus = skl_to_bus(skl);
         struct snd_soc_acpi_mach *mach = driver_data;
@@ -516,13 +518,15 @@ static int skl_find_machine(struct skl *skl, void *driver_data)
 
         if (pdata) {
                 skl->use_tplg_pcm = pdata->use_tplg_pcm;
-                mach->mach_params.dmic_num = skl_get_dmic_geo(skl);
+                mach->mach_params.dmic_num =
+                        intel_nhlt_get_dmic_geo(&skl->pci->dev,
+                                                skl->nhlt);
         }
 
         return 0;
 }
 
-static int skl_machine_device_register(struct skl *skl)
+static int skl_machine_device_register(struct skl_dev *skl)
 {
         struct snd_soc_acpi_mach *mach = skl->mach;
         struct hdac_bus *bus = skl_to_bus(skl);
@@ -558,13 +562,13 @@ static int skl_machine_device_register(struct skl *skl)
         return 0;
 }
 
-static void skl_machine_device_unregister(struct skl *skl)
+static void skl_machine_device_unregister(struct skl_dev *skl)
 {
         if (skl->i2s_dev)
                 platform_device_unregister(skl->i2s_dev);
 }
 
-static int skl_dmic_device_register(struct skl *skl)
+static int skl_dmic_device_register(struct skl_dev *skl)
 {
         struct hdac_bus *bus = skl_to_bus(skl);
         struct platform_device *pdev;
@@ -588,7 +592,7 @@ static int skl_dmic_device_register(struct skl *skl)
         return 0;
 }
 
-static void skl_dmic_device_unregister(struct skl *skl)
+static void skl_dmic_device_unregister(struct skl_dev *skl)
 {
         if (skl->dmic_dev)
                 platform_device_unregister(skl->dmic_dev);
@@ -626,7 +630,7 @@ static void init_skl_xtal_rate(int pci_id)
         }
 }
 
-static int skl_clock_device_register(struct skl *skl)
+static int skl_clock_device_register(struct skl_dev *skl)
 {
         struct platform_device_info pdevinfo = {NULL};
         struct skl_clk_pdata *clk_pdata;
@@ -656,7 +660,7 @@ static int skl_clock_device_register(struct skl *skl)
         return PTR_ERR_OR_ZERO(skl->clk_dev);
 }
 
-static void skl_clock_device_unregister(struct skl *skl)
+static void skl_clock_device_unregister(struct skl_dev *skl)
 {
         if (skl->clk_dev)
                 platform_device_unregister(skl->clk_dev);
@@ -692,7 +696,7 @@ static int probe_codec(struct hdac_bus *bus, int addr)
         unsigned int cmd = (addr << 28) | (AC_NODE_ROOT << 20) |
                 (AC_VERB_PARAMETERS << 8) | AC_PAR_VENDOR_ID;
         unsigned int res = -1;
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
 #if IS_ENABLED(CONFIG_SND_SOC_INTEL_SKYLAKE_HDAUDIO_CODEC)
         struct hdac_hda_priv *hda_codec;
         int err;
@@ -792,7 +796,7 @@ static int skl_i915_init(struct hdac_bus *bus)
 
 static void skl_probe_work(struct work_struct *work)
 {
-        struct skl *skl = container_of(work, struct skl, probe_work);
+        struct skl_dev *skl = container_of(work, struct skl_dev, probe_work);
         struct hdac_bus *bus = skl_to_bus(skl);
         struct hdac_ext_link *hlink = NULL;
         int err;
@@ -854,11 +858,10 @@ out_err:
  * constructor
  */
 static int skl_create(struct pci_dev *pci,
-                      const struct hdac_io_ops *io_ops,
-                      struct skl **rskl)
+                      struct skl_dev **rskl)
 {
         struct hdac_ext_bus_ops *ext_ops = NULL;
-        struct skl *skl;
+        struct skl_dev *skl;
         struct hdac_bus *bus;
         struct hda_bus *hbus;
         int err;
@@ -884,7 +887,7 @@ static int skl_create(struct pci_dev *pci,
 #if IS_ENABLED(CONFIG_SND_SOC_INTEL_SKYLAKE_HDAUDIO_CODEC)
         ext_ops = snd_soc_hdac_hda_get_ops();
 #endif
-        snd_hdac_ext_bus_init(bus, &pci->dev, &bus_core_ops, io_ops, ext_ops);
+        snd_hdac_ext_bus_init(bus, &pci->dev, &bus_core_ops, ext_ops);
         bus->use_posbuf = 1;
         skl->pci = pci;
         INIT_WORK(&skl->probe_work, skl_probe_work);
@@ -902,7 +905,7 @@ static int skl_create(struct pci_dev *pci,
 
 static int skl_first_init(struct hdac_bus *bus)
 {
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
         struct pci_dev *pci = skl->pci;
         int err;
         unsigned short gcap;
@@ -978,7 +981,7 @@ static int skl_first_init(struct hdac_bus *bus)
 static int skl_probe(struct pci_dev *pci,
                      const struct pci_device_id *pci_id)
 {
-        struct skl *skl;
+        struct skl_dev *skl;
         struct hdac_bus *bus = NULL;
         int err;
 
@@ -1013,7 +1016,7 @@ static int skl_probe(struct pci_dev *pci,
         }
 
         /* we use ext core ops, so provide NULL for ops here */
-        err = skl_create(pci, NULL, &skl);
+        err = skl_create(pci, &skl);
         if (err < 0)
                 return err;
 
@@ -1029,7 +1032,7 @@ static int skl_probe(struct pci_dev *pci,
 
         device_disable_async_suspend(bus->dev);
 
-        skl->nhlt = skl_nhlt_init(bus->dev);
+        skl->nhlt = intel_nhlt_init(bus->dev);
 
         if (skl->nhlt == NULL) {
 #if !IS_ENABLED(CONFIG_SND_SOC_INTEL_SKYLAKE_HDAUDIO_CODEC)
@@ -1071,8 +1074,8 @@ static int skl_probe(struct pci_dev *pci,
                 dev_dbg(bus->dev, "error failed to register dsp\n");
                 goto out_nhlt_free;
         }
-        skl->skl_sst->enable_miscbdcge = skl_enable_miscbdcge;
-        skl->skl_sst->clock_power_gating = skl_clock_power_gating;
+        skl->enable_miscbdcge = skl_enable_miscbdcge;
+        skl->clock_power_gating = skl_clock_power_gating;
 
         if (bus->mlcap)
                 snd_hdac_ext_bus_get_ml_capabilities(bus);
@@ -1095,7 +1098,7 @@ out_dsp_free:
 out_clk_free:
         skl_clock_device_unregister(skl);
 out_nhlt_free:
-        skl_nhlt_free(skl->nhlt);
+        intel_nhlt_free(skl->nhlt);
 out_free:
         skl_free(bus);
 
@@ -1107,7 +1110,7 @@ static void skl_shutdown(struct pci_dev *pci)
         struct hdac_bus *bus = pci_get_drvdata(pci);
         struct hdac_stream *s;
         struct hdac_ext_stream *stream;
-        struct skl *skl;
+        struct skl_dev *skl;
 
         if (!bus)
                 return;
@@ -1129,7 +1132,7 @@ static void skl_shutdown(struct pci_dev *pci)
 static void skl_remove(struct pci_dev *pci)
 {
         struct hdac_bus *bus = pci_get_drvdata(pci);
-        struct skl *skl = bus_to_skl(bus);
+        struct skl_dev *skl = bus_to_skl(bus);
 
         cancel_work_sync(&skl->probe_work);
 
@@ -1144,7 +1147,7 @@ static void skl_remove(struct pci_dev *pci)
         skl_dmic_device_unregister(skl);
         skl_clock_device_unregister(skl);
         skl_nhlt_remove_sysfs(skl);
-        skl_nhlt_free(skl->nhlt);
+        intel_nhlt_free(skl->nhlt);
         skl_free(bus);
         dev_set_drvdata(&pci->dev, NULL);
 }
diff --git a/sound/soc/intel/skylake/skl.h b/sound/soc/intel/skylake/skl.h
index 6070666a6392..2bfbf59277c4 100644
--- a/sound/soc/intel/skylake/skl.h
+++ b/sound/soc/intel/skylake/skl.h
@@ -16,8 +16,8 @@
 #include <sound/hdaudio_ext.h>
 #include <sound/hda_codec.h>
 #include <sound/soc.h>
-#include "skl-nhlt.h"
 #include "skl-ssp-clk.h"
+#include "skl-sst-ipc.h"
 
 #define SKL_SUSPEND_DELAY 2000
 
@@ -40,13 +40,6 @@
 #define AZX_VS_EM2_DUM                  BIT(23)
 #define AZX_REG_VS_EM2_L1SEN            BIT(13)
 
-struct skl_dsp_resource {
-        u32 max_mcps;
-        u32 max_mem;
-        u32 mcps;
-        u32 mem;
-};
-
 struct skl_debug;
 
 struct skl_astate_param {
@@ -63,7 +56,7 @@ struct skl_fw_config {
         struct skl_astate_config *astate_cfg;
 };
 
-struct skl {
+struct skl_dev {
         struct hda_bus hbus;
         struct pci_dev *pci;
 
@@ -75,16 +68,13 @@ struct skl {
         struct snd_soc_dai_driver *dais;
 
         struct nhlt_acpi_table *nhlt; /* nhlt ptr */
-        struct skl_sst *skl_sst; /* sst skl ctx */
 
-        struct skl_dsp_resource resource;
         struct list_head ppl_list;
         struct list_head bind_list;
 
         const char *fw_name;
         char tplg_name[64];
         unsigned short pci_id;
-        const struct firmware *tplg;
 
         int supend_active;
 
@@ -96,13 +86,59 @@ struct skl {
         bool use_tplg_pcm;
         struct skl_fw_config cfg;
         struct snd_soc_acpi_mach *mach;
+
+        struct device *dev;
+        struct sst_dsp *dsp;
+
+        /* boot */
+        wait_queue_head_t boot_wait;
+        bool boot_complete;
+
+        /* module load */
+        wait_queue_head_t mod_load_wait;
+        bool mod_load_complete;
+        bool mod_load_status;
+
+        /* IPC messaging */
+        struct sst_generic_ipc ipc;
+
+        /* callback for miscbdge */
+        void (*enable_miscbdcge)(struct device *dev, bool enable);
+        /* Is CGCTL.MISCBDCGE disabled */
+        bool miscbdcg_disabled;
+
+        /* Populate module information */
+        struct list_head uuid_list;
+
+        /* Is firmware loaded */
+        bool fw_loaded;
+
+        /* first boot ? */
+        bool is_first_boot;
+
+        /* multi-core */
+        struct skl_dsp_cores cores;
+
+        /* library info */
+        struct skl_lib_info  lib_info[SKL_MAX_LIB];
+        int lib_count;
+
+        /* Callback to update D0i3C register */
+        void (*update_d0i3c)(struct device *dev, bool enable);
+
+        struct skl_d0i3_data d0i3;
+
+        const struct skl_dsp_ops *dsp_ops;
+
+        /* Callback to update dynamic clock and power gating registers */
+        void (*clock_power_gating)(struct device *dev, bool enable);
 };
 
 #define skl_to_bus(s)  (&(s)->hbus.core)
-#define bus_to_skl(bus) container_of(bus, struct skl, hbus.core)
+#define bus_to_skl(bus) container_of(bus, struct skl_dev, hbus.core)
 
 #define skl_to_hbus(s) (&(s)->hbus)
-#define hbus_to_skl(hbus) container_of((hbus), struct skl, (hbus))
+#define hbus_to_skl(hbus) container_of((hbus), struct skl_dev, (hbus))
 
 /* to pass dai dma data */
 struct skl_dma_params {
@@ -121,52 +157,49 @@ struct skl_dsp_ops {
         int (*init)(struct device *dev, void __iomem *mmio_base,
                         int irq, const char *fw_name,
                         struct skl_dsp_loader_ops loader_ops,
-                        struct skl_sst **skl_sst);
-        int (*init_fw)(struct device *dev, struct skl_sst *ctx);
-        void (*cleanup)(struct device *dev, struct skl_sst *ctx);
+                        struct skl_dev **skl_sst);
+        int (*init_fw)(struct device *dev, struct skl_dev *skl);
+        void (*cleanup)(struct device *dev, struct skl_dev *skl);
 };
 
 int skl_platform_unregister(struct device *dev);
 int skl_platform_register(struct device *dev);
 
-struct nhlt_acpi_table *skl_nhlt_init(struct device *dev);
-void skl_nhlt_free(struct nhlt_acpi_table *addr);
-struct nhlt_specific_cfg *skl_get_ep_blob(struct skl *skl, u32 instance,
+struct nhlt_specific_cfg *skl_get_ep_blob(struct skl_dev *skl, u32 instance,
                                         u8 link_type, u8 s_fmt, u8 no_ch,
                                         u32 s_rate, u8 dirn, u8 dev_type);
 
-int skl_get_dmic_geo(struct skl *skl);
-int skl_nhlt_update_topology_bin(struct skl *skl);
-int skl_init_dsp(struct skl *skl);
-int skl_free_dsp(struct skl *skl);
-int skl_suspend_late_dsp(struct skl *skl);
-int skl_suspend_dsp(struct skl *skl);
-int skl_resume_dsp(struct skl *skl);
-void skl_cleanup_resources(struct skl *skl);
+int skl_nhlt_update_topology_bin(struct skl_dev *skl);
+int skl_init_dsp(struct skl_dev *skl);
+int skl_free_dsp(struct skl_dev *skl);
+int skl_suspend_late_dsp(struct skl_dev *skl);
+int skl_suspend_dsp(struct skl_dev *skl);
+int skl_resume_dsp(struct skl_dev *skl);
+void skl_cleanup_resources(struct skl_dev *skl);
 const struct skl_dsp_ops *skl_get_dsp_ops(int pci_id);
 void skl_update_d0i3c(struct device *dev, bool enable);
-int skl_nhlt_create_sysfs(struct skl *skl);
-void skl_nhlt_remove_sysfs(struct skl *skl);
-void skl_get_clks(struct skl *skl, struct skl_ssp_clk *ssp_clks);
+int skl_nhlt_create_sysfs(struct skl_dev *skl);
+void skl_nhlt_remove_sysfs(struct skl_dev *skl);
+void skl_get_clks(struct skl_dev *skl, struct skl_ssp_clk *ssp_clks);
 struct skl_clk_parent_src *skl_get_parent_clk(u8 clk_id);
-int skl_dsp_set_dma_control(struct skl_sst *ctx, u32 *caps,
+int skl_dsp_set_dma_control(struct skl_dev *skl, u32 *caps,
                                 u32 caps_size, u32 node_id);
 
 struct skl_module_cfg;
 
 #ifdef CONFIG_DEBUG_FS
-struct skl_debug *skl_debugfs_init(struct skl *skl);
-void skl_debugfs_exit(struct skl *skl);
+struct skl_debug *skl_debugfs_init(struct skl_dev *skl);
+void skl_debugfs_exit(struct skl_dev *skl);
 void skl_debug_init_module(struct skl_debug *d,
                         struct snd_soc_dapm_widget *w,
                         struct skl_module_cfg *mconfig);
 #else
-static inline struct skl_debug *skl_debugfs_init(struct skl *skl)
+static inline struct skl_debug *skl_debugfs_init(struct skl_dev *skl)
 {
         return NULL;
 }
 
-static inline void skl_debugfs_exit(struct skl *skl)
+static inline void skl_debugfs_exit(struct skl_dev *skl)
 {}
 
 static inline void skl_debug_init_module(struct skl_debug *d,