8 files changed, 135 insertions, 189 deletions

diff --git a/include/sound/soc-dapm.h b/include/sound/soc-dapm.h
index 8d7416e46861..485fc9d1a7bc 100644
--- a/include/sound/soc-dapm.h
+++ b/include/sound/soc-dapm.h
@@ -586,8 +586,6 @@ struct snd_soc_dapm_update {
 /* DAPM context */
 struct snd_soc_dapm_context {
         enum snd_soc_bias_level bias_level;
-        enum snd_soc_bias_level suspend_bias_level;
-        struct delayed_work delayed_work;
         unsigned int idle_bias_off:1; /* Use BIAS_OFF instead of STANDBY */
         /* Go to BIAS_OFF in suspend if the DAPM context is idle */
         unsigned int suspend_bias_off:1;
diff --git a/include/sound/soc-dpcm.h b/include/sound/soc-dpcm.h
index 98f2ade0266e..806059052bfc 100644
--- a/include/sound/soc-dpcm.h
+++ b/include/sound/soc-dpcm.h
@@ -135,7 +135,7 @@ void snd_soc_dpcm_be_set_state(struct snd_soc_pcm_runtime *be, int stream,
 
 /* internal use only */
 int soc_dpcm_be_digital_mute(struct snd_soc_pcm_runtime *fe, int mute);
-int soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd);
+void soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd);
 int soc_dpcm_runtime_update(struct snd_soc_card *);
 
 int dpcm_path_get(struct snd_soc_pcm_runtime *fe,
diff --git a/sound/soc/codecs/wm8350.c b/sound/soc/codecs/wm8350.c
index c81a9eab3e3e..c65e5a75fc1a 100644
--- a/sound/soc/codecs/wm8350.c
+++ b/sound/soc/codecs/wm8350.c
@@ -69,14 +69,14 @@ struct wm8350_data {
         struct regulator_bulk_data supplies[ARRAY_SIZE(supply_names)];
         int fll_freq_out;
         int fll_freq_in;
+        struct delayed_work pga_work;
 };
 
 /*
  * Ramp OUT1 PGA volume to minimise pops at stream startup and shutdown.
  */
-static inline int wm8350_out1_ramp_step(struct snd_soc_codec *codec)
+static inline int wm8350_out1_ramp_step(struct wm8350_data *wm8350_data)
 {
-        struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec);
         struct wm8350_output *out1 = &wm8350_data->out1;
         struct wm8350 *wm8350 = wm8350_data->wm8350;
         int left_complete = 0, right_complete = 0;
@@ -140,9 +140,8 @@ static inline int wm8350_out1_ramp_step(struct snd_soc_codec *codec)
 /*
  * Ramp OUT2 PGA volume to minimise pops at stream startup and shutdown.
  */
-static inline int wm8350_out2_ramp_step(struct snd_soc_codec *codec)
+static inline int wm8350_out2_ramp_step(struct wm8350_data *wm8350_data)
 {
-        struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec);
         struct wm8350_output *out2 = &wm8350_data->out2;
         struct wm8350 *wm8350 = wm8350_data->wm8350;
         int left_complete = 0, right_complete = 0;
@@ -210,10 +209,8 @@ static inline int wm8350_out2_ramp_step(struct snd_soc_codec *codec)
  */
 static void wm8350_pga_work(struct work_struct *work)
 {
-        struct snd_soc_dapm_context *dapm =
-            container_of(work, struct snd_soc_dapm_context, delayed_work.work);
-        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
-        struct wm8350_data *wm8350_data = snd_soc_codec_get_drvdata(codec);
+        struct wm8350_data *wm8350_data =
+                container_of(work, struct wm8350_data, pga_work.work);
         struct wm8350_output *out1 = &wm8350_data->out1,
             *out2 = &wm8350_data->out2;
         int i, out1_complete, out2_complete;
@@ -226,9 +223,9 @@ static void wm8350_pga_work(struct work_struct *work)
         for (i = 0; i <= 63; i++) {
                 out1_complete = 1, out2_complete = 1;
                 if (out1->ramp != WM8350_RAMP_NONE)
-                        out1_complete = wm8350_out1_ramp_step(codec);
+                        out1_complete = wm8350_out1_ramp_step(wm8350_data);
                 if (out2->ramp != WM8350_RAMP_NONE)
-                        out2_complete = wm8350_out2_ramp_step(codec);
+                        out2_complete = wm8350_out2_ramp_step(wm8350_data);
 
                 /* ramp finished ? */
                 if (out1_complete && out2_complete)
@@ -283,7 +280,7 @@ static int pga_event(struct snd_soc_dapm_widget *w,
                 out->ramp = WM8350_RAMP_UP;
                 out->active = 1;
 
-                schedule_delayed_work(&codec->dapm.delayed_work,
+                schedule_delayed_work(&wm8350_data->pga_work,
                                       msecs_to_jiffies(1));
                 break;
 
@@ -291,7 +288,7 @@ static int pga_event(struct snd_soc_dapm_widget *w,
                 out->ramp = WM8350_RAMP_DOWN;
                 out->active = 0;
 
-                schedule_delayed_work(&codec->dapm.delayed_work,
+                schedule_delayed_work(&wm8350_data->pga_work,
                                       msecs_to_jiffies(1));
                 break;
         }
@@ -1492,7 +1489,7 @@ static  int wm8350_codec_probe(struct snd_soc_codec *codec)
         /* Put the codec into reset if it wasn't already */
         wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA);
 
-        INIT_DELAYED_WORK(&codec->dapm.delayed_work, wm8350_pga_work);
+        INIT_DELAYED_WORK(&priv->pga_work, wm8350_pga_work);
         INIT_DELAYED_WORK(&priv->hpl.work, wm8350_hpl_work);
         INIT_DELAYED_WORK(&priv->hpr.work, wm8350_hpr_work);
 
@@ -1578,7 +1575,7 @@ static int  wm8350_codec_remove(struct snd_soc_codec *codec)
 
         /* if there was any work waiting then we run it now and
          * wait for its completion */
-        flush_delayed_work(&codec->dapm.delayed_work);
+        flush_delayed_work(&priv->pga_work);
 
         wm8350_clear_bits(wm8350, WM8350_POWER_MGMT_5, WM8350_CODEC_ENA);
 
diff --git a/sound/soc/codecs/wm8753.c b/sound/soc/codecs/wm8753.c
index 21ca3a94fc96..c50a5959345f 100644
--- a/sound/soc/codecs/wm8753.c
+++ b/sound/soc/codecs/wm8753.c
@@ -153,6 +153,7 @@ struct wm8753_priv {
         unsigned int hifi_fmt;
 
         int dai_func;
+        struct delayed_work charge_work;
 };
 
 #define wm8753_reset(c) snd_soc_write(c, WM8753_RESET, 0)
@@ -1326,9 +1327,19 @@ static int wm8753_mute(struct snd_soc_dai *dai, int mute)
         return 0;
 }
 
+static void wm8753_charge_work(struct work_struct *work)
+{
+        struct wm8753_priv *wm8753 =
+                container_of(work, struct wm8753_priv, charge_work.work);
+
+        /* Set to 500k */
+        regmap_update_bits(wm8753->regmap, WM8753_PWR1, 0x0180, 0x0100);
+}
+
 static int wm8753_set_bias_level(struct snd_soc_codec *codec,
                                  enum snd_soc_bias_level level)
 {
+        struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec);
         u16 pwr_reg = snd_soc_read(codec, WM8753_PWR1) & 0xfe3e;
 
         switch (level) {
@@ -1337,14 +1348,22 @@ static int wm8753_set_bias_level(struct snd_soc_codec *codec,
                 snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x00c0);
                 break;
         case SND_SOC_BIAS_PREPARE:
-                /* set vmid to 5k for quick power up */
-                snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x01c1);
+                /* Wait until fully charged */
+                flush_delayed_work(&wm8753->charge_work);
                 break;
         case SND_SOC_BIAS_STANDBY:
-                /* mute dac and set vmid to 500k, enable VREF */
-                snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x0141);
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
+                        /* set vmid to 5k for quick power up */
+                        snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x01c1);
+                        schedule_delayed_work(&wm8753->charge_work,
+                                msecs_to_jiffies(caps_charge));
+                } else {
+                        /* mute dac and set vmid to 500k, enable VREF */
+                        snd_soc_write(codec, WM8753_PWR1, pwr_reg | 0x0141);
+                }
                 break;
         case SND_SOC_BIAS_OFF:
+                cancel_delayed_work_sync(&wm8753->charge_work);
                 snd_soc_write(codec, WM8753_PWR1, 0x0001);
                 break;
         }
@@ -1428,38 +1447,12 @@ static struct snd_soc_dai_driver wm8753_dai[] = {
 },
 };
 
