Merge branch 'for-next' into topic/hda-core

13 files changed, 291 insertions, 69 deletions

diff --git a/sound/soc/intel/broadwell.c b/sound/soc/intel/broadwell.c
index 9cf7d01479ad..fc5542034b9b 100644
--- a/sound/soc/intel/broadwell.c
+++ b/sound/soc/intel/broadwell.c
@@ -80,15 +80,9 @@ static int broadwell_rt286_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
         struct snd_soc_codec *codec = rtd->codec;
         int ret = 0;
-        ret = snd_soc_jack_new(codec, "Headset",
-                SND_JACK_HEADSET | SND_JACK_BTN_0, &broadwell_headset);
-
-        if (ret)
-                return ret;
-
-        ret = snd_soc_jack_add_pins(&broadwell_headset,
-                ARRAY_SIZE(broadwell_headset_pins),
-                broadwell_headset_pins);
+        ret = snd_soc_card_jack_new(rtd->card, "Headset",
+                SND_JACK_HEADSET | SND_JACK_BTN_0, &broadwell_headset,
+                broadwell_headset_pins, ARRAY_SIZE(broadwell_headset_pins));
         if (ret)
                 return ret;
 
@@ -110,9 +104,7 @@ static int broadwell_ssp0_fixup(struct snd_soc_pcm_runtime *rtd,
         channels->min = channels->max = 2;
 
         /* set SSP0 to 16 bit */
-        snd_mask_set(&params->masks[SNDRV_PCM_HW_PARAM_FORMAT -
-                                    SNDRV_PCM_HW_PARAM_FIRST_MASK],
-                                    SNDRV_PCM_FORMAT_S16_LE);
+        params_set_format(params, SNDRV_PCM_FORMAT_S16_LE);
         return 0;
 }
 
diff --git a/sound/soc/intel/byt-max98090.c b/sound/soc/intel/byt-max98090.c
index 9832afe7d22c..d8b1f038da1c 100644
--- a/sound/soc/intel/byt-max98090.c
+++ b/sound/soc/intel/byt-max98090.c
@@ -84,7 +84,6 @@ static struct snd_soc_jack_gpio hs_jack_gpios[] = {
 static int byt_max98090_init(struct snd_soc_pcm_runtime *runtime)
 {
         int ret;
-        struct snd_soc_codec *codec = runtime->codec;
         struct snd_soc_card *card = runtime->card;
         struct byt_max98090_private *drv = snd_soc_card_get_drvdata(card);
         struct snd_soc_jack *jack = &drv->jack;
@@ -100,13 +99,9 @@ static int byt_max98090_init(struct snd_soc_pcm_runtime *runtime)
         }
 
         /* Enable jack detection */
-        ret = snd_soc_jack_new(codec, "Headset",
-                               SND_JACK_LINEOUT | SND_JACK_HEADSET, jack);
-        if (ret)
-                return ret;
-
-        ret = snd_soc_jack_add_pins(jack, ARRAY_SIZE(hs_jack_pins),
-                                    hs_jack_pins);
+        ret = snd_soc_card_jack_new(runtime->card, "Headset",
+                                    SND_JACK_LINEOUT | SND_JACK_HEADSET, jack,
+                                    hs_jack_pins, ARRAY_SIZE(hs_jack_pins));
         if (ret)
                 return ret;
 
diff --git a/sound/soc/intel/bytcr_dpcm_rt5640.c b/sound/soc/intel/bytcr_dpcm_rt5640.c
index 59308629043e..3b262d01c1b3 100644
--- a/sound/soc/intel/bytcr_dpcm_rt5640.c
+++ b/sound/soc/intel/bytcr_dpcm_rt5640.c
@@ -113,9 +113,7 @@ static int byt_codec_fixup(struct snd_soc_pcm_runtime *rtd,
         channels->min = channels->max = 2;
 
         /* set SSP2 to 24-bit */
-        snd_mask_set(&params->masks[SNDRV_PCM_HW_PARAM_FORMAT -
-                                    SNDRV_PCM_HW_PARAM_FIRST_MASK],
-                                    SNDRV_PCM_FORMAT_S24_LE);
+        params_set_format(params, SNDRV_PCM_FORMAT_S24_LE);
         return 0;
 }
 
diff --git a/sound/soc/intel/cht_bsw_rt5645.c b/sound/soc/intel/cht_bsw_rt5645.c
index bd29617a9ab9..012227997ed9 100644
--- a/sound/soc/intel/cht_bsw_rt5645.c
+++ b/sound/soc/intel/cht_bsw_rt5645.c
@@ -169,17 +169,17 @@ static int cht_codec_init(struct snd_soc_pcm_runtime *runtime)
                 return ret;
         }
 
