static int cs35l35_sdin_event(struct snd_soc_dapm_widget *w,
                struct snd_kcontrol *kcontrol, int event)
 {
-       struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
-       struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
+       struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
+       struct cs35l35_private *cs35l35 = snd_soc_component_get_drvdata(component);
        int ret = 0;
 
        switch (event) {
                                   1 << CS35L35_AMP_DIGSFT_SHIFT);
                break;
        default:
-               dev_err(codec->dev, "Invalid event = 0x%x\n", event);
+               dev_err(component->dev, "Invalid event = 0x%x\n", event);
                ret = -EINVAL;
        }
        return ret;
 static int cs35l35_main_amp_event(struct snd_soc_dapm_widget *w,
                struct snd_kcontrol *kcontrol, int event)
 {
-       struct snd_soc_codec *codec = snd_soc_dapm_to_codec(w->dapm);
-       struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
+       struct snd_soc_component *component = snd_soc_dapm_to_component(w->dapm);
+       struct cs35l35_private *cs35l35 = snd_soc_component_get_drvdata(component);
        unsigned int reg[4];
        int i;
 
 
                break;
        default:
-               dev_err(codec->dev, "Invalid event = 0x%x\n", event);
+               dev_err(component->dev, "Invalid event = 0x%x\n", event);
        }
        return 0;
 }
 
 static int cs35l35_set_dai_fmt(struct snd_soc_dai *codec_dai, unsigned int fmt)
 {
-       struct snd_soc_codec *codec = codec_dai->codec;
-       struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
+       struct snd_soc_component *component = codec_dai->component;
+       struct cs35l35_private *cs35l35 = snd_soc_component_get_drvdata(component);
 
        switch (fmt & SND_SOC_DAIFMT_MASTER_MASK) {
        case SND_SOC_DAIFMT_CBM_CFM:
                                 struct snd_pcm_hw_params *params,
                                 struct snd_soc_dai *dai)
 {
-       struct snd_soc_codec *codec = dai->codec;
-       struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
+       struct snd_soc_component *component = dai->component;
+       struct cs35l35_private *cs35l35 = snd_soc_component_get_drvdata(component);
        struct classh_cfg *classh = &cs35l35->pdata.classh_algo;
        int srate = params_rate(params);
        int ret = 0;
        int clk_ctl = cs35l35_get_clk_config(cs35l35->sysclk, srate);
 
        if (clk_ctl < 0) {
-               dev_err(codec->dev, "Invalid CLK:Rate %d:%d\n",
+               dev_err(component->dev, "Invalid CLK:Rate %d:%d\n",
                        cs35l35->sysclk, srate);
                return -EINVAL;
        }
        ret = regmap_update_bits(cs35l35->regmap, CS35L35_CLK_CTL2,
                          CS35L35_CLK_CTL2_MASK, clk_ctl);
        if (ret != 0) {
-               dev_err(codec->dev, "Failed to set port config %d\n", ret);
+               dev_err(component->dev, "Failed to set port config %d\n", ret);
                return ret;
        }
 
                                        CS35L35_CH_WKFET_DEL_MASK,
                                        0 << CS35L35_CH_WKFET_DEL_SHIFT);
                if (ret != 0) {
-                       dev_err(codec->dev, "Failed to set fet config %d\n",
+                       dev_err(component->dev, "Failed to set fet config %d\n",
                                ret);
                        return ret;
                }
                        audin_format = CS35L35_SDIN_DEPTH_24;
                        break;
                default:
-                       dev_err(codec->dev, "Unsupported Width %d\n",
+                       dev_err(component->dev, "Unsupported Width %d\n",
                                params_width(params));
                        return -EINVAL;
                }
                 * to configure the CLOCK_CTL3 register correctly
                 */
                if ((cs35l35->sclk / srate) % 4) {
-                       dev_err(codec->dev, "Unsupported sclk/fs ratio %d:%d\n",
+                       dev_err(component->dev, "Unsupported sclk/fs ratio %d:%d\n",
                                        cs35l35->sclk, srate);
                        return -EINVAL;
                }
                        case CS35L35_SP_SCLKS_64FS:
                                break;
                        default:
-                               dev_err(codec->dev, "ratio not supported\n");
+                               dev_err(component->dev, "ratio not supported\n");
                                return -EINVAL;
                        }
                } else {
                        case CS35L35_SP_SCLKS_64FS:
                                break;
                        default:
-                               dev_err(codec->dev, "ratio not supported\n");
+                               dev_err(component->dev, "ratio not supported\n");
                                return -EINVAL;
                        }
                }
                                        CS35L35_SP_SCLKS_MASK, sp_sclks <<
                                        CS35L35_SP_SCLKS_SHIFT);
                if (ret != 0) {
-                       dev_err(codec->dev, "Failed to set fsclk %d\n", ret);
+                       dev_err(component->dev, "Failed to set fsclk %d\n", ret);
                        return ret;
                }
        }
 static int cs35l35_pcm_startup(struct snd_pcm_substream *substream,
                               struct snd_soc_dai *dai)
 {
-       struct snd_soc_codec *codec = dai->codec;
-       struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
+       struct snd_soc_component *component = dai->component;
+       struct cs35l35_private *cs35l35 = snd_soc_component_get_drvdata(component);
 
        if (!substream->runtime)
                return 0;
 static int cs35l35_pdm_startup(struct snd_pcm_substream *substream,
                               struct snd_soc_dai *dai)
 {
-       struct snd_soc_codec *codec = dai->codec;
-       struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
+       struct snd_soc_component *component = dai->component;
+       struct cs35l35_private *cs35l35 = snd_soc_component_get_drvdata(component);
 
        if (!substream->runtime)
                return 0;
 static int cs35l35_dai_set_sysclk(struct snd_soc_dai *dai,
                                int clk_id, unsigned int freq, int dir)
 {
-       struct snd_soc_codec *codec = dai->codec;
-       struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
+       struct snd_soc_component *component = dai->component;
+       struct cs35l35_private *cs35l35 = snd_soc_component_get_drvdata(component);
 
        /* Need the SCLK Frequency regardless of sysclk source for I2S */
        cs35l35->sclk = freq;
        },
 };
 
-static int cs35l35_codec_set_sysclk(struct snd_soc_codec *codec,
+static int cs35l35_component_set_sysclk(struct snd_soc_component *component,
                                int clk_id, int source, unsigned int freq,
                                int dir)
 {
-       struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
+       struct cs35l35_private *cs35l35 = snd_soc_component_get_drvdata(component);
        int clksrc;
        int ret = 0;
 
                clksrc = CS35L35_CLK_SOURCE_PDM;
                break;
        default:
-               dev_err(codec->dev, "Invalid CLK Source\n");
+               dev_err(component->dev, "Invalid CLK Source\n");
                return -EINVAL;
        }
 
                cs35l35->sysclk = freq;
                break;
        default:
-               dev_err(codec->dev, "Invalid CLK Frequency Input : %d\n", freq);
+               dev_err(component->dev, "Invalid CLK Frequency Input : %d\n", freq);
                return -EINVAL;
        }
 
                                CS35L35_CLK_SOURCE_MASK,
                                clksrc << CS35L35_CLK_SOURCE_SHIFT);
        if (ret != 0) {
-               dev_err(codec->dev, "Failed to set sysclk %d\n", ret);
+               dev_err(component->dev, "Failed to set sysclk %d\n", ret);
                return ret;
        }
 
        return 0;
 }
 
