}
 
 static struct snd_soc_component *soc_find_component(
-       struct device_node *of_node, const char *name)
+       const struct snd_soc_dai_link_component *dlc)
 {
        struct snd_soc_component *component;
-       struct snd_soc_dai_link_component dlc;
 
        lockdep_assert_held(&client_mutex);
 
-       for_each_component(component) {
-               dlc.name = name;
-               dlc.of_node = of_node;
-               if (snd_soc_is_matching_component(&dlc, component))
+       for_each_component(component)
+               if (snd_soc_is_matching_component(dlc, component))
                        return component;
-       }
 
        return NULL;
 }
                 * added to component list.
                 */
                if ((link->platforms->of_node || link->platforms->name) &&
-                   !soc_find_component(link->platforms->of_node,
-                                       link->platforms->name))
+                   !soc_find_component(link->platforms))
                        return -EPROBE_DEFER;
        }
 
         * component list.
         */
        if ((link->cpus->of_node || link->cpus->name) &&
-           !soc_find_component(link->cpus->of_node, link->cpus->name))
+           !soc_find_component(link->cpus))
                return -EPROBE_DEFER;
 
        /*
 {
        struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
        struct snd_soc_component *component;
-       const char *name;
-       struct device_node *codec_of_node;
+       struct snd_soc_dai_link_component dlc;
 
        if (aux_dev->codec_of_node || aux_dev->codec_name) {
                /* codecs, usually analog devices */
-               name = aux_dev->codec_name;
-               codec_of_node = aux_dev->codec_of_node;
-               component = soc_find_component(codec_of_node, name);
+               dlc.name = aux_dev->codec_name;
+               dlc.of_node = aux_dev->codec_of_node;
+               component = soc_find_component(&dlc);
                if (!component) {
-                       if (codec_of_node)
-                               name = of_node_full_name(codec_of_node);
+                       if (dlc.of_node)
+                               dlc.name = of_node_full_name(dlc.of_node);
                        goto err_defer;
                }
        } else if (aux_dev->name) {
                /* generic components */
-               name = aux_dev->name;
-               component = soc_find_component(NULL, name);
+               dlc.name = aux_dev->name;
+               dlc.of_node = NULL;
+               component = soc_find_component(&dlc);
                if (!component)
                        goto err_defer;
        } else {
        return 0;
 
 err_defer:
-       dev_err(card->dev, "ASoC: %s not registered\n", name);
+       dev_err(card->dev, "ASoC: %s not registered\n", dlc.name);
        return -EPROBE_DEFER;
 }
 
 int snd_soc_get_dai_id(struct device_node *ep)
 {
        struct snd_soc_component *component;
-       struct device_node *node;
+       struct snd_soc_dai_link_component dlc;
        int ret;
 
-       node = of_graph_get_port_parent(ep);
-
+       dlc.of_node     = of_graph_get_port_parent(ep);
+       dlc.name        = NULL;
        /*
         * For example HDMI case, HDMI has video/sound port,
         * but ALSA SoC needs sound port number only.
         */
        ret = -ENOTSUPP;
        mutex_lock(&client_mutex);
-       component = soc_find_component(node, NULL);
+       component = soc_find_component(&dlc);
        if (component &&
            component->driver->of_xlate_dai_id)
                ret = component->driver->of_xlate_dai_id(component, ep);
        mutex_unlock(&client_mutex);
 
-       of_node_put(node);
+       of_node_put(dlc.of_node);
 
        return ret;
 }