-static void wm8753_work(struct work_struct *work)
-{
-        struct snd_soc_dapm_context *dapm =
-                container_of(work, struct snd_soc_dapm_context,
-                             delayed_work.work);
-        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
-        wm8753_set_bias_level(codec, dapm->bias_level);
-}
-
-static int wm8753_suspend(struct snd_soc_codec *codec)
-{
-        wm8753_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        return 0;
-}
-
 static int wm8753_resume(struct snd_soc_codec *codec)
 {
         struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec);
 
         regcache_sync(wm8753->regmap);
 
-        wm8753_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
-
-        /* charge wm8753 caps */
-        if (codec->dapm.suspend_bias_level == SND_SOC_BIAS_ON) {
-                wm8753_set_bias_level(codec, SND_SOC_BIAS_PREPARE);
-                codec->dapm.bias_level = SND_SOC_BIAS_ON;
-                queue_delayed_work(system_power_efficient_wq,
-                                   &codec->dapm.delayed_work,
-                                   msecs_to_jiffies(caps_charge));
-        }
-
         return 0;
 }
 
@@ -1468,7 +1461,7 @@ static int wm8753_probe(struct snd_soc_codec *codec)
         struct wm8753_priv *wm8753 = snd_soc_codec_get_drvdata(codec);
         int ret;
 
-        INIT_DELAYED_WORK(&codec->dapm.delayed_work, wm8753_work);
+        INIT_DELAYED_WORK(&wm8753->charge_work, wm8753_charge_work);
 
         ret = wm8753_reset(codec);
         if (ret < 0) {
@@ -1476,14 +1469,8 @@ static int wm8753_probe(struct snd_soc_codec *codec)
                 return ret;
         }
 
-        wm8753_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
         wm8753->dai_func = 0;
 
-        /* charge output caps */
-        wm8753_set_bias_level(codec, SND_SOC_BIAS_PREPARE);
-        schedule_delayed_work(&codec->dapm.delayed_work,
-                              msecs_to_jiffies(caps_charge));
-
         /* set the update bits */
         snd_soc_update_bits(codec, WM8753_LDAC, 0x0100, 0x0100);
         snd_soc_update_bits(codec, WM8753_RDAC, 0x0100, 0x0100);
@@ -1499,21 +1486,11 @@ static int wm8753_probe(struct snd_soc_codec *codec)
         return 0;
 }
 
-/* power down chip */
-static int wm8753_remove(struct snd_soc_codec *codec)
-{
-        flush_delayed_work(&codec->dapm.delayed_work);
-        wm8753_set_bias_level(codec, SND_SOC_BIAS_OFF);
-
-        return 0;
-}
-
 static struct snd_soc_codec_driver soc_codec_dev_wm8753 = {
         .probe =        wm8753_probe,
-        .remove =       wm8753_remove,
-        .suspend =      wm8753_suspend,
         .resume =       wm8753_resume,
         .set_bias_level = wm8753_set_bias_level,
+        .suspend_bias_off = true,
 
         .controls = wm8753_snd_controls,
         .num_controls = ARRAY_SIZE(wm8753_snd_controls),
diff --git a/sound/soc/codecs/wm8971.c b/sound/soc/codecs/wm8971.c
index 39ddb9b8834c..f9cbabdc6238 100644
--- a/sound/soc/codecs/wm8971.c
+++ b/sound/soc/codecs/wm8971.c
@@ -31,11 +31,11 @@
 
 #define WM8971_REG_COUNT                43
 
-static struct workqueue_struct *wm8971_workq = NULL;
-
 /* codec private data */
 struct wm8971_priv {
         unsigned int sysclk;
+        struct delayed_work charge_work;
+        struct regmap *regmap;
 };
 
 /*
@@ -552,9 +552,19 @@ static int wm8971_mute(struct snd_soc_dai *dai, int mute)
         return 0;
 }
 
+static void wm8971_charge_work(struct work_struct *work)
+{
+        struct wm8971_priv *wm8971 =
+                container_of(work, struct wm8971_priv, charge_work.work);
+
+        /* Set to 500k */
+        regmap_update_bits(wm8971->regmap, WM8971_PWR1, 0x0180, 0x0100);
+}
+
 static int wm8971_set_bias_level(struct snd_soc_codec *codec,
         enum snd_soc_bias_level level)
 {
+        struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec);
         u16 pwr_reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e;
 
         switch (level) {
@@ -563,15 +573,24 @@ static int wm8971_set_bias_level(struct snd_soc_codec *codec,
                 snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x00c1);
                 break;
         case SND_SOC_BIAS_PREPARE:
+                /* Wait until fully charged */
+                flush_delayed_work(&wm8971->charge_work);
                 break;
         case SND_SOC_BIAS_STANDBY:
-                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF)
+                if (codec->dapm.bias_level == SND_SOC_BIAS_OFF) {
                         snd_soc_cache_sync(codec);
+                        /* charge output caps - set vmid to 5k for quick power up */
+                        snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x01c0);
+                        queue_delayed_work(system_power_efficient_wq,
+                                &wm8971->charge_work, msecs_to_jiffies(1000));
+                } else {
+                        /* mute dac and set vmid to 500k, enable VREF */
+                        snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x0140);
+                }
 
-                /* mute dac and set vmid to 500k, enable VREF */
-                snd_soc_write(codec, WM8971_PWR1, pwr_reg | 0x0140);
                 break;
         case SND_SOC_BIAS_OFF:
+                cancel_delayed_work_sync(&wm8971->charge_work);
                 snd_soc_write(codec, WM8971_PWR1, 0x0001);
                 break;
         }
@@ -610,58 +629,14 @@ static struct snd_soc_dai_driver wm8971_dai = {
         .ops = &wm8971_dai_ops,
 };
 
-static void wm8971_work(struct work_struct *work)
-{
-        struct snd_soc_dapm_context *dapm =
-                container_of(work, struct snd_soc_dapm_context,
-                             delayed_work.work);
-        struct snd_soc_codec *codec = snd_soc_dapm_to_codec(dapm);
-        wm8971_set_bias_level(codec, codec->dapm.bias_level);
-}
-
-static int wm8971_suspend(struct snd_soc_codec *codec)
-{
-        wm8971_set_bias_level(codec, SND_SOC_BIAS_OFF);
-        return 0;
-}
-
-static int wm8971_resume(struct snd_soc_codec *codec)
-{
-        u16 reg;
-
-        wm8971_set_bias_level(codec, SND_SOC_BIAS_STANDBY);
-
-        /* charge wm8971 caps */
-        if (codec->dapm.suspend_bias_level == SND_SOC_BIAS_ON) {
-                reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e;
-                snd_soc_write(codec, WM8971_PWR1, reg | 0x01c0);
-                codec->dapm.bias_level = SND_SOC_BIAS_ON;
-                queue_delayed_work(wm8971_workq, &codec->dapm.delayed_work,
-                        msecs_to_jiffies(1000));
-        }
-
-        return 0;
-}
-
 static int wm8971_probe(struct snd_soc_codec *codec)
 {
-        int ret = 0;
-        u16 reg;
+        struct wm8971_priv *wm8971 = snd_soc_codec_get_drvdata(codec);
 
-        INIT_DELAYED_WORK(&codec->dapm.delayed_work, wm8971_work);
-        wm8971_workq = create_workqueue("wm8971");
-        if (wm8971_workq == NULL)
-                return -ENOMEM;
+        INIT_DELAYED_WORK(&wm8971->charge_work, wm8971_charge_work);
 
         wm8971_reset(codec);
 
-        /* charge output caps - set vmid to 5k for quick power up */
-        reg = snd_soc_read(codec, WM8971_PWR1) & 0xfe3e;
-        snd_soc_write(codec, WM8971_PWR1, reg | 0x01c0);
-        codec->dapm.bias_level = SND_SOC_BIAS_STANDBY;
-        queue_delayed_work(wm8971_workq, &codec->dapm.delayed_work,
-                msecs_to_jiffies(1000));
-
         /* set the update bits */
         snd_soc_update_bits(codec, WM8971_LDAC, 0x0100, 0x0100);
         snd_soc_update_bits(codec, WM8971_RDAC, 0x0100, 0x0100);
@@ -672,26 +647,13 @@ static int wm8971_probe(struct snd_soc_codec *codec)
         snd_soc_update_bits(codec, WM8971_LINVOL, 0x0100, 0x0100);
         snd_soc_update_bits(codec, WM8971_RINVOL, 0x0100, 0x0100);
 
-        return ret;
-}
-
-
-/* power down chip */
-static int wm8971_remove(struct snd_soc_codec *codec)
-{
-        wm8971_set_bias_level(codec, SND_SOC_BIAS_OFF);
-
-        if (wm8971_workq)
-                destroy_workqueue(wm8971_workq);
         return 0;
 }
 
 static struct snd_soc_codec_driver soc_codec_dev_wm8971 = {
         .probe =        wm8971_probe,
-        .remove =       wm8971_remove,
-        .suspend =      wm8971_suspend,
-        .resume =       wm8971_resume,
         .set_bias_level = wm8971_set_bias_level,
+        .suspend_bias_off = true,
 
         .controls = wm8971_snd_controls,
         .num_controls = ARRAY_SIZE(wm8971_snd_controls),
@@ -715,7 +677,6 @@ static int wm8971_i2c_probe(struct i2c_client *i2c,
                             const struct i2c_device_id *id)
 {
         struct wm8971_priv *wm8971;
-        struct regmap *regmap;
         int ret;
 
         wm8971 = devm_kzalloc(&i2c->dev, sizeof(struct wm8971_priv),
@@ -723,9 +684,9 @@ static int wm8971_i2c_probe(struct i2c_client *i2c,
         if (wm8971 == NULL)
                 return -ENOMEM;
 
-        regmap = devm_regmap_init_i2c(i2c, &wm8971_regmap);
-        if (IS_ERR(regmap))
-                return PTR_ERR(regmap);
+        wm8971->regmap = devm_regmap_init_i2c(i2c, &wm8971_regmap);
+        if (IS_ERR(wm8971->regmap))
+                return PTR_ERR(wm8971->regmap);
 
         i2c_set_clientdata(i2c, wm8971);
 
diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index 07aa54385ae0..2fb3bf738b5b 100644
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -292,6 +292,9 @@ static const struct file_operations codec_reg_fops = {
 
 static void soc_init_component_debugfs(struct snd_soc_component *component)
 {
+        if (!component->card->debugfs_card_root)
+                return;
+
         if (component->debugfs_prefix) {
                 char *name;
 
@@ -455,6 +458,9 @@ static const struct file_operations platform_list_fops = {
 
 static void soc_init_card_debugfs(struct snd_soc_card *card)
 {
+        if (!snd_soc_debugfs_root)
+                return;
+
         card->debugfs_card_root = debugfs_create_dir(card->name,
                                                      snd_soc_debugfs_root);
         if (!card->debugfs_card_root) {
@@ -476,6 +482,34 @@ static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
         debugfs_remove_recursive(card->debugfs_card_root);
 }
 
+
+static void snd_soc_debugfs_init(void)
+{
+        snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
+        if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
+                pr_warn("ASoC: Failed to create debugfs directory\n");
+                snd_soc_debugfs_root = NULL;
+                return;
+        }
+
+        if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
+                                 &codec_list_fops))
+                pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
+
+        if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
+                                 &dai_list_fops))
+                pr_warn("ASoC: Failed to create DAI list debugfs file\n");
+
+        if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
+                                 &platform_list_fops))
+                pr_warn("ASoC: Failed to create platform list debugfs file\n");
+}
+
+static void snd_soc_debugfs_exit(void)
+{
+        debugfs_remove_recursive(snd_soc_debugfs_root);
+}
+
 #else
 
 #define soc_init_codec_debugfs NULL
@@ -497,6 +531,15 @@ static inline void soc_init_card_debugfs(struct snd_soc_card *card)
 static inline void soc_cleanup_card_debugfs(struct snd_soc_card *card)
 {
 }
+
+static inline void snd_soc_debugfs_init(void)
+{
+}
+
+static inline void snd_soc_debugfs_exit(void)
+{
+}
+
 #endif
 
 struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
@@ -595,15 +638,9 @@ int snd_soc_suspend(struct device *dev)
                         cpu_dai->driver->suspend(cpu_dai);
         }
 
-        /* close any waiting streams and save state */
-        for (i = 0; i < card->num_rtd; i++) {
-                struct snd_soc_dai **codec_dais = card->rtd[i].codec_dais;
+        /* close any waiting streams */
+        for (i = 0; i < card->num_rtd; i++)
                 flush_delayed_work(&card->rtd[i].delayed_work);
-                for (j = 0; j < card->rtd[i].num_codecs; j++) {
-                        codec_dais[j]->codec->dapm.suspend_bias_level =
-                                        codec_dais[j]->codec->dapm.bias_level;
-                }
-        }
 
         for (i = 0; i < card->num_rtd; i++) {
 
@@ -1322,21 +1359,17 @@ static int soc_probe_link_dais(struct snd_soc_card *card, int num, int order)
                 }
         }
 
+        if (dai_link->dai_fmt)
+                snd_soc_runtime_set_dai_fmt(rtd, dai_link->dai_fmt);
+
         ret = soc_post_component_init(rtd, dai_link->name);
         if (ret)
                 return ret;
 
 #ifdef CONFIG_DEBUG_FS
         /* add DPCM sysfs entries */
-        if (dai_link->dynamic) {
-                ret = soc_dpcm_debugfs_add(rtd);
-                if (ret < 0) {
-                        dev_err(rtd->dev,
-                                "ASoC: failed to add dpcm sysfs entries: %d\n",
-                                ret);
-                        return ret;
-                }
-        }
+        if (dai_link->dynamic)
+                soc_dpcm_debugfs_add(rtd);
 #endif
 
         if (cpu_dai->driver->compress_dai) {
@@ -1426,7 +1459,6 @@ static void soc_remove_aux_dev(struct snd_soc_card *card, int num)
 
         /* unregister the rtd device */
         if (rtd->dev_registered) {
-                device_remove_file(rtd->dev, &dev_attr_codec_reg);
                 device_unregister(rtd->dev);
                 rtd->dev_registered = 0;
         }
@@ -1560,6 +1592,8 @@ static int snd_soc_instantiate_card(struct snd_soc_card *card)
                 goto base_error;
         }
 
