dprintk("%s: allmulti mode\n", dev->name);
                priv->rx_mode = RX_MODE_ALL_MULTI;
        } else if (!netdev_mc_empty(dev)) {
-               int mci;
                struct dev_mc_list *mc;
 
                dprintk("%s: set_mc_list, %d entries\n",
                priv->rx_mode = RX_MODE_MULTI;
                priv->multi_num = 0;
 
-               for (mci = 0, mc=dev->mc_list;
-                    mci < netdev_mc_count(dev);
-                    mc = mc->next, mci++) {
+               netdev_for_each_mc_addr(mc, dev)
                        dvb_set_mc_filter(dev, mc);
-               }
        }
 
        netif_addr_unlock_bh(dev);
 
 static void mlx4_en_clear_list(struct net_device *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
-       struct dev_mc_list *plist = priv->mc_list;
-       struct dev_mc_list *next;
 
-       while (plist) {
-               next = plist->next;
-               kfree(plist);
-               plist = next;
-       }
-       priv->mc_list = NULL;
+       kfree(priv->mc_addrs);
+       priv->mc_addrs_cnt = 0;
 }
 
 static void mlx4_en_cache_mclist(struct net_device *dev)
 {
        struct mlx4_en_priv *priv = netdev_priv(dev);
        struct dev_mc_list *mclist;
-       struct dev_mc_list *tmp;
-       struct dev_mc_list *plist = NULL;
-
-       for (mclist = dev->mc_list; mclist; mclist = mclist->next) {
-               tmp = kmalloc(sizeof(struct dev_mc_list), GFP_ATOMIC);
-               if (!tmp) {
-                       en_err(priv, "failed to allocate multicast list\n");
-                       mlx4_en_clear_list(dev);
-                       return;
-               }
-               memcpy(tmp, mclist, sizeof(struct dev_mc_list));
-               tmp->next = NULL;
-               if (plist)
-                       plist->next = tmp;
-               else
-                       priv->mc_list = tmp;
-               plist = tmp;
+       char *mc_addrs;
+       int mc_addrs_cnt = netdev_mc_count(dev);
+       int i;
+
+       mc_addrs = kmalloc(mc_addrs_cnt * ETH_ALEN, GFP_ATOMIC);
+       if (!mc_addrs) {
+               en_err(priv, "failed to allocate multicast list\n");
+               return;
        }
+       i = 0;
+       netdev_for_each_mc_addr(mclist, dev)
+               memcpy(mc_addrs + i++ * ETH_ALEN, mclist->dmi_addr, ETH_ALEN);
+       priv->mc_addrs = mc_addrs;
+       priv->mc_addrs_cnt = mc_addrs_cnt;
 }
 
 
                                                 mcast_task);
        struct mlx4_en_dev *mdev = priv->mdev;
        struct net_device *dev = priv->dev;
-       struct dev_mc_list *mclist;
        u64 mcast_addr = 0;
        int err;
 
                if (err)
                        en_err(priv, "Failed disabling multicast filter\n");
        } else {
+               int i;
+
                err = mlx4_SET_MCAST_FLTR(mdev->dev, priv->port, 0,
                                          0, MLX4_MCAST_DISABLE);
                if (err)
                netif_tx_lock_bh(dev);
                mlx4_en_cache_mclist(dev);
                netif_tx_unlock_bh(dev);
-               for (mclist = priv->mc_list; mclist; mclist = mclist->next) {
-                       mcast_addr = mlx4_en_mac_to_u64(mclist->dmi_addr);
+               for (i = 0; i < priv->mc_addrs_cnt; i++) {
+                       mcast_addr =
+                             mlx4_en_mac_to_u64(priv->mc_addrs + i * ETH_ALEN);
                        mlx4_SET_MCAST_FLTR(mdev->dev, priv->port,
                                            mcast_addr, 0, MLX4_MCAST_CONFIG);
                }
        priv->flags = prof->flags;
        priv->tx_ring_num = prof->tx_ring_num;
        priv->rx_ring_num = prof->rx_ring_num;
-       priv->mc_list = NULL;
        priv->mac_index = -1;
        priv->msg_enable = MLX4_EN_MSG_LEVEL;
        spin_lock_init(&priv->stats_lock);
 
                memcpy(__skb_put(skb, ETH_ALEN), dev->broadcast, ETH_ALEN);
                r->len = htons(ETH_ALEN * 2);
        } else {
-               struct dev_mc_list *dmi = dev->mc_list;
+               struct dev_mc_list *dmi;
                int i, len = skb->len;
 
                if (dev->flags & IFF_BROADCAST) {
 
                /* FIXME: We should group addresses here. */
 
-               for (i = 0;
-                    i < netdev_mc_count(dev) && i < BNEP_MAX_MULTICAST_FILTERS;
-                    i++) {
+               i = 0;
+               netdev_for_each_mc_addr(dmi, dev) {
+                       if (i == BNEP_MAX_MULTICAST_FILTERS)
+                               break;
                        memcpy(__skb_put(skb, ETH_ALEN), dmi->dmi_addr, ETH_ALEN);
                        memcpy(__skb_put(skb, ETH_ALEN), dmi->dmi_addr, ETH_ALEN);
-                       dmi = dmi->next;
                }
                r->len = htons(skb->len - len);
        }