Merge branch 'topic/pcm' of git://git.kernel.org/pub/scm/linux/kernel/git/broonie...

diff --git a/include/sound/soc.h b/include/sound/soc.h
index 230b8eedd9f2602251641ac2750df1c9fa584526..df819f76cbf69fe9acda79ff50f1a00616ae42cb 100644 (file)
--- a/include/sound/soc.h
+++ b/include/sound/soc.h
@@ -469,10 +469,10 @@ int snd_soc_register_codec(struct device *dev,
                struct snd_soc_dai_driver *dai_drv, int num_dai);
 void snd_soc_unregister_codec(struct device *dev);
 int snd_soc_register_component(struct device *dev,
-                        const struct snd_soc_component_driver *cmpnt_drv,
+                        const struct snd_soc_component_driver *component_driver,
                         struct snd_soc_dai_driver *dai_drv, int num_dai);
 int devm_snd_soc_register_component(struct device *dev,
-                        const struct snd_soc_component_driver *cmpnt_drv,
+                        const struct snd_soc_component_driver *component_driver,
                         struct snd_soc_dai_driver *dai_drv, int num_dai);
 void snd_soc_unregister_component(struct device *dev);
 int snd_soc_cache_init(struct snd_soc_codec *codec);
@@ -886,6 +886,18 @@ struct snd_soc_component {
 #endif
 };
 