+        soc_init_card_debugfs(card);
+
         card->dapm.bias_level = SND_SOC_BIAS_OFF;
         card->dapm.dev = card->dev;
         card->dapm.card = card;
@@ -1641,12 +1675,6 @@ static int snd_soc_instantiate_card(struct snd_soc_card *card)
                 snd_soc_dapm_add_routes(&card->dapm, card->of_dapm_routes,
                                         card->num_of_dapm_routes);
 
-        for (i = 0; i < card->num_links; i++) {
-                if (card->dai_link[i].dai_fmt)
-                        snd_soc_runtime_set_dai_fmt(&card->rtd[i],
-                                card->dai_link[i].dai_fmt);
-        }
-
         snprintf(card->snd_card->shortname, sizeof(card->snd_card->shortname),
                  "%s", card->name);
         snprintf(card->snd_card->longname, sizeof(card->snd_card->longname),
@@ -1702,6 +1730,7 @@ card_probe_error:
         if (card->remove)
                 card->remove(card);
 
+        soc_cleanup_card_debugfs(card);
         snd_card_free(card->snd_card);
 
 base_error:
@@ -2380,8 +2409,6 @@ int snd_soc_register_card(struct snd_soc_card *card)
 
         snd_soc_initialize_card_lists(card);
 
-        soc_init_card_debugfs(card);
-
         card->rtd = devm_kzalloc(card->dev,
                                  sizeof(struct snd_soc_pcm_runtime) *
                                  (card->num_links + card->num_aux_devs),
@@ -2412,7 +2439,7 @@ int snd_soc_register_card(struct snd_soc_card *card)
 
         ret = snd_soc_instantiate_card(card);
         if (ret != 0)
-                soc_cleanup_card_debugfs(card);
+                return ret;
 
         /* deactivate pins to sleep state */
         for (i = 0; i < card->num_rtd; i++) {
@@ -3595,26 +3622,7 @@ EXPORT_SYMBOL_GPL(snd_soc_of_get_dai_link_codecs);
 
 static int __init snd_soc_init(void)
 {
-#ifdef CONFIG_DEBUG_FS
-        snd_soc_debugfs_root = debugfs_create_dir("asoc", NULL);
-        if (IS_ERR(snd_soc_debugfs_root) || !snd_soc_debugfs_root) {
-                pr_warn("ASoC: Failed to create debugfs directory\n");
-                snd_soc_debugfs_root = NULL;
-        }
-
-        if (!debugfs_create_file("codecs", 0444, snd_soc_debugfs_root, NULL,
-                                 &codec_list_fops))
-                pr_warn("ASoC: Failed to create CODEC list debugfs file\n");
-
-        if (!debugfs_create_file("dais", 0444, snd_soc_debugfs_root, NULL,
-                                 &dai_list_fops))
-                pr_warn("ASoC: Failed to create DAI list debugfs file\n");
-
-        if (!debugfs_create_file("platforms", 0444, snd_soc_debugfs_root, NULL,
-                                 &platform_list_fops))
-                pr_warn("ASoC: Failed to create platform list debugfs file\n");
-#endif
-
+        snd_soc_debugfs_init();
         snd_soc_util_init();
 
         return platform_driver_register(&soc_driver);
@@ -3624,9 +3632,9 @@ module_init(snd_soc_init);
 static void __exit snd_soc_exit(void)
 {
         snd_soc_util_exit();
+        snd_soc_debugfs_exit();
 
 #ifdef CONFIG_DEBUG_FS
-        debugfs_remove_recursive(snd_soc_debugfs_root);
 #endif
         platform_driver_unregister(&soc_driver);
 }
diff --git a/sound/soc/soc-dapm.c b/sound/soc/soc-dapm.c
index b6f88202b8c9..1fd2d458824e 100644
--- a/sound/soc/soc-dapm.c
+++ b/sound/soc/soc-dapm.c
@@ -1898,6 +1898,9 @@ void snd_soc_dapm_debugfs_init(struct snd_soc_dapm_context *dapm,
 {
         struct dentry *d;
 
+        if (!parent)
+                return;
+
         dapm->debugfs_dapm = debugfs_create_dir("dapm", parent);
 
         if (!dapm->debugfs_dapm) {
diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c
index 6e3781e88f9a..35fe58f4fa86 100644
--- a/sound/soc/soc-pcm.c
+++ b/sound/soc/soc-pcm.c
@@ -1097,8 +1097,9 @@ static int dpcm_be_connect(struct snd_soc_pcm_runtime *fe,
                         stream ? "<-" : "->", be->dai_link->name);
 
 #ifdef CONFIG_DEBUG_FS
-        dpcm->debugfs_state = debugfs_create_u32(be->dai_link->name, 0644,
-                        fe->debugfs_dpcm_root, &dpcm->state);
+        if (fe->debugfs_dpcm_root)
+                dpcm->debugfs_state = debugfs_create_u32(be->dai_link->name, 0644,
+                                fe->debugfs_dpcm_root, &dpcm->state);
 #endif
         return 1;
 }
@@ -2803,10 +2804,13 @@ static const struct file_operations dpcm_state_fops = {
         .llseek = default_llseek,
 };
 
-int soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
+void soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
 {
         if (!rtd->dai_link)
-                return 0;
+                return;
+
+        if (!rtd->card->debugfs_card_root)
+                return;
 
         rtd->debugfs_dpcm_root = debugfs_create_dir(rtd->dai_link->name,
                         rtd->card->debugfs_card_root);
@@ -2814,13 +2818,11 @@ int soc_dpcm_debugfs_add(struct snd_soc_pcm_runtime *rtd)
                 dev_dbg(rtd->dev,
                          "ASoC: Failed to create dpcm debugfs directory %s\n",
                          rtd->dai_link->name);
-                return -EINVAL;
+                return;
         }
 
         rtd->debugfs_dpcm_state = debugfs_create_file("state", 0444,
                                                 rtd->debugfs_dpcm_root,
                                                 rtd, &dpcm_state_fops);
-
-        return 0;
 }
 #endif