}
 
 static int sof_widget_load_dai(struct snd_soc_component *scomp, int index,
-                              struct snd_sof_widget *swidget,
+                              struct snd_sof_widget *swidget, int core,
                               struct snd_soc_tplg_dapm_widget *tw,
                               struct sof_ipc_comp_reply *r,
                               struct snd_sof_dai *dai)
        comp_dai.comp.id = swidget->comp_id;
        comp_dai.comp.type = SOF_COMP_DAI;
        comp_dai.comp.pipeline_id = index;
+       comp_dai.comp.core = core;
        comp_dai.config.hdr.size = sizeof(comp_dai.config);
 
        ret = sof_parse_tokens(scomp, &comp_dai, dai_tokens,
  */
 
 static int sof_widget_load_buffer(struct snd_soc_component *scomp, int index,
-                                 struct snd_sof_widget *swidget,
+                                 struct snd_sof_widget *swidget, int core,
                                  struct snd_soc_tplg_dapm_widget *tw,
                                  struct sof_ipc_comp_reply *r)
 {
        buffer->comp.id = swidget->comp_id;
        buffer->comp.type = SOF_COMP_BUFFER;
        buffer->comp.pipeline_id = index;
+       buffer->comp.core = core;
 
        ret = sof_parse_tokens(scomp, buffer, buffer_tokens,
                               ARRAY_SIZE(buffer_tokens), private->array,
  */
 
 static int sof_widget_load_pcm(struct snd_soc_component *scomp, int index,
-                              struct snd_sof_widget *swidget,
+                              struct snd_sof_widget *swidget, int core,
                               enum sof_ipc_stream_direction dir,
                               struct snd_soc_tplg_dapm_widget *tw,
                               struct sof_ipc_comp_reply *r)
        host->comp.id = swidget->comp_id;
        host->comp.type = SOF_COMP_HOST;
        host->comp.pipeline_id = index;
+       host->comp.core = core;
        host->direction = dir;
        host->config.hdr.size = sizeof(host->config);
 
        return ret;
 }
 
-static int sof_widget_load_pipeline(struct snd_soc_component *scomp,
-                                   int index, struct snd_sof_widget *swidget,
+static int sof_widget_load_pipeline(struct snd_soc_component *scomp, int index,
+                                   struct snd_sof_widget *swidget,
                                    struct snd_soc_tplg_dapm_widget *tw,
                                    struct sof_ipc_comp_reply *r)
 {
  */
 
 static int sof_widget_load_mixer(struct snd_soc_component *scomp, int index,
-                                struct snd_sof_widget *swidget,
+                                struct snd_sof_widget *swidget, int core,
                                 struct snd_soc_tplg_dapm_widget *tw,
                                 struct sof_ipc_comp_reply *r)
 {
        mixer->comp.id = swidget->comp_id;
        mixer->comp.type = SOF_COMP_MIXER;
        mixer->comp.pipeline_id = index;
+       mixer->comp.core = core;
        mixer->config.hdr.size = sizeof(mixer->config);
 
        ret = sof_parse_tokens(scomp, &mixer->config, comp_tokens,
  * Mux topology
  */
 static int sof_widget_load_mux(struct snd_soc_component *scomp, int index,
-                              struct snd_sof_widget *swidget,
+                              struct snd_sof_widget *swidget, int core,
                               struct snd_soc_tplg_dapm_widget *tw,
                               struct sof_ipc_comp_reply *r)
 {
        mux->comp.id = swidget->comp_id;
        mux->comp.type = SOF_COMP_MUX;
        mux->comp.pipeline_id = index;
+       mux->comp.core = core;
        mux->config.hdr.size = sizeof(mux->config);
 
        ret = sof_parse_tokens(scomp, &mux->config, comp_tokens,
  */
 
 static int sof_widget_load_pga(struct snd_soc_component *scomp, int index,
-                              struct snd_sof_widget *swidget,
+                              struct snd_sof_widget *swidget, int core,
                               struct snd_soc_tplg_dapm_widget *tw,
                               struct sof_ipc_comp_reply *r)
 {
        volume->comp.id = swidget->comp_id;
        volume->comp.type = SOF_COMP_VOLUME;
        volume->comp.pipeline_id = index;
+       volume->comp.core = core;
        volume->config.hdr.size = sizeof(volume->config);
 
        ret = sof_parse_tokens(scomp, volume, volume_tokens,
  */
 
 static int sof_widget_load_src(struct snd_soc_component *scomp, int index,
-                              struct snd_sof_widget *swidget,
+                              struct snd_sof_widget *swidget, int core,
                               struct snd_soc_tplg_dapm_widget *tw,
                               struct sof_ipc_comp_reply *r)
 {
        src->comp.id = swidget->comp_id;
        src->comp.type = SOF_COMP_SRC;
        src->comp.pipeline_id = index;
+       src->comp.core = core;
        src->config.hdr.size = sizeof(src->config);
 
        ret = sof_parse_tokens(scomp, src, src_tokens,
  */
 
 static int sof_widget_load_asrc(struct snd_soc_component *scomp, int index,
-                               struct snd_sof_widget *swidget,
+                               struct snd_sof_widget *swidget, int core,
                                struct snd_soc_tplg_dapm_widget *tw,
                                struct sof_ipc_comp_reply *r)
 {
        asrc->comp.id = swidget->comp_id;
        asrc->comp.type = SOF_COMP_ASRC;
        asrc->comp.pipeline_id = index;
+       asrc->comp.core = core;
        asrc->config.hdr.size = sizeof(asrc->config);
 
        ret = sof_parse_tokens(scomp, asrc, asrc_tokens,
  */
 
 static int sof_widget_load_siggen(struct snd_soc_component *scomp, int index,
-                                 struct snd_sof_widget *swidget,
+                                 struct snd_sof_widget *swidget, int core,
                                  struct snd_soc_tplg_dapm_widget *tw,
                                  struct sof_ipc_comp_reply *r)
 {
        tone->comp.id = swidget->comp_id;
        tone->comp.type = SOF_COMP_TONE;
        tone->comp.pipeline_id = index;
+       tone->comp.core = core;
        tone->config.hdr.size = sizeof(tone->config);
 
        ret = sof_parse_tokens(scomp, tone, tone_tokens,
  */
 
 static int sof_widget_load_process(struct snd_soc_component *scomp, int index,
-                                  struct snd_sof_widget *swidget,
+                                  struct snd_sof_widget *swidget, int core,
                                   struct snd_soc_tplg_dapm_widget *tw,
                                   struct sof_ipc_comp_reply *r)
 {
        }
 
        memset(&config, 0, sizeof(config));
+       config.comp.core = core;
 
        /* get the process token */
        ret = sof_parse_tokens(scomp, &config, process_tokens,
        struct snd_sof_dai *dai;
        struct sof_ipc_comp_reply reply;
        struct snd_sof_control *scontrol;
+       struct sof_ipc_comp comp = {
+               .core = SOF_DSP_PRIMARY_CORE,
+       };
        int ret = 0;
 
        swidget = kzalloc(sizeof(*swidget), GFP_KERNEL);
                        return -ENOMEM;
                }
 
-               ret = sof_widget_load_dai(scomp, index, swidget, tw, &reply,
-                                         dai);
+               ret = sof_widget_load_dai(scomp, index, swidget, comp.core,
+                                         tw, &reply, dai);
                if (ret == 0) {
                        sof_connect_dai_widget(scomp, w, tw, dai);
                        list_add(&dai->list, &sdev->dai_list);
                }
                break;
        case snd_soc_dapm_mixer:
-               ret = sof_widget_load_mixer(scomp, index, swidget, tw, &reply);
+               ret = sof_widget_load_mixer(scomp, index, swidget, comp.core,
+                                           tw, &reply);
                break;
        case snd_soc_dapm_pga:
-               ret = sof_widget_load_pga(scomp, index, swidget, tw, &reply);
+               ret = sof_widget_load_pga(scomp, index, swidget, comp.core,
+                                         tw, &reply);
                /* Find scontrol for this pga and set readback offset*/
                list_for_each_entry(scontrol, &sdev->kcontrol_list, list) {
                        if (scontrol->comp_id == swidget->comp_id) {
                }
                break;
        case snd_soc_dapm_buffer:
-               ret = sof_widget_load_buffer(scomp, index, swidget, tw, &reply);
+               ret = sof_widget_load_buffer(scomp, index, swidget, comp.core,
+                                            tw, &reply);
                break;
        case snd_soc_dapm_scheduler:
-               ret = sof_widget_load_pipeline(scomp, index, swidget, tw,
-                                              &reply);
+               ret = sof_widget_load_pipeline(scomp, index, swidget,
+                                              tw, &reply);
                break;
        case snd_soc_dapm_aif_out:
-               ret = sof_widget_load_pcm(scomp, index, swidget,
+               ret = sof_widget_load_pcm(scomp, index, swidget, comp.core,
                                          SOF_IPC_STREAM_CAPTURE, tw, &reply);
                break;
        case snd_soc_dapm_aif_in:
-               ret = sof_widget_load_pcm(scomp, index, swidget,
+               ret = sof_widget_load_pcm(scomp, index, swidget, comp.core,
                                          SOF_IPC_STREAM_PLAYBACK, tw, &reply);
                break;
        case snd_soc_dapm_src:
-               ret = sof_widget_load_src(scomp, index, swidget, tw, &reply);
+               ret = sof_widget_load_src(scomp, index, swidget, comp.core,
+                                         tw, &reply);
                break;
        case snd_soc_dapm_asrc:
-               ret = sof_widget_load_asrc(scomp, index, swidget, tw, &reply);
+               ret = sof_widget_load_asrc(scomp, index, swidget, comp.core,
+                                          tw, &reply);
                break;
        case snd_soc_dapm_siggen:
-               ret = sof_widget_load_siggen(scomp, index, swidget, tw, &reply);
+               ret = sof_widget_load_siggen(scomp, index, swidget, comp.core,
+                                            tw, &reply);
                break;
        case snd_soc_dapm_effect:
-               ret = sof_widget_load_process(scomp, index, swidget, tw,
-                                             &reply);
+               ret = sof_widget_load_process(scomp, index, swidget, comp.core,
+                                             tw, &reply);
                break;
        case snd_soc_dapm_mux:
        case snd_soc_dapm_demux:
-               ret = sof_widget_load_mux(scomp, index, swidget, tw, &reply);
+               ret = sof_widget_load_mux(scomp, index, swidget, comp.core,
+                                         tw, &reply);
                break;
        case snd_soc_dapm_switch:
        case snd_soc_dapm_dai_link: