static int sst_soc_pcm_new(struct snd_soc_component *component,
                           struct snd_soc_pcm_runtime *rtd)
 {
-       struct snd_soc_dai *dai = rtd->cpu_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_cpu(rtd, 0);
        struct snd_pcm *pcm = rtd->pcm;
 
        if (dai->driver->playback.channels_min ||
 
        /* set the SSPs to idle */
        for_each_card_rtds(drv->soc_card, rtd) {
-               struct snd_soc_dai *dai = rtd->cpu_dai;
+               struct snd_soc_dai *dai = asoc_rtd_to_cpu(rtd, 0);
 
                if (dai->active) {
                        send_ssp_cmd(dai, dai->name, 0);
 
        /* restart SSPs */
        for_each_card_rtds(drv->soc_card, rtd) {
-               struct snd_soc_dai *dai = rtd->cpu_dai;
+               struct snd_soc_dai *dai = asoc_rtd_to_cpu(rtd, 0);
 
                if (dai->active) {
                        sst_handle_vb_timer(dai, true);
 
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        /* Workaround: set codec PLL to 19.2MHz that PLL source is
 {
        struct bdw_rt5650_priv *bdw_rt5650 =
                snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_component *component = rtd->codec_dai->component;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
+       struct snd_soc_component *component = codec_dai->component;
        int ret;
 
        /* Enable codec ASRC function for Stereo DAC/Stereo1 ADC/DMIC/I2S1.
 
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai, RT5677_SCLK_S_MCLK, 24576000,
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai, RT5677_SCLK_S_PLL1, 24576000,
 {
        struct bdw_rt5677_priv *bdw_rt5677 =
                        snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
        int ret;
 
 
 
 static int broadwell_rt286_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        int ret = 0;
        ret = snd_soc_card_jack_new(rtd->card, "Headset",
                SND_JACK_HEADSET | SND_JACK_BTN_0, &broadwell_headset,
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai, RT286_SCLK_S_PLL, 24000000,
 
 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;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        int clk_freq;
 
        /* Configure sysclk for codec */
 static int broxton_hdmi_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct bxt_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct bxt_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 static int broxton_da7219_fe_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_dapm_context *dapm;
-       struct snd_soc_component *component = rtd->cpu_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
 
        dapm = snd_soc_component_get_dapm(component);
        snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
 
 static int broxton_rt298_fe_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_dapm_context *dapm;
-       struct snd_soc_component *component = rtd->cpu_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
 
        dapm = snd_soc_component_get_dapm(component);
        snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
 
 static int broxton_rt298_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        int ret = 0;
 
        ret = snd_soc_card_jack_new(rtd->card, "Headset",
 static int broxton_hdmi_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct bxt_rt286_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct bxt_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai, RT298_SCLK_S_PLL,
 
 
        card->dapm.idle_bias_off = true;
 
-       ret = snd_soc_dai_set_sysclk(runtime->codec_dai,
+       ret = snd_soc_dai_set_sysclk(asoc_rtd_to_codec(runtime, 0),
                                     M98090_REG_SYSTEM_CLOCK,
                                     25000000, SND_SOC_CLOCK_IN);
        if (ret < 0) {
 
                                struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai, RT5640_SCLK_S_PLL1,
 static int byt_rt5640_init(struct snd_soc_pcm_runtime *runtime)
 {
        int ret;
-       struct snd_soc_component *component = runtime->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(runtime, 0)->component;
        struct snd_soc_card *card = runtime->card;
        const struct snd_soc_dapm_route *custom_map;
        int num_routes;
 
 static int byt_cht_cx2072x_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_card *card = rtd->card;
-       struct snd_soc_component *codec = rtd->codec_dai->component;
+       struct snd_soc_component *codec = asoc_rtd_to_codec(rtd, 0)->component;
        int ret;
 
        if (devm_acpi_dev_add_driver_gpios(codec->dev,
        card->dapm.idle_bias_off = true;
 
        /* set the default PLL rate, the clock is handled by the codec driver */
-       ret = snd_soc_dai_set_sysclk(rtd->codec_dai, CX2072X_MCLK_EXTERNAL_PLL,
+       ret = snd_soc_dai_set_sysclk(asoc_rtd_to_codec(rtd, 0), CX2072X_MCLK_EXTERNAL_PLL,
                                     19200000, SND_SOC_CLOCK_IN);
        if (ret) {
                dev_err(rtd->dev, "Could not set sysclk\n");
 
        snd_soc_component_set_jack(codec, &byt_cht_cx2072x_headset, NULL);
 
-       snd_soc_dai_set_bclk_ratio(rtd->codec_dai, 50);
+       snd_soc_dai_set_bclk_ratio(asoc_rtd_to_codec(rtd, 0), 50);
 
        return ret;
 }
         * with explicit setting to I2S 2ch 24-bit. The word length is set with
         * dai_set_tdm_slot() since there is no other API exposed
         */
-       ret = snd_soc_dai_set_fmt(rtd->cpu_dai,
+       ret = snd_soc_dai_set_fmt(asoc_rtd_to_cpu(rtd, 0),
                                SND_SOC_DAIFMT_I2S     |
                                SND_SOC_DAIFMT_NB_NF   |
                                SND_SOC_DAIFMT_CBS_CFS);
                return ret;
        }
 
-       ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, 24);
+       ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2, 24);
        if (ret < 0) {
                dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
                return ret;
 
         * with explicit setting to I2S 2ch 24-bit. The word length is set with
         * dai_set_tdm_slot() since there is no other API exposed
         */
-       ret = snd_soc_dai_set_fmt(rtd->cpu_dai,
+       ret = snd_soc_dai_set_fmt(asoc_rtd_to_cpu(rtd, 0),
                                  SND_SOC_DAIFMT_I2S     |
                                  SND_SOC_DAIFMT_NB_NF   |
                                  SND_SOC_DAIFMT_CBS_CFS);
                return ret;
        }
 
-       ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, 24);
+       ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2, 24);
        if (ret < 0) {
                dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
                return ret;
                          struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai, DA7213_CLKSRC_MCLK,
 static int aif1_hw_free(struct snd_pcm_substream *substream)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_pll(codec_dai, 0,
 
 
 static int byt_cht_es8316_init(struct snd_soc_pcm_runtime *runtime)
 {
-       struct snd_soc_component *codec = runtime->codec_dai->component;
+       struct snd_soc_component *codec = asoc_rtd_to_codec(runtime, 0)->component;
        struct snd_soc_card *card = runtime->card;
        struct byt_cht_es8316_private *priv = snd_soc_card_get_drvdata(card);
        const struct snd_soc_dapm_route *custom_map;
        if (ret)
                dev_err(card->dev, "unable to enable MCLK\n");
 
-       ret = snd_soc_dai_set_sysclk(runtime->codec_dai, 0, 19200000,
+       ret = snd_soc_dai_set_sysclk(asoc_rtd_to_codec(runtime, 0), 0, 19200000,
                                     SND_SOC_CLOCK_IN);
        if (ret < 0) {
                dev_err(card->dev, "can't set codec clock %d\n", ret);
         * with explicit setting to I2S 2ch 24-bit. The word length is set with
         * dai_set_tdm_slot() since there is no other API exposed
         */
-       ret = snd_soc_dai_set_fmt(rtd->cpu_dai,
+       ret = snd_soc_dai_set_fmt(asoc_rtd_to_cpu(rtd, 0),
                                SND_SOC_DAIFMT_I2S     |
                                SND_SOC_DAIFMT_NB_NF   |
                                SND_SOC_DAIFMT_CBS_CFS
                return ret;
        }
 
-       ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, bits);
+       ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2, bits);
        if (ret < 0) {
                dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
                return ret;
 
         * with explicit setting to I2S 2ch 24-bit. The word length is set with
         * dai_set_tdm_slot() since there is no other API exposed
         */
-       ret = snd_soc_dai_set_fmt(rtd->cpu_dai,
+       ret = snd_soc_dai_set_fmt(asoc_rtd_to_cpu(rtd, 0),
                                  SND_SOC_DAIFMT_I2S     |
                                  SND_SOC_DAIFMT_NB_NF   |
                                  SND_SOC_DAIFMT_CBS_CFS);
                return ret;
        }
 
-       ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, 24);
+       ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2, 24);
        if (ret < 0) {
                dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
                return ret;
 
                                        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
 
        return byt_rt5640_prepare_and_enable_pll1(dai, params_rate(params));
 }
 {
        struct snd_soc_card *card = runtime->card;
        struct byt_rt5640_private *priv = snd_soc_card_get_drvdata(card);
-       struct snd_soc_component *component = runtime->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(runtime, 0)->component;
        const struct snd_soc_dapm_route *custom_map;
        int num_routes;
        int ret;
         * with explicit setting to I2S 2ch. The word length is set with
         * dai_set_tdm_slot() since there is no other API exposed
         */
-       ret = snd_soc_dai_set_fmt(rtd->cpu_dai,
+       ret = snd_soc_dai_set_fmt(asoc_rtd_to_cpu(rtd, 0),
                                  SND_SOC_DAIFMT_I2S     |
                                  SND_SOC_DAIFMT_NB_NF   |
                                  SND_SOC_DAIFMT_CBS_CFS);
                return ret;
        }
 
-       ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, bits);
+       ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2, bits);
        if (ret < 0) {
                dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
                return ret;
 
                                        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        snd_pcm_format_t format = params_format(params);
        int rate = params_rate(params);
        int bclk_ratio;
 static int byt_rt5651_init(struct snd_soc_pcm_runtime *runtime)
 {
        struct snd_soc_card *card = runtime->card;
-       struct snd_soc_component *codec = runtime->codec_dai->component;
+       struct snd_soc_component *codec = asoc_rtd_to_codec(runtime, 0)->component;
        struct byt_rt5651_private *priv = snd_soc_card_get_drvdata(card);
        const struct snd_soc_dapm_route *custom_map;
        int num_routes;
         * with explicit setting to I2S 2ch. The word length is set with
         * dai_set_tdm_slot() since there is no other API exposed
         */
-       ret = snd_soc_dai_set_fmt(rtd->cpu_dai,
+       ret = snd_soc_dai_set_fmt(asoc_rtd_to_cpu(rtd, 0),
                                  SND_SOC_DAIFMT_I2S     |
                                  SND_SOC_DAIFMT_NB_NF   |
                                  SND_SOC_DAIFMT_CBS_CFS
                return ret;
        }
 
-       ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, bits);
+       ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2, bits);
        if (ret < 0) {
                dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
                return ret;
 
                             struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai, M98090_REG_SYSTEM_CLOCK,
        int ret = 0;
        unsigned int fmt = 0;
 
-       ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, 16);
+       ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2, 16);
        if (ret < 0) {
                dev_err(rtd->dev, "can't set cpu_dai slot fmt: %d\n", ret);
                return ret;
        fmt = SND_SOC_DAIFMT_I2S | SND_SOC_DAIFMT_NB_NF
                                | SND_SOC_DAIFMT_CBS_CFS;
 
-       ret = snd_soc_dai_set_fmt(rtd->cpu_dai, fmt);
+       ret = snd_soc_dai_set_fmt(asoc_rtd_to_cpu(rtd, 0), fmt);
        if (ret < 0) {
                dev_err(rtd->dev, "can't set cpu_dai set fmt: %d\n", ret);
                return ret;
 
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai, NAU8824_CLK_FLL_FS, 0,
 {
        struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
        struct snd_soc_jack *jack = &ctx->jack;
-       struct snd_soc_dai *codec_dai = runtime->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(runtime, 0);
        struct snd_soc_component *component = codec_dai->component;
        int ret, jack_type;
 
 
                             struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        /* set codec PLL source to the 19.2MHz platform clock (MCLK) */
 {
        struct snd_soc_card *card = runtime->card;
        struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
-       struct snd_soc_component *component = runtime->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(runtime, 0)->component;
        int jack_type;
        int ret;
 
                 * with explicit setting to I2S 2ch 16-bit. The word length is set with
                 * dai_set_tdm_slot() since there is no other API exposed
                 */
-               ret = snd_soc_dai_set_fmt(rtd->cpu_dai,
+               ret = snd_soc_dai_set_fmt(asoc_rtd_to_cpu(rtd, 0),
                                        SND_SOC_DAIFMT_I2S     |
                                        SND_SOC_DAIFMT_NB_NF   |
                                        SND_SOC_DAIFMT_CBS_CFS
                        return ret;
                }
 
-               ret = snd_soc_dai_set_fmt(rtd->codec_dai,
+               ret = snd_soc_dai_set_fmt(asoc_rtd_to_codec(rtd, 0),
                                        SND_SOC_DAIFMT_I2S     |
                                        SND_SOC_DAIFMT_NB_NF   |
                                        SND_SOC_DAIFMT_CBS_CFS
                        return ret;
                }
 
-               ret = snd_soc_dai_set_tdm_slot(rtd->cpu_dai, 0x3, 0x3, 2, 16);
+               ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_cpu(rtd, 0), 0x3, 0x3, 2, 16);
                if (ret < 0) {
                        dev_err(rtd->dev, "can't set I2S config, err %d\n", ret);
                        return ret;
                /*
                 * Default mode for SSP configuration is TDM 4 slot
                 */
-               ret = snd_soc_dai_set_fmt(rtd->codec_dai,
+               ret = snd_soc_dai_set_fmt(asoc_rtd_to_codec(rtd, 0),
                                        SND_SOC_DAIFMT_DSP_B |
                                        SND_SOC_DAIFMT_IB_NF |
                                        SND_SOC_DAIFMT_CBS_CFS);
                }
 
                /* TDM 4 slots 24 bit, set Rx & Tx bitmask to 4 active slots */
-               ret = snd_soc_dai_set_tdm_slot(rtd->codec_dai, 0xF, 0xF, 4, 24);
+               ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_codec(rtd, 0), 0xF, 0xF, 4, 24);
                if (ret < 0) {
                        dev_err(rtd->dev, "can't set codec TDM slot %d\n", ret);
                        return ret;
 
                                        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        /* set codec PLL source to the 19.2MHz platform clock (MCLK) */
 static int cht_codec_init(struct snd_soc_pcm_runtime *runtime)
 {
        int ret;
-       struct snd_soc_dai *codec_dai = runtime->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(runtime, 0);
        struct snd_soc_component *component = codec_dai->component;
        struct cht_mc_private *ctx = snd_soc_card_get_drvdata(runtime->card);
 
        /*
         * Default mode for SSP configuration is TDM 4 slot
         */
-       ret = snd_soc_dai_set_fmt(rtd->codec_dai,
+       ret = snd_soc_dai_set_fmt(asoc_rtd_to_codec(rtd, 0),
                                  SND_SOC_DAIFMT_DSP_B |
                                  SND_SOC_DAIFMT_IB_NF |
                                  SND_SOC_DAIFMT_CBS_CFS);
        }
 
        /* TDM 4 slots 24 bit, set Rx & Tx bitmask to 4 active slots */
-       ret = snd_soc_dai_set_tdm_slot(rtd->codec_dai, 0xF, 0xF, 4, 24);
+       ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_codec(rtd, 0), 0xF, 0xF, 4, 24);
        if (ret < 0) {
                dev_err(rtd->dev, "can't set codec TDM slot %d\n", ret);
                return ret;
 
 static int cml_rt5682_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        struct snd_soc_jack *jack;
        int ret;
 
                                struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int clk_id, clk_freq, pll_out, ret;
 
        clk_id = RT5682_PLL1_S_MCLK;
 static int hdmi_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 
 static int geminilake_rt5682_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct glk_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_component *component = rtd->codec_dai->component;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        struct snd_soc_jack *jack;
        int ret;
 
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        /* Set valid bitmask & configuration for I2S in 24 bit */
 static int geminilake_hdmi_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct glk_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct glk_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 
 static int geminilake_rt5682_fe_init(struct snd_soc_pcm_runtime *rtd)
 {
-       struct snd_soc_component *component = rtd->cpu_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
        struct snd_soc_dapm_context *dapm;
        int ret;
 
 
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai, RT5640_SCLK_S_MCLK, 12288000,
 
 static int kabylake_da7219_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_component *component = rtd->codec_dai->component;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        struct snd_soc_jack *jack;
        int ret;
 
 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device)
 {
        struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct kbl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 static int kabylake_da7219_fe_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_dapm_context *dapm;
-       struct snd_soc_component *component = rtd->cpu_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
 
        dapm = snd_soc_component_get_dapm(component);
        snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
 
 static int kabylake_da7219_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        struct snd_soc_jack *jack;
        struct snd_soc_card *card = rtd->card;
        int ret;
 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device)
 {
        struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct kbl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 static int kabylake_da7219_fe_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_dapm_context *dapm;
-       struct snd_soc_component *component = rtd->cpu_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
 
        dapm = snd_soc_component_get_dapm(component);
        snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
 
 {
        int ret;
        struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        struct snd_soc_dapm_context *dapm = snd_soc_component_get_dapm(component);
 
        ret = devm_acpi_dev_add_driver_gpios(component->dev, acpi_rt5660_gpios);
 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device)
 {
        struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct kbl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai,
 
 {
        int ret;
        struct snd_soc_dapm_context *dapm;
-       struct snd_soc_component *component = rtd->cpu_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
 
        dapm = snd_soc_component_get_dapm(component);
        ret = snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
 {
        int ret;
        struct kbl_rt5663_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        struct snd_soc_jack *jack;
 
        /*
 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device)
 {
        struct kbl_rt5663_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct kbl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        /* use ASRC for internal clocks, as PLL rate isn't multiple of BCLK */
 
 static int kabylake_rt5663_fe_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_dapm_context *dapm;
-       struct snd_soc_component *component = rtd->cpu_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
        int ret;
 
        dapm = snd_soc_component_get_dapm(component);
 {
        int ret;
        struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        struct snd_soc_jack *jack;
 
        /*
 static int kabylake_hdmi_init(struct snd_soc_pcm_runtime *rtd, int device)
 {
        struct kbl_codec_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct kbl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        /* use ASRC for internal clocks, as PLL rate isn't multiple of BCLK */
 
 static int skylake_nau8825_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
        int ret;
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
 
        /*
         * Headset buttons map to the google Reference headset.
 static int skylake_hdmi1_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct skl_nau8825_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct skl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 static int skylake_hdmi2_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct skl_nau8825_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct skl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 static int skylake_hdmi3_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct skl_nau8825_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct skl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 static int skylake_nau8825_fe_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_dapm_context *dapm;
-       struct snd_soc_component *component = rtd->cpu_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
 
        dapm = snd_soc_component_get_dapm(component);
        snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai,
 
        int ret;
 
        /* Slot 1 for left */
-       ret = snd_soc_dai_set_tdm_slot(rtd->codec_dais[0], 0x01, 0x01, 2, 48);
+       ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_codec(rtd, 0), 0x01, 0x01, 2, 48);
        if (ret < 0)
                return ret;
 
        /* Slot 2 for right */
-       ret = snd_soc_dai_set_tdm_slot(rtd->codec_dais[1], 0x02, 0x02, 2, 48);
+       ret = snd_soc_dai_set_tdm_slot(asoc_rtd_to_codec(rtd, 1), 0x02, 0x02, 2, 48);
        if (ret < 0)
                return ret;
 
 static int skylake_nau8825_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
        int ret;
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
 
        /*
         * 4 buttons here map to the google Reference headset
 static int skylake_hdmi1_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct skl_nau88125_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct skl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 static int skylake_hdmi2_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct skl_nau88125_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct skl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 static int skylake_hdmi3_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct skl_nau88125_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct skl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 static int skylake_nau8825_fe_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_dapm_context *dapm;
-       struct snd_soc_component *component = rtd->cpu_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
 
        dapm = snd_soc_component_get_dapm(component);
        snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai,
 
 static int skylake_rt286_fe_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct snd_soc_dapm_context *dapm;
-       struct snd_soc_component *component = rtd->cpu_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_cpu(rtd, 0)->component;
 
        dapm = snd_soc_component_get_dapm(component);
        snd_soc_dapm_ignore_suspend(dapm, "Reference Capture");
 
 static int skylake_rt286_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        int ret;
 
        ret = snd_soc_card_jack_new(rtd->card, "Headset",
 static int skylake_hdmi_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct skl_rt286_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct skl_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
        struct snd_pcm_hw_params *params)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int ret;
 
        ret = snd_soc_dai_set_sysclk(codec_dai, RT286_SCLK_S_PLL, 24000000,
 
 
 static int da7219_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
-       struct snd_soc_component *component = rtd->codec_dai->component;
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
+       struct snd_soc_component *component = codec_dai->component;
        struct snd_soc_jack *jack;
        int ret;
 
        int ret, j;
 
        for (j = 0; j < runtime->num_codecs; j++) {
-               struct snd_soc_dai *codec_dai = runtime->codec_dais[j];
+               struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(runtime, j);
 
                if (!strcmp(codec_dai->component->name, MAXIM_DEV0_NAME)) {
                        /* vmon_slot_no = 0 imon_slot_no = 1 for TX slots */
 static int hdmi_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 
 static int sof_hdmi_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct sof_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct sof_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 
 static int sof_pcm512x_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
-       struct snd_soc_component *codec = rtd->codec_dai->component;
+       struct snd_soc_component *codec = asoc_rtd_to_codec(rtd, 0)->component;
 
        snd_soc_component_update_bits(codec, PCM512x_GPIO_EN, 0x08, 0x08);
        snd_soc_component_update_bits(codec, PCM512x_GPIO_OUTPUT_4, 0x0f, 0x02);
 static int aif1_startup(struct snd_pcm_substream *substream)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_component *codec = rtd->codec_dai->component;
+       struct snd_soc_component *codec = asoc_rtd_to_codec(rtd, 0)->component;
 
        snd_soc_component_update_bits(codec, PCM512x_GPIO_CONTROL_1,
                                      0x08, 0x08);
 static void aif1_shutdown(struct snd_pcm_substream *substream)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
-       struct snd_soc_component *codec = rtd->codec_dai->component;
+       struct snd_soc_component *codec = asoc_rtd_to_codec(rtd, 0)->component;
 
        snd_soc_component_update_bits(codec, PCM512x_GPIO_CONTROL_1,
                                      0x08, 0x00);
 
 static int sof_hdmi_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct sof_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *dai = rtd->codec_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_codec(rtd, 0);
        struct sof_hdmi_pcm *pcm;
 
        pcm = devm_kzalloc(rtd->card->dev, sizeof(*pcm), GFP_KERNEL);
 static int sof_rt5682_codec_init(struct snd_soc_pcm_runtime *rtd)
 {
        struct sof_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_component *component = rtd->codec_dai->component;
+       struct snd_soc_component *component = asoc_rtd_to_codec(rtd, 0)->component;
        struct snd_soc_jack *jack;
        int ret;
 
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
        struct sof_card_private *ctx = snd_soc_card_get_drvdata(rtd->card);
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        int clk_id, clk_freq, pll_out, ret;
 
        if (sof_rt5682_quirk & SOF_RT5682_MCLK_EN) {
 
        u8 channels;
        int ret, dai;
 
-       dai = mod_map[rtd->cpu_dai->id].dai_id;
+       dai = mod_map[asoc_rtd_to_cpu(rtd, 0)->id].dai_id;
        pcm_data = &pdata->pcm[dai][substream->stream];
 
        /* check if we are being called a subsequent time */
                }
                pcm_data->allocated = false;
 
-               pcm_data->stream = sst_hsw_stream_new(hsw, rtd->cpu_dai->id,
+               pcm_data->stream = sst_hsw_stream_new(hsw, asoc_rtd_to_cpu(rtd, 0)->id,
                        hsw_notify_pointer, pcm_data);
                if (pcm_data->stream == NULL) {
                        dev_err(rtd->dev, "error: failed to create stream\n");
                path_id = SST_HSW_STREAM_PATH_SSP0_IN;
 
        /* DSP stream type depends on DAI ID */
-       switch (rtd->cpu_dai->id) {
+       switch (asoc_rtd_to_cpu(rtd, 0)->id) {
        case 0:
                if (substream->stream == SNDRV_PCM_STREAM_PLAYBACK) {
                        stream_type = SST_HSW_STREAM_TYPE_SYSTEM;
                break;
        default:
                dev_err(rtd->dev, "error: invalid DAI ID %d\n",
-                       rtd->cpu_dai->id);
+                       asoc_rtd_to_cpu(rtd, 0)->id);
                return -EINVAL;
        }
 
        dmab = snd_pcm_get_dma_buf(substream);
 
        ret = create_adsp_page_table(substream, pdata, rtd, runtime->dma_area,
-               runtime->dma_bytes, rtd->cpu_dai->id);
+               runtime->dma_bytes, asoc_rtd_to_cpu(rtd, 0)->id);
        if (ret < 0)
                return ret;
 
                pages = runtime->dma_bytes / PAGE_SIZE;
 
        ret = sst_hsw_stream_buffer(hsw, pcm_data->stream,
-               pdata->dmab[rtd->cpu_dai->id][substream->stream].addr,
+               pdata->dmab[asoc_rtd_to_cpu(rtd, 0)->id][substream->stream].addr,
                pages, runtime->dma_bytes, 0,
                snd_sgbuf_get_addr(dmab, 0) >> PAGE_SHIFT);
        if (ret < 0) {
        snd_pcm_uframes_t pos;
        int dai;
 
-       dai = mod_map[rtd->cpu_dai->id].dai_id;
+       dai = mod_map[asoc_rtd_to_cpu(rtd, 0)->id].dai_id;
        pcm_data = &pdata->pcm[dai][substream->stream];
        sst_stream = pcm_data->stream;
 
        u32 position;
        int dai;
 
-       dai = mod_map[rtd->cpu_dai->id].dai_id;
+       dai = mod_map[asoc_rtd_to_cpu(rtd, 0)->id].dai_id;
        pcm_data = &pdata->pcm[dai][substream->stream];
        position = sst_hsw_get_dsp_position(hsw, pcm_data->stream);
 
        struct sst_hsw *hsw = pdata->hsw;
        int dai;
 
-       dai = mod_map[rtd->cpu_dai->id].dai_id;
+       dai = mod_map[asoc_rtd_to_cpu(rtd, 0)->id].dai_id;
        pcm_data = &pdata->pcm[dai][substream->stream];
 
        mutex_lock(&pcm_data->mutex);
 
        snd_soc_set_runtime_hwparams(substream, &hsw_pcm_hardware);
 
-       pcm_data->stream = sst_hsw_stream_new(hsw, rtd->cpu_dai->id,
+       pcm_data->stream = sst_hsw_stream_new(hsw, asoc_rtd_to_cpu(rtd, 0)->id,
                hsw_notify_pointer, pcm_data);
        if (pcm_data->stream == NULL) {
                dev_err(rtd->dev, "error: failed to create stream\n");
        struct sst_hsw *hsw = pdata->hsw;
        int ret, dai;
 
-       dai = mod_map[rtd->cpu_dai->id].dai_id;
+       dai = mod_map[asoc_rtd_to_cpu(rtd, 0)->id].dai_id;
        pcm_data = &pdata->pcm[dai][substream->stream];
 
        mutex_lock(&pcm_data->mutex);
                        hsw_pcm_hardware.buffer_bytes_max);
        }
        if (pcm->streams[SNDRV_PCM_STREAM_PLAYBACK].substream)
-               priv_data->pcm[rtd->cpu_dai->id][SNDRV_PCM_STREAM_PLAYBACK].hsw_pcm = pcm;
+               priv_data->pcm[asoc_rtd_to_cpu(rtd, 0)->id][SNDRV_PCM_STREAM_PLAYBACK].hsw_pcm = pcm;
        if (pcm->streams[SNDRV_PCM_STREAM_CAPTURE].substream)
-               priv_data->pcm[rtd->cpu_dai->id][SNDRV_PCM_STREAM_CAPTURE].hsw_pcm = pcm;
+               priv_data->pcm[asoc_rtd_to_cpu(rtd, 0)->id][SNDRV_PCM_STREAM_CAPTURE].hsw_pcm = pcm;
 
        return 0;
 }
 
        struct hdac_bus *bus = dev_get_drvdata(dai->dev);
        struct hdac_ext_stream *link_dev;
        struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        struct skl_pipe_params p_params = {0};
        struct hdac_ext_link *link;
        int stream_tag;
 
        link_dev->link_prepared = 0;
 
-       link = snd_hdac_ext_bus_get_link(bus, rtd->codec_dai->component->name);
+       link = snd_hdac_ext_bus_get_link(bus, asoc_rtd_to_codec(rtd, 0)->component->name);
        if (!link)
                return -EINVAL;
 
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
        struct snd_soc_dai_link *dai_link = rtd->dai_link;
 
-       dev_dbg(rtd->cpu_dai->dev, "In %s:%s\n", __func__,
+       dev_dbg(asoc_rtd_to_cpu(rtd, 0)->dev, "In %s:%s\n", __func__,
                                        dai_link->cpus->dai_name);
 
        snd_soc_set_runtime_hwparams(substream, &azx_pcm_hw);
                                u64 nsec)
 {
        struct snd_soc_pcm_runtime *rtd = snd_pcm_substream_chip(substream);
-       struct snd_soc_dai *codec_dai = rtd->codec_dai;
+       struct snd_soc_dai *codec_dai = asoc_rtd_to_codec(rtd, 0);
        u64 codec_frames, codec_nsecs;
 
        if (!codec_dai->driver->ops->delay)
 static int skl_platform_soc_new(struct snd_soc_component *component,
                                struct snd_soc_pcm_runtime *rtd)
 {
-       struct snd_soc_dai *dai = rtd->cpu_dai;
+       struct snd_soc_dai *dai = asoc_rtd_to_cpu(rtd, 0);
        struct hdac_bus *bus = dev_get_drvdata(dai->dev);
        struct snd_pcm *pcm = rtd->pcm;
        unsigned int size;