-        ret = snd_soc_jack_new(codec, "Headphone Jack",
-                                SND_JACK_HEADPHONE,
-                                &ctx->hp_jack);
+        ret = snd_soc_card_jack_new(runtime->card, "Headphone Jack",
+                                    SND_JACK_HEADPHONE, &ctx->hp_jack,
+                                    NULL, 0);
         if (ret) {
                 dev_err(runtime->dev, "HP jack creation failed %d\n", ret);
                 return ret;
         }
 
-        ret = snd_soc_jack_new(codec, "Mic Jack",
-                                SND_JACK_MICROPHONE,
-                                &ctx->mic_jack);
+        ret = snd_soc_card_jack_new(runtime->card, "Mic Jack",
+                                    SND_JACK_MICROPHONE, &ctx->mic_jack,
+                                    NULL, 0);
         if (ret) {
                 dev_err(runtime->dev, "Mic jack creation failed %d\n", ret);
                 return ret;
@@ -203,9 +203,7 @@ static int cht_codec_fixup(struct snd_soc_pcm_runtime *rtd,
         channels->min = channels->max = 2;
 
         /* set SSP2 to 24-bit */
-        snd_mask_set(&params->masks[SNDRV_PCM_HW_PARAM_FORMAT -
-                                    SNDRV_PCM_HW_PARAM_FIRST_MASK],
-                                    SNDRV_PCM_FORMAT_S24_LE);
+        params_set_format(params, SNDRV_PCM_FORMAT_S24_LE);
         return 0;
 }
 
diff --git a/sound/soc/intel/cht_bsw_rt5672.c b/sound/soc/intel/cht_bsw_rt5672.c
index ff016621583a..bc8dcacd5e6a 100644
--- a/sound/soc/intel/cht_bsw_rt5672.c
+++ b/sound/soc/intel/cht_bsw_rt5672.c
@@ -178,9 +178,7 @@ static int cht_codec_fixup(struct snd_soc_pcm_runtime *rtd,
         channels->min = channels->max = 2;
 
         /* set SSP2 to 24-bit */
-        snd_mask_set(&params->masks[SNDRV_PCM_HW_PARAM_FORMAT -
-                                    SNDRV_PCM_HW_PARAM_FIRST_MASK],
-                                    SNDRV_PCM_FORMAT_S24_LE);
+        params_set_format(params, SNDRV_PCM_FORMAT_S24_LE);
         return 0;
 }
 
@@ -217,7 +215,7 @@ static struct snd_soc_dai_link cht_dailink[] = {
                 .codec_dai_name = "snd-soc-dummy-dai",
                 .codec_name = "snd-soc-dummy",
                 .platform_name = "sst-mfld-platform",
-                .ignore_suspend = 1,
+                .nonatomic = true,
                 .dynamic = 1,
                 .dpcm_playback = 1,
                 .dpcm_capture = 1,
@@ -240,13 +238,13 @@ static struct snd_soc_dai_link cht_dailink[] = {
                 .cpu_dai_name = "ssp2-port",
                 .platform_name = "sst-mfld-platform",
                 .no_pcm = 1,
+                .nonatomic = true,
                 .codec_dai_name = "rt5670-aif1",
                 .codec_name = "i2c-10EC5670:00",
                 .dai_fmt = SND_SOC_DAIFMT_DSP_B | SND_SOC_DAIFMT_IB_NF
                                         | SND_SOC_DAIFMT_CBS_CFS,
                 .init = cht_codec_init,
                 .be_hw_params_fixup = cht_codec_fixup,
-                .ignore_suspend = 1,
                 .dpcm_playback = 1,
                 .dpcm_capture = 1,
                 .ops = &cht_be_ssp2_ops,
@@ -285,7 +283,6 @@ static int snd_cht_mc_probe(struct platform_device *pdev)
 static struct platform_driver snd_cht_mc_driver = {
         .driver = {
                 .name = "cht-bsw-rt5672",
-                .pm = &snd_soc_pm_ops,
         },
         .probe = snd_cht_mc_probe,
 };
diff --git a/sound/soc/intel/haswell.c b/sound/soc/intel/haswell.c
index 35edf51a52aa..00fddd3f5dfb 100644
--- a/sound/soc/intel/haswell.c
+++ b/sound/soc/intel/haswell.c
@@ -56,9 +56,7 @@ static int haswell_ssp0_fixup(struct snd_soc_pcm_runtime *rtd,
         channels->min = channels->max = 2;
 
         /* set SSP0 to 16 bit */
-        snd_mask_set(&params->masks[SNDRV_PCM_HW_PARAM_FORMAT -
-                                    SNDRV_PCM_HW_PARAM_FIRST_MASK],
-                                    SNDRV_PCM_FORMAT_S16_LE);
+        params_set_format(params, SNDRV_PCM_FORMAT_S16_LE);
         return 0;
 }
 
diff --git a/sound/soc/intel/mfld_machine.c b/sound/soc/intel/mfld_machine.c
index 90b7a57713a0..49c09a0add79 100644
--- a/sound/soc/intel/mfld_machine.c
+++ b/sound/soc/intel/mfld_machine.c
@@ -228,10 +228,13 @@ static void mfld_jack_check(unsigned int intr_status)
 {
         struct mfld_jack_data jack_data;
 
+        if (!mfld_codec)
+                return;
+
         jack_data.mfld_jack = &mfld_jack;
         jack_data.intr_id = intr_status;
 
-        sn95031_jack_detection(&jack_data);
+        sn95031_jack_detection(mfld_codec, &jack_data);
         /* TODO: add american headset detection post gpiolib support */
 }
 
@@ -240,8 +243,6 @@ static int mfld_init(struct snd_soc_pcm_runtime *runtime)
         struct snd_soc_dapm_context *dapm = &runtime->card->dapm;
         int ret_val;
 
-        mfld_codec = runtime->codec;
-
         /* default is earpiece pin, userspace sets it explcitly */
         snd_soc_dapm_disable_pin(dapm, "Headphones");
         /* default is lineout NC, userspace sets it explcitly */
@@ -254,20 +255,15 @@ static int mfld_init(struct snd_soc_pcm_runtime *runtime)
         snd_soc_dapm_disable_pin(dapm, "LINEINR");
 
         /* Headset and button jack detection */
-        ret_val = snd_soc_jack_new(mfld_codec, "Intel(R) MID Audio Jack",
-                        SND_JACK_HEADSET | SND_JACK_BTN_0 |
-                        SND_JACK_BTN_1, &mfld_jack);
+        ret_val = snd_soc_card_jack_new(runtime->card,
+                        "Intel(R) MID Audio Jack", SND_JACK_HEADSET |
+                        SND_JACK_BTN_0 | SND_JACK_BTN_1, &mfld_jack,
+                        mfld_jack_pins, ARRAY_SIZE(mfld_jack_pins));
         if (ret_val) {
                 pr_err("jack creation failed\n");
                 return ret_val;
         }
 
-        ret_val = snd_soc_jack_add_pins(&mfld_jack,
-                        ARRAY_SIZE(mfld_jack_pins), mfld_jack_pins);
-        if (ret_val) {
-                pr_err("adding jack pins failed\n");
-                return ret_val;
-        }
         ret_val = snd_soc_jack_add_zones(&mfld_jack,
                         ARRAY_SIZE(mfld_zones), mfld_zones);
         if (ret_val) {
@@ -275,6 +271,8 @@ static int mfld_init(struct snd_soc_pcm_runtime *runtime)
                 return ret_val;
         }
 
+        mfld_codec = runtime->codec;
+
         /* we want to check if anything is inserted at boot,
          * so send a fake event to codec and it will read adc
          * to find if anything is there or not */
@@ -359,8 +357,6 @@ static irqreturn_t snd_mfld_jack_detection(int irq, void *data)
 {
         struct mfld_mc_private *mc_drv_ctx = (struct mfld_mc_private *) data;
 
-        if (mfld_jack.codec == NULL)
-                return IRQ_HANDLED;
         mfld_jack_check(mc_drv_ctx->interrupt_status);
 
         return IRQ_HANDLED;
diff --git a/sound/soc/intel/sst-mfld-platform-pcm.c b/sound/soc/intel/sst-mfld-platform-pcm.c
index 7523cbef8780..2fbaf2c75d17 100644
--- a/sound/soc/intel/sst-mfld-platform-pcm.c
+++ b/sound/soc/intel/sst-mfld-platform-pcm.c
@@ -594,11 +594,13 @@ static int sst_platform_pcm_trigger(struct snd_pcm_substream *substream,
                 ret_val = stream->ops->stream_drop(sst->dev, str_id);
                 break;
         case SNDRV_PCM_TRIGGER_PAUSE_PUSH:
+        case SNDRV_PCM_TRIGGER_SUSPEND:
                 dev_dbg(rtd->dev, "sst: in pause\n");
                 status = SST_PLATFORM_PAUSED;
                 ret_val = stream->ops->stream_pause(sst->dev, str_id);
                 break;
         case SNDRV_PCM_TRIGGER_PAUSE_RELEASE:
+        case SNDRV_PCM_TRIGGER_RESUME:
                 dev_dbg(rtd->dev, "sst: in pause release\n");
                 status = SST_PLATFORM_RUNNING;
                 ret_val = stream->ops->stream_pause_release(sst->dev, str_id);
@@ -665,6 +667,9 @@ static int sst_pcm_new(struct snd_soc_pcm_runtime *rtd)
 
 static int sst_soc_probe(struct snd_soc_platform *platform)
 {
+        struct sst_data *drv = dev_get_drvdata(platform->dev);
+
+        drv->soc_card = platform->component.card;
         return sst_dsp_init_v2_dpcm(platform);
 }
 
@@ -727,9 +732,64 @@ static int sst_platform_remove(struct platform_device *pdev)
         return 0;
 }
 
+#ifdef CONFIG_PM_SLEEP
+
+static int sst_soc_prepare(struct device *dev)
+{
+        struct sst_data *drv = dev_get_drvdata(dev);
+        int i;
+
+        /* suspend all pcms first */
+        snd_soc_suspend(drv->soc_card->dev);
+        snd_soc_poweroff(drv->soc_card->dev);
+
+        /* set the SSPs to idle */
+        for (i = 0; i < drv->soc_card->num_rtd; i++) {
+                struct snd_soc_dai *dai = drv->soc_card->rtd[i].cpu_dai;
+
+                if (dai->active) {
+                        send_ssp_cmd(dai, dai->name, 0);
+                        sst_handle_vb_timer(dai, false);
+                }
+        }
+
+        return 0;
+}
+
+static void sst_soc_complete(struct device *dev)
+{
+        struct sst_data *drv = dev_get_drvdata(dev);
+        int i;
+
+        /* restart SSPs */
+        for (i = 0; i < drv->soc_card->num_rtd; i++) {
+                struct snd_soc_dai *dai = drv->soc_card->rtd[i].cpu_dai;
+
+                if (dai->active) {
+                        sst_handle_vb_timer(dai, true);
+                        send_ssp_cmd(dai, dai->name, 1);
+                }
+        }
+        snd_soc_resume(drv->soc_card->dev);
+}
+
+#else
+
+#define sst_soc_prepare NULL
+#define sst_soc_complete NULL
+
+#endif
+
+
+static const struct dev_pm_ops sst_platform_pm = {
+        .prepare        = sst_soc_prepare,
+        .complete       = sst_soc_complete,
+};
+
 static struct platform_driver sst_platform_driver = {
         .driver         = {
                 .name           = "sst-mfld-platform",
+                .pm             = &sst_platform_pm,
         },
         .probe          = sst_platform_probe,
         .remove         = sst_platform_remove,
diff --git a/sound/soc/intel/sst-mfld-platform.h b/sound/soc/intel/sst-mfld-platform.h
index 79c8d1246a8f..9094314be2b0 100644
--- a/sound/soc/intel/sst-mfld-platform.h
+++ b/sound/soc/intel/sst-mfld-platform.h
@@ -174,6 +174,7 @@ struct sst_data {
         struct sst_platform_data *pdata;
         struct snd_sst_bytes_v2 *byte_stream;
         struct mutex lock;
+        struct snd_soc_card *soc_card;
 };
 int sst_register_dsp(struct sst_device *sst);
 int sst_unregister_dsp(struct sst_device *sst);
diff --git a/sound/soc/intel/sst/sst.c b/sound/soc/intel/sst/sst.c
index 11c578651c1c..1a7eeec444b1 100644
--- a/sound/soc/intel/sst/sst.c
+++ b/sound/soc/intel/sst/sst.c
@@ -423,23 +423,135 @@ static int intel_sst_runtime_suspend(struct device *dev)
         return ret;
 }
 
-static int intel_sst_runtime_resume(struct device *dev)
+static int intel_sst_suspend(struct device *dev)
 {
-        int ret = 0;
         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
+        struct sst_fw_save *fw_save;
+        int i, ret = 0;
 
-        if (ctx->sst_state == SST_RESET) {
-                ret = sst_load_fw(ctx);
-                if (ret) {
-                        dev_err(dev, "FW download fail %d\n", ret);
-                        sst_set_fw_state_locked(ctx, SST_RESET);
+        /* check first if we are already in SW reset */
+        if (ctx->sst_state == SST_RESET)
+                return 0;
+
+        /*
+         * check if any stream is active and running
+         * they should already by suspend by soc_suspend
+         */
+        for (i = 1; i <= ctx->info.max_streams; i++) {
+                struct stream_info *stream = &ctx->streams[i];
+
+                if (stream->status == STREAM_RUNNING) {
+                        dev_err(dev, "stream %d is running, cant susupend, abort\n", i);
+                        return -EBUSY;
                 }
         }
+        synchronize_irq(ctx->irq_num);
+        flush_workqueue(ctx->post_msg_wq);
+
+        /* Move the SST state to Reset */
+        sst_set_fw_state_locked(ctx, SST_RESET);
+
+        /* tell DSP we are suspending */
+        if (ctx->ops->save_dsp_context(ctx))
+                return -EBUSY;
+
+        /* save the memories */
+        fw_save = kzalloc(sizeof(*fw_save), GFP_KERNEL);
+        if (!fw_save)
+                return -ENOMEM;
+        fw_save->iram = kzalloc(ctx->iram_end - ctx->iram_base, GFP_KERNEL);
+        if (!fw_save->iram) {
+                ret = -ENOMEM;
+                goto iram;
+        }
+        fw_save->dram = kzalloc(ctx->dram_end - ctx->dram_base, GFP_KERNEL);
+        if (!fw_save->dram) {
+                ret = -ENOMEM;
+                goto dram;
+        }
+        fw_save->sram = kzalloc(SST_MAILBOX_SIZE, GFP_KERNEL);
+        if (!fw_save->sram) {
+                ret = -ENOMEM;
+                goto sram;
+        }
+
+        fw_save->ddr = kzalloc(ctx->ddr_end - ctx->ddr_base, GFP_KERNEL);
+        if (!fw_save->ddr) {
+                ret = -ENOMEM;
+                goto ddr;
+        }
+
+        memcpy32_fromio(fw_save->iram, ctx->iram, ctx->iram_end - ctx->iram_base);
+        memcpy32_fromio(fw_save->dram, ctx->dram, ctx->dram_end - ctx->dram_base);
+        memcpy32_fromio(fw_save->sram, ctx->mailbox, SST_MAILBOX_SIZE);
+        memcpy32_fromio(fw_save->ddr, ctx->ddr, ctx->ddr_end - ctx->ddr_base);
+
+        ctx->fw_save = fw_save;
+        ctx->ops->reset(ctx);
+        return 0;
+ddr:
+        kfree(fw_save->sram);
+sram:
+        kfree(fw_save->dram);
+dram:
+        kfree(fw_save->iram);
+iram:
+        kfree(fw_save);
+        return ret;
+}
+
+static int intel_sst_resume(struct device *dev)
+{
+        struct intel_sst_drv *ctx = dev_get_drvdata(dev);
+        struct sst_fw_save *fw_save = ctx->fw_save;
+        int ret = 0;
+        struct sst_block *block;
+
+        if (!fw_save)
+                return 0;
+
+        sst_set_fw_state_locked(ctx, SST_FW_LOADING);
+
+        /* we have to restore the memory saved */
+        ctx->ops->reset(ctx);
+
+        ctx->fw_save = NULL;
+
+        memcpy32_toio(ctx->iram, fw_save->iram, ctx->iram_end - ctx->iram_base);
+        memcpy32_toio(ctx->dram, fw_save->dram, ctx->dram_end - ctx->dram_base);
+        memcpy32_toio(ctx->mailbox, fw_save->sram, SST_MAILBOX_SIZE);
+        memcpy32_toio(ctx->ddr, fw_save->ddr, ctx->ddr_end - ctx->ddr_base);
+
+        kfree(fw_save->sram);
+        kfree(fw_save->dram);
+        kfree(fw_save->iram);
+        kfree(fw_save->ddr);
+        kfree(fw_save);
+
+        block = sst_create_block(ctx, 0, FW_DWNL_ID);
+        if (block == NULL)
+                return -ENOMEM;
+
+
+        /* start and wait for ack */
+        ctx->ops->start(ctx);
+        ret = sst_wait_timeout(ctx, block);
+        if (ret) {
+                dev_err(ctx->dev, "fw download failed %d\n", ret);
+                /* FW download failed due to timeout */
+                ret = -EBUSY;
+
+        } else {
+                sst_set_fw_state_locked(ctx, SST_FW_RUNNING);
+        }
+
+        sst_free_block(ctx, block);
         return ret;
 }
 
 const struct dev_pm_ops intel_sst_pm = {
+        .suspend = intel_sst_suspend,
+        .resume = intel_sst_resume,
         .runtime_suspend = intel_sst_runtime_suspend,
-        .runtime_resume = intel_sst_runtime_resume,
 };
 EXPORT_SYMBOL_GPL(intel_sst_pm);
diff --git a/sound/soc/intel/sst/sst.h b/sound/soc/intel/sst/sst.h
index 562bc483d6b7..3f493862e98d 100644
--- a/sound/soc/intel/sst/sst.h
+++ b/sound/soc/intel/sst/sst.h
@@ -337,6 +337,13 @@ struct sst_shim_regs64 {
         u64 csr2;
 };
 
+struct sst_fw_save {
+        void *iram;
+        void *dram;
+        void *sram;
+        void *ddr;
+};
+
 /**
  * struct intel_sst_drv - driver ops
  *
@@ -428,6 +435,8 @@ struct intel_sst_drv {
          * persistent till worker thread gets called
          */
         char firmware_name[FW_NAME_SIZE];
+
+        struct sst_fw_save      *fw_save;
 };
 
 /* misc definitions */
@@ -544,4 +553,7 @@ int sst_alloc_drv_context(struct intel_sst_drv **ctx,
 int sst_context_init(struct intel_sst_drv *ctx);
 void sst_context_cleanup(struct intel_sst_drv *ctx);
 void sst_configure_runtime_pm(struct intel_sst_drv *ctx);
+void memcpy32_toio(void __iomem *dst, const void *src, int count);
+void memcpy32_fromio(void *dst, const void __iomem *src, int count);
+
 #endif
diff --git a/sound/soc/intel/sst/sst_drv_interface.c b/sound/soc/intel/sst/sst_drv_interface.c
index 5f75ef3cdd22..f0e4b99b3aeb 100644
--- a/sound/soc/intel/sst/sst_drv_interface.c
+++ b/sound/soc/intel/sst/sst_drv_interface.c
@@ -138,12 +138,36 @@ int sst_get_stream(struct intel_sst_drv *ctx,
 static int sst_power_control(struct device *dev, bool state)
 {
         struct intel_sst_drv *ctx = dev_get_drvdata(dev);
-
-        dev_dbg(ctx->dev, "state:%d", state);
-        if (state == true)
-                return pm_runtime_get_sync(dev);
-        else
+        int ret = 0;
+        int usage_count = 0;
+
+#ifdef CONFIG_PM
+        usage_count = atomic_read(&dev->power.usage_count);
+#else
+        usage_count = 1;
+#endif
+
+        if (state == true) {
+                ret = pm_runtime_get_sync(dev);
+
+                dev_dbg(ctx->dev, "Enable: pm usage count: %d\n", usage_count);
+                if (ret < 0) {
+                        dev_err(ctx->dev, "Runtime get failed with err: %d\n", ret);
+                        return ret;
+                }
+                if ((ctx->sst_state == SST_RESET) && (usage_count == 1)) {
+                        ret = sst_load_fw(ctx);
+                        if (ret) {
+                                dev_err(dev, "FW download fail %d\n", ret);
+                                sst_set_fw_state_locked(ctx, SST_RESET);
+                                ret = sst_pm_runtime_put(ctx);
+                        }
+                }
+        } else {
+                dev_dbg(ctx->dev, "Disable: pm usage count: %d\n", usage_count);
                 return sst_pm_runtime_put(ctx);
+        }
+        return ret;
 }
 
 /*
@@ -572,6 +596,35 @@ static int sst_stream_drop(struct device *dev, int str_id)
         return sst_drop_stream(ctx, str_id);
 }
 
+static int sst_stream_pause(struct device *dev, int str_id)
+{
+        struct stream_info *str_info;
+        struct intel_sst_drv *ctx = dev_get_drvdata(dev);
+
+        if (ctx->sst_state != SST_FW_RUNNING)
+                return 0;
+
+        str_info = get_stream_info(ctx, str_id);
+        if (!str_info)
+                return -EINVAL;
+
+        return sst_pause_stream(ctx, str_id);
+}
+
+static int sst_stream_resume(struct device *dev, int str_id)
+{
+        struct stream_info *str_info;
+        struct intel_sst_drv *ctx = dev_get_drvdata(dev);
+
+        if (ctx->sst_state != SST_FW_RUNNING)
+                return 0;
+
+        str_info = get_stream_info(ctx, str_id);
+        if (!str_info)
+                return -EINVAL;
+        return sst_resume_stream(ctx, str_id);
+}
+
 static int sst_stream_init(struct device *dev, struct pcm_stream_info *str_info)
 {
         int str_id = 0;
@@ -633,6 +686,8 @@ static struct sst_ops pcm_ops = {
         .stream_init = sst_stream_init,
         .stream_start = sst_stream_start,
         .stream_drop = sst_stream_drop,
+        .stream_pause = sst_stream_pause,
+        .stream_pause_release = sst_stream_resume,
         .stream_read_tstamp = sst_read_timestamp,
         .send_byte_stream = sst_send_byte_stream,
         .close = sst_close_pcm_stream,
diff --git a/sound/soc/intel/sst/sst_loader.c b/sound/soc/intel/sst/sst_loader.c
index 7888cd707853..e88907ae8b15 100644
--- a/sound/soc/intel/sst/sst_loader.c
+++ b/sound/soc/intel/sst/sst_loader.c
@@ -39,7 +39,15 @@
 #include "sst.h"
 #include "../sst-dsp.h"
 
-static inline void memcpy32_toio(void __iomem *dst, const void *src, int count)
+void memcpy32_toio(void __iomem *dst, const void *src, int count)
+{
+        /* __iowrite32_copy uses 32-bit count values so divide by 4 for
+         * right count in words
+         */
+        __iowrite32_copy(dst, src, count/4);
+}
+
+void memcpy32_fromio(void *dst, const void __iomem *src, int count)
 {
         /* __iowrite32_copy uses 32-bit count values so divide by 4 for
          * right count in words