for ((i) = 0;                                                   \
             ((i) < (card)->num_links) && ((link) = &(card)->dai_link[i]); \
             (i)++)
+#define for_each_card_pre_auxs(card, i, aux)                           \
+       for ((i) = 0;                                                   \
+            ((i) < (card)->num_aux_devs) && ((aux) = &(card)->aux_dev[i]); \
+            (i)++)
 
 #define for_each_card_links(card, link)                                \
        list_for_each_entry(link, &(card)->dai_link_list, list)
 #define for_each_card_rtds_safe(card, rtd, _rtd)       \
        list_for_each_entry_safe(rtd, _rtd, &(card)->rtd_list, list)
 
+#define for_each_card_auxs(card, component)                    \
+       list_for_each_entry(component, &card->aux_comp_list, card_aux_list)
+#define for_each_card_auxs_safe(card, component, _comp)        \
+       list_for_each_entry_safe(component, _comp,      \
+                                &card->aux_comp_list, card_aux_list)
+
 #define for_each_card_components(card, component)                      \
        list_for_each_entry(component, &(card)->component_dev_list, card_list)
 
 
        struct snd_soc_card *card = &priv->card;
        struct snd_soc_dai_link *link;
        struct snd_soc_dai_link_component *codec;
+       struct snd_soc_aux_dev *aux;
        int i, j;
 
        if (card->dai_link) {
        }
 
        if (card->aux_dev) {
-               for (i = 0; i < card->num_aux_devs; i++)
-                       of_node_put(card->aux_dev[i].dlc.of_node);
+               for_each_card_pre_auxs(card, i, aux)
+                       of_node_put(aux->dlc.of_node);
        }
 
        kfree(card->dai_link);
        card->aux_dev = aux;
        card->num_aux_devs = num;
 
-       for (i = 0; i < card->num_aux_devs; i++, aux++) {
+       for_each_card_pre_auxs(card, i, aux) {
                aux->dlc.of_node =
                        of_parse_phandle(node, "audio-aux-devs", i);
                if (!aux->dlc.of_node)
 
        return ret;
 }
 
-static int soc_bind_aux_dev(struct snd_soc_card *card, int num)
+static int soc_bind_aux_dev(struct snd_soc_card *card,
+                           struct snd_soc_aux_dev *aux_dev)
 {
-       struct snd_soc_aux_dev *aux_dev = &card->aux_dev[num];
        struct snd_soc_component *component;
 
        /* codecs, usually analog devices */
                return -EPROBE_DEFER;
 
        component->init = aux_dev->init;
+       /* see for_each_card_auxs */
        list_add(&component->card_aux_list, &card->aux_comp_list);
 
        return 0;
        int ret;
 
        for_each_comp_order(order) {
-               list_for_each_entry(comp, &card->aux_comp_list, card_aux_list) {
+               for_each_card_auxs(card, comp) {
                        if (comp->driver->probe_order == order) {
                                ret = soc_probe_component(card, comp);
                                if (ret < 0) {
        int order;
 
        for_each_comp_order(order) {
-               list_for_each_entry_safe(comp, _comp,
-                       &card->aux_comp_list, card_aux_list) {
+               for_each_card_auxs_safe(card, comp, _comp) {
 
                        if (comp->driver->remove_order == order) {
                                soc_remove_component(comp);
 {
        struct snd_soc_pcm_runtime *rtd;
        struct snd_soc_dai_link *dai_link;
+       struct snd_soc_aux_dev *aux;
        int ret, i, order;
 
        mutex_lock(&client_mutex);
        }
 
        /* bind aux_devs too */
-       for (i = 0; i < card->num_aux_devs; i++) {
-               ret = soc_bind_aux_dev(card, i);
+       for_each_card_pre_auxs(card, i, aux) {
+               ret = soc_bind_aux_dev(card, aux);
                if (ret != 0)
                        goto probe_end;
        }