-static int cs35l35_codec_probe(struct snd_soc_codec *codec)
+static int cs35l35_component_probe(struct snd_soc_component *component)
 {
-       struct cs35l35_private *cs35l35 = snd_soc_codec_get_drvdata(codec);
+       struct cs35l35_private *cs35l35 = snd_soc_component_get_drvdata(component);
        struct classh_cfg *classh = &cs35l35->pdata.classh_algo;
        struct monitor_cfg *monitor_config = &cs35l35->pdata.mon_cfg;
        int ret;
                        regmap_update_bits(cs35l35->regmap, CS35L35_CLASS_H_CTL,
                                        CS35L35_CH_STEREO_MASK,
                                        1 << CS35L35_CH_STEREO_SHIFT);
-               ret = snd_soc_add_codec_controls(codec, cs35l35_adv_controls,
+               ret = snd_soc_add_component_controls(component, cs35l35_adv_controls,
                                        ARRAY_SIZE(cs35l35_adv_controls));
                if (ret)
                        return ret;
        return 0;
 }
 
-static const struct snd_soc_codec_driver soc_codec_dev_cs35l35 = {
-       .probe = cs35l35_codec_probe,
-       .set_sysclk = cs35l35_codec_set_sysclk,
-       .component_driver = {
-               .dapm_widgets = cs35l35_dapm_widgets,
-               .num_dapm_widgets = ARRAY_SIZE(cs35l35_dapm_widgets),
-
-               .dapm_routes = cs35l35_audio_map,
-               .num_dapm_routes = ARRAY_SIZE(cs35l35_audio_map),
-
-               .controls = cs35l35_aud_controls,
-               .num_controls = ARRAY_SIZE(cs35l35_aud_controls),
-       },
-
+static const struct snd_soc_component_driver soc_component_dev_cs35l35 = {
+       .probe                  = cs35l35_component_probe,
+       .set_sysclk             = cs35l35_component_set_sysclk,
+       .dapm_widgets           = cs35l35_dapm_widgets,
+       .num_dapm_widgets       = ARRAY_SIZE(cs35l35_dapm_widgets),
+       .dapm_routes            = cs35l35_audio_map,
+       .num_dapm_routes        = ARRAY_SIZE(cs35l35_audio_map),
+       .controls               = cs35l35_aud_controls,
+       .num_controls           = ARRAY_SIZE(cs35l35_aud_controls),
+       .idle_bias_on           = 1,
+       .use_pmdown_time        = 1,
+       .endianness             = 1,
+       .non_legacy_dai_naming  = 1,
 };
 
 static struct regmap_config cs35l35_regmap = {
        regmap_update_bits(cs35l35->regmap, CS35L35_PROTECT_CTL,
                CS35L35_AMP_MUTE_MASK, 1 << CS35L35_AMP_MUTE_SHIFT);
 
-       ret =  snd_soc_register_codec(dev, &soc_codec_dev_cs35l35, cs35l35_dai,
-                                     ARRAY_SIZE(cs35l35_dai));
+       ret = devm_snd_soc_register_component(dev, &soc_component_dev_cs35l35,
+                                       cs35l35_dai, ARRAY_SIZE(cs35l35_dai));
        if (ret < 0) {
-               dev_err(dev, "Failed to register codec: %d\n", ret);
+               dev_err(dev, "Failed to register component: %d\n", ret);
                goto err;
        }
 
        return ret;
 }
 
-static int cs35l35_i2c_remove(struct i2c_client *client)
-{
-       snd_soc_unregister_codec(&client->dev);
-       return 0;
-}
-
 static const struct of_device_id cs35l35_of_match[] = {
        {.compatible = "cirrus,cs35l35"},
        {},
        },
        .id_table = cs35l35_id,
        .probe = cs35l35_i2c_probe,
-       .remove = cs35l35_i2c_remove,
 };
 
 module_i2c_driver(cs35l35_i2c_driver);