+struct snd_soc_rtdcom_list {
+       struct snd_soc_component *component;
+       struct list_head list; /* rtd::component_list */
+};
+struct snd_soc_component*
+snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
+                      const char *driver_name);
+#define for_each_rtdcom(rtd, rtdcom) \
+       list_for_each_entry(rtdcom, &(rtd)->component_list, list)
+#define for_each_rtdcom_safe(rtd, rtdcom1, rtdcom2) \
+       list_for_each_entry_safe(rtdcom1, rtdcom2, &(rtd)->component_list, list)
+
 /* SoC Audio Codec device */
 struct snd_soc_codec {
        struct device *dev;
@@ -894,7 +906,6 @@ struct snd_soc_codec {
        struct list_head list;
 
        /* runtime */
-       unsigned int cache_bypass:1; /* Suppress access to the cache */
        unsigned int cache_init:1; /* codec cache has been initialized */
 
        /* codec IO */
@@ -904,10 +915,6 @@ struct snd_soc_codec {
 
        /* component */
        struct snd_soc_component component;
-
-#ifdef CONFIG_DEBUG_FS
-       struct dentry *debugfs_reg;
-#endif
 };
 
 /* codec driver */
@@ -1230,7 +1237,7 @@ struct snd_soc_pcm_runtime {
        struct snd_pcm *pcm;
        struct snd_compr *compr;
        struct snd_soc_codec *codec;
-       struct snd_soc_platform *platform;
+       struct snd_soc_platform *platform; /* will be removed */
        struct snd_soc_dai *codec_dai;
        struct snd_soc_dai *cpu_dai;
 
@@ -1244,6 +1251,7 @@ struct snd_soc_pcm_runtime {
 
        unsigned int num; /* 0-based and monotonic increasing */
        struct list_head list; /* rtd list of the soc card */
+       struct list_head component_list; /* list of connected components */
 
        /* bit field */
        unsigned int dev_registered:1;

diff --git a/sound/soc/codecs/max98927.c b/sound/soc/codecs/max98927.c
index b5ee29499e166d887f6e62e3b2dfcfc05ef3aa4c..b0380b560bf538ecfd686154ee3bc0ebc9457b10 100644 (file)
--- a/sound/soc/codecs/max98927.c
+++ b/sound/soc/codecs/max98927.c
@@ -577,7 +577,6 @@ static int max98927_probe(struct snd_soc_codec *codec)
 
        max98927->codec = codec;
        codec->control_data = max98927->regmap;
-       codec->cache_bypass = 1;
 
        /* Software Reset */
        regmap_write(max98927->regmap,

diff --git a/sound/soc/soc-core.c b/sound/soc/soc-core.c
index 921622a019448394687655034f52befb4abfd6ec..b1860b14b0757ac4327e0864b66c02b7250687b4 100644 (file)
--- a/sound/soc/soc-core.c
+++ b/sound/soc/soc-core.c
@@ -339,11 +339,12 @@ static void soc_cleanup_component_debugfs(struct snd_soc_component *component)
 static void soc_init_codec_debugfs(struct snd_soc_component *component)
 {
        struct snd_soc_codec *codec = snd_soc_component_to_codec(component);
+       struct dentry *debugfs_reg;
 
-       codec->debugfs_reg = debugfs_create_file("codec_reg", 0644,
-                                                codec->component.debugfs_root,
-                                                codec, &codec_reg_fops);
-       if (!codec->debugfs_reg)
+       debugfs_reg = debugfs_create_file("codec_reg", 0644,
+                                         codec->component.debugfs_root,
+                                         codec, &codec_reg_fops);
+       if (!debugfs_reg)
                dev_warn(codec->dev,
                        "ASoC: Failed to create codec register debugfs file\n");
 }
@@ -494,7 +495,7 @@ static void soc_cleanup_card_debugfs(struct snd_soc_card *card)
 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) {
+       if (IS_ERR_OR_NULL(snd_soc_debugfs_root)) {
                pr_warn("ASoC: Failed to create debugfs directory\n");
                snd_soc_debugfs_root = NULL;
                return;
@@ -550,6 +551,54 @@ static inline void snd_soc_debugfs_exit(void)
 
 #endif
 
+static int snd_soc_rtdcom_add(struct snd_soc_pcm_runtime *rtd,
+                             struct snd_soc_component *component)
+{
+       struct snd_soc_rtdcom_list *rtdcom;
+       struct snd_soc_rtdcom_list *new_rtdcom;
+
+       for_each_rtdcom(rtd, rtdcom) {
+               /* already connected */
+               if (rtdcom->component == component)
+                       return 0;
+       }
+
+       new_rtdcom = kmalloc(sizeof(*new_rtdcom), GFP_KERNEL);
+       if (!new_rtdcom)
+               return -ENOMEM;
+
+       new_rtdcom->component = component;
+       INIT_LIST_HEAD(&new_rtdcom->list);
+
+       list_add_tail(&new_rtdcom->list, &rtd->component_list);
+
+       return 0;
+}
+
+static void snd_soc_rtdcom_del_all(struct snd_soc_pcm_runtime *rtd)
+{
+       struct snd_soc_rtdcom_list *rtdcom1, *rtdcom2;
+
+       for_each_rtdcom_safe(rtd, rtdcom1, rtdcom2)
+               kfree(rtdcom1);
+
+       INIT_LIST_HEAD(&rtd->component_list);
+}
+
+struct snd_soc_component *snd_soc_rtdcom_lookup(struct snd_soc_pcm_runtime *rtd,
+                                               const char *driver_name)
+{
+       struct snd_soc_rtdcom_list *rtdcom;
+
+       for_each_rtdcom(rtd, rtdcom) {
+               if ((rtdcom->component->driver->name == driver_name) ||
+                   strcmp(rtdcom->component->driver->name, driver_name) == 0)
+                       return rtdcom->component;
+       }
+
+       return NULL;
+}
+
 struct snd_pcm_substream *snd_soc_get_dai_substream(struct snd_soc_card *card,
                const char *dai_link, int stream)
 {
@@ -574,6 +623,7 @@ static struct snd_soc_pcm_runtime *soc_new_pcm_runtime(
        if (!rtd)
                return NULL;
 
+       INIT_LIST_HEAD(&rtd->component_list);
        rtd->card = card;
        rtd->dai_link = dai_link;
        rtd->codec_dais = kzalloc(sizeof(struct snd_soc_dai *) *
@@ -591,6 +641,7 @@ static void soc_free_pcm_runtime(struct snd_soc_pcm_runtime *rtd)
 {
        if (rtd && rtd->codec_dais)
                kfree(rtd->codec_dais);
+       snd_soc_rtdcom_del_all(rtd);
        kfree(rtd);
 }
 
@@ -1049,6 +1100,7 @@ static int soc_bind_dai_link(struct snd_soc_card *card,
        struct snd_soc_pcm_runtime *rtd;
        struct snd_soc_dai_link_component *codecs = dai_link->codecs;
        struct snd_soc_dai_link_component cpu_dai_component;
+       struct snd_soc_component *component;
        struct snd_soc_dai **codec_dais;
        struct snd_soc_platform *platform;
        struct device_node *platform_of_node;
@@ -1076,6 +1128,7 @@ static int soc_bind_dai_link(struct snd_soc_card *card,
                        dai_link->cpu_dai_name);
                goto _err_defer;
        }
+       snd_soc_rtdcom_add(rtd, rtd->cpu_dai->component);
 
        rtd->num_codecs = dai_link->num_codecs;
 
@@ -1088,6 +1141,7 @@ static int soc_bind_dai_link(struct snd_soc_card *card,
                                codecs[i].dai_name);
                        goto _err_defer;
                }
+               snd_soc_rtdcom_add(rtd, codec_dais[i]->component);
        }
 
        /* Single codec links expect codec and codec_dai in runtime data */
@@ -1099,6 +1153,23 @@ static int soc_bind_dai_link(struct snd_soc_card *card,
        if (!platform_name && !dai_link->platform_of_node)
                platform_name = "snd-soc-dummy";
 
+       /* find one from the set of registered platforms */
+       list_for_each_entry(component, &component_list, list) {
+               platform_of_node = component->dev->of_node;
+               if (!platform_of_node && component->dev->parent->of_node)
+                       platform_of_node = component->dev->parent->of_node;
+
+               if (dai_link->platform_of_node) {
+                       if (platform_of_node != dai_link->platform_of_node)
+                               continue;
+               } else {
+                       if (strcmp(component->name, platform_name))
+                               continue;
+               }
+
+               snd_soc_rtdcom_add(rtd, component);
+       }
+
        /* find one from the set of registered platforms */
        list_for_each_entry(platform, &platform_list, list) {
                platform_of_node = platform->dev->of_node;
@@ -1184,27 +1255,15 @@ static void soc_remove_link_dais(struct snd_soc_card *card,
 static void soc_remove_link_components(struct snd_soc_card *card,
        struct snd_soc_pcm_runtime *rtd, int order)
 {
-       struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
-       struct snd_soc_platform *platform = rtd->platform;
        struct snd_soc_component *component;
-       int i;
+       struct snd_soc_rtdcom_list *rtdcom;
 
-       /* remove the platform */
-       if (platform && platform->component.driver->remove_order == order)
-               soc_remove_component(&platform->component);
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
 
-       /* remove the CODEC-side CODEC */
-       for (i = 0; i < rtd->num_codecs; i++) {
-               component = rtd->codec_dais[i]->component;
                if (component->driver->remove_order == order)
                        soc_remove_component(component);
        }
-
-       /* remove any CPU-side CODEC */
-       if (cpu_dai) {
-               if (cpu_dai->component->driver->remove_order == order)
-                       soc_remove_component(cpu_dai->component);
-       }
 }
 
 static void soc_remove_dai_links(struct snd_soc_card *card)
@@ -1556,21 +1615,13 @@ static int soc_probe_link_components(struct snd_soc_card *card,
                        struct snd_soc_pcm_runtime *rtd,
                                     int order)
 {
-       struct snd_soc_platform *platform = rtd->platform;
        struct snd_soc_component *component;
-       int i, ret;
+       struct snd_soc_rtdcom_list *rtdcom;
+       int ret;
 
-       /* probe the CPU-side component, if it is a CODEC */
-       component = rtd->cpu_dai->component;
-       if (component->driver->probe_order == order) {
-               ret = soc_probe_component(card, component);
-               if (ret < 0)
-                       return ret;
-       }
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
 
-       /* probe the CODEC-side components */
-       for (i = 0; i < rtd->num_codecs; i++) {
-               component = rtd->codec_dais[i]->component;
                if (component->driver->probe_order == order) {
                        ret = soc_probe_component(card, component);
                        if (ret < 0)
@@ -1578,13 +1629,6 @@ static int soc_probe_link_components(struct snd_soc_card *card,
                }
        }
 
-       /* probe the platform */
-       if (platform->component.driver->probe_order == order) {
-               ret = soc_probe_component(card, &platform->component);
-               if (ret < 0)
-                       return ret;
-       }
-
        return 0;
 }
 
@@ -3282,40 +3326,40 @@ static void snd_soc_component_del_unlocked(struct snd_soc_component *component)
 }
 
 int snd_soc_register_component(struct device *dev,
-                              const struct snd_soc_component_driver *cmpnt_drv,
+                              const struct snd_soc_component_driver *component_driver,
                               struct snd_soc_dai_driver *dai_drv,
                               int num_dai)
 {
-       struct snd_soc_component *cmpnt;
+       struct snd_soc_component *component;
        int ret;
 
-       cmpnt = kzalloc(sizeof(*cmpnt), GFP_KERNEL);
-       if (!cmpnt) {
+       component = kzalloc(sizeof(*component), GFP_KERNEL);
+       if (!component) {
                dev_err(dev, "ASoC: Failed to allocate memory\n");
                return -ENOMEM;
        }
 
-       ret = snd_soc_component_initialize(cmpnt, cmpnt_drv, dev);
+       ret = snd_soc_component_initialize(component, component_driver, dev);
        if (ret)
                goto err_free;
 
-       cmpnt->ignore_pmdown_time = true;
-       cmpnt->registered_as_component = true;
+       component->ignore_pmdown_time = true;
+       component->registered_as_component = true;
 
-       ret = snd_soc_register_dais(cmpnt, dai_drv, num_dai, true);
+       ret = snd_soc_register_dais(component, dai_drv, num_dai, true);
        if (ret < 0) {
                dev_err(dev, "ASoC: Failed to register DAIs: %d\n", ret);
                goto err_cleanup;
        }
 
-       snd_soc_component_add(cmpnt);
+       snd_soc_component_add(component);
 
        return 0;
 
 err_cleanup:
-       snd_soc_component_cleanup(cmpnt);
+       snd_soc_component_cleanup(component);
 err_free:
-       kfree(cmpnt);
+       kfree(component);
        return ret;
 }
 EXPORT_SYMBOL_GPL(snd_soc_register_component);
@@ -3327,22 +3371,26 @@ EXPORT_SYMBOL_GPL(snd_soc_register_component);
  */
 void snd_soc_unregister_component(struct device *dev)
 {
-       struct snd_soc_component *cmpnt;
+       struct snd_soc_component *component;
+       int found = 0;
 
        mutex_lock(&client_mutex);
-       list_for_each_entry(cmpnt, &component_list, list) {
-               if (dev == cmpnt->dev && cmpnt->registered_as_component)
-                       goto found;
+       list_for_each_entry(component, &component_list, list) {
+               if (dev != component->dev ||
+                   !component->registered_as_component)
+                       continue;
+
+               snd_soc_tplg_component_remove(component, SND_SOC_TPLG_INDEX_ALL);
+               snd_soc_component_del_unlocked(component);
+               found = 1;
+               break;
        }
        mutex_unlock(&client_mutex);
-       return;
 
-found:
-       snd_soc_tplg_component_remove(cmpnt, SND_SOC_TPLG_INDEX_ALL);
-       snd_soc_component_del_unlocked(cmpnt);
-       mutex_unlock(&client_mutex);
-       snd_soc_component_cleanup(cmpnt);
-       kfree(cmpnt);
+       if (found) {
+               snd_soc_component_cleanup(component);
+               kfree(component);
+       }
 }
 EXPORT_SYMBOL_GPL(snd_soc_unregister_component);
 

diff --git a/sound/soc/soc-pcm.c b/sound/soc/soc-pcm.c
index 2ddf6aae230ddbf13acddba0397690c49993239e..4b65aa91f64b4e177607605407df1992de0bb4f8 100644 (file)
--- a/sound/soc/soc-pcm.c
+++ b/sound/soc/soc-pcm.c
@@ -450,6 +450,8 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
        struct snd_pcm_runtime *runtime = substream->runtime;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
        struct snd_soc_dai *codec_dai;
        const char *codec_dai_name = "multicodec";
@@ -458,10 +460,12 @@ static int soc_pcm_open(struct snd_pcm_substream *substream)
        pinctrl_pm_select_default_state(cpu_dai->dev);
        for (i = 0; i < rtd->num_codecs; i++)
                pinctrl_pm_select_default_state(rtd->codec_dais[i]->dev);
-       pm_runtime_get_sync(cpu_dai->dev);
-       for (i = 0; i < rtd->num_codecs; i++)
-               pm_runtime_get_sync(rtd->codec_dais[i]->dev);
-       pm_runtime_get_sync(platform->dev);
+
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               pm_runtime_get_sync(component->dev);
+       }
 
        mutex_lock_nested(&rtd->pcm_mutex, rtd->pcm_subclass);
 
@@ -599,15 +603,13 @@ platform_err:
 out:
        mutex_unlock(&rtd->pcm_mutex);
 
-       pm_runtime_mark_last_busy(platform->dev);
-       pm_runtime_put_autosuspend(platform->dev);
-       for (i = 0; i < rtd->num_codecs; i++) {
-               pm_runtime_mark_last_busy(rtd->codec_dais[i]->dev);
-               pm_runtime_put_autosuspend(rtd->codec_dais[i]->dev);
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
+
+               pm_runtime_mark_last_busy(component->dev);
+               pm_runtime_put_autosuspend(component->dev);
        }
 
-       pm_runtime_mark_last_busy(cpu_dai->dev);
-       pm_runtime_put_autosuspend(cpu_dai->dev);
        for (i = 0; i < rtd->num_codecs; i++) {
                if (!rtd->codec_dais[i]->active)
                        pinctrl_pm_select_sleep_state(rtd->codec_dais[i]->dev);
@@ -655,6 +657,8 @@ static int soc_pcm_close(struct snd_pcm_substream *substream)
 {
        struct snd_soc_pcm_runtime *rtd = substream->private_data;
        struct snd_soc_platform *platform = rtd->platform;
+       struct snd_soc_component *component;
+       struct snd_soc_rtdcom_list *rtdcom;
        struct snd_soc_dai *cpu_dai = rtd->cpu_dai;
        struct snd_soc_dai *codec_dai;
        int i;
@@ -711,17 +715,13 @@ static int soc_pcm_close(struct snd_pcm_substream *substream)
 
        mutex_unlock(&rtd->pcm_mutex);
 
-       pm_runtime_mark_last_busy(platform->dev);
-       pm_runtime_put_autosuspend(platform->dev);
+       for_each_rtdcom(rtd, rtdcom) {
+               component = rtdcom->component;
 
-       for (i = 0; i < rtd->num_codecs; i++) {
-               pm_runtime_mark_last_busy(rtd->codec_dais[i]->dev);
-               pm_runtime_put_autosuspend(rtd->codec_dais[i]->dev);
+               pm_runtime_mark_last_busy(component->dev);
+               pm_runtime_put_autosuspend(component->dev);
        }
 
-       pm_runtime_mark_last_busy(cpu_dai->dev);
-       pm_runtime_put_autosuspend(cpu_dai->dev);
-
        for (i = 0; i < rtd->num_codecs; i++) {
                if (!rtd->codec_dais[i]->active)
                        pinctrl_pm_select_sleep_state(rtd->codec_dais[i]->dev);