bcmdhd: use the wiphy from private data structure (i.e., wl_priv)
[linux-2.6.git] / drivers / net / ixgb / ixgb_main.c
index 93d0185..6a130eb 100644 (file)
@@ -26,6 +26,9 @@
 
 *******************************************************************************/
 
+#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
+
+#include <linux/prefetch.h>
 #include "ixgb.h"
 
 char ixgb_driver_name[] = "ixgb";
@@ -96,8 +99,8 @@ static void ixgb_alloc_rx_buffers(struct ixgb_adapter *, int);
 static void ixgb_tx_timeout(struct net_device *dev);
 static void ixgb_tx_timeout_task(struct work_struct *work);
 
-static void ixgb_vlan_rx_register(struct net_device *netdev,
-                                  struct vlan_group *grp);
+static void ixgb_vlan_strip_enable(struct ixgb_adapter *adapter);
+static void ixgb_vlan_strip_disable(struct ixgb_adapter *adapter);
 static void ixgb_vlan_rx_add_vid(struct net_device *netdev, u16 vid);
 static void ixgb_vlan_rx_kill_vid(struct net_device *netdev, u16 vid);
 static void ixgb_restore_vlan(struct ixgb_adapter *adapter);
@@ -146,10 +149,8 @@ MODULE_PARM_DESC(debug, "Debug level (0=none,...,16=all)");
 static int __init
 ixgb_init_module(void)
 {
-       printk(KERN_INFO "%s - version %s\n",
-              ixgb_driver_string, ixgb_driver_version);
-
-       printk(KERN_INFO "%s\n", ixgb_copyright);
+       pr_info("%s - version %s\n", ixgb_driver_string, ixgb_driver_version);
+       pr_info("%s\n", ixgb_copyright);
 
        return pci_register_driver(&ixgb_driver);
 }
@@ -334,7 +335,6 @@ static const struct net_device_ops ixgb_netdev_ops = {
        .ndo_set_mac_address    = ixgb_set_mac,
        .ndo_change_mtu         = ixgb_change_mtu,
        .ndo_tx_timeout         = ixgb_tx_timeout,
-       .ndo_vlan_rx_register   = ixgb_vlan_rx_register,
        .ndo_vlan_rx_add_vid    = ixgb_vlan_rx_add_vid,
        .ndo_vlan_rx_kill_vid   = ixgb_vlan_rx_kill_vid,
 #ifdef CONFIG_NET_POLL_CONTROLLER
@@ -368,17 +368,22 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        if (err)
                return err;
 
-       if (!(err = pci_set_dma_mask(pdev, DMA_BIT_MASK(64))) &&
-           !(err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64)))) {
-               pci_using_dac = 1;
+       pci_using_dac = 0;
+       err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(64));
+       if (!err) {
+               err = dma_set_coherent_mask(&pdev->dev, DMA_BIT_MASK(64));
+               if (!err)
+                       pci_using_dac = 1;
        } else {
-               if ((err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32))) ||
-                   (err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32)))) {
-                       printk(KERN_ERR
-                        "ixgb: No usable DMA configuration, aborting\n");
-                       goto err_dma_mask;
+               err = dma_set_mask(&pdev->dev, DMA_BIT_MASK(32));
+               if (err) {
+                       err = dma_set_coherent_mask(&pdev->dev,
+                                                   DMA_BIT_MASK(32));
+                       if (err) {
+                               pr_err("No usable DMA configuration, aborting\n");
+                               goto err_dma_mask;
+                       }
                }
-               pci_using_dac = 0;
        }
 
        err = pci_request_regions(pdev, ixgb_driver_name);
@@ -441,8 +446,10 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
                           NETIF_F_HW_VLAN_FILTER;
        netdev->features |= NETIF_F_TSO;
 
-       if (pci_using_dac)
+       if (pci_using_dac) {
                netdev->features |= NETIF_F_HIGHDMA;
+               netdev->vlan_features |= NETIF_F_HIGHDMA;
+       }
 
        /* make sure the EEPROM is good */
 
@@ -465,7 +472,7 @@ ixgb_probe(struct pci_dev *pdev, const struct pci_device_id *ent)
        adapter->part_num = ixgb_get_ee_pba_number(&adapter->hw);
 
        init_timer(&adapter->watchdog_timer);
-       adapter->watchdog_timer.function = &ixgb_watchdog;
+       adapter->watchdog_timer.function = ixgb_watchdog;
        adapter->watchdog_timer.data = (unsigned long)adapter;
 
        INIT_WORK(&adapter->tx_timeout_task, ixgb_tx_timeout_task);
@@ -518,7 +525,7 @@ ixgb_remove(struct pci_dev *pdev)
        struct net_device *netdev = pci_get_drvdata(pdev);
        struct ixgb_adapter *adapter = netdev_priv(netdev);
 
-       flush_scheduled_work();
+       cancel_work_sync(&adapter->tx_timeout_task);
 
        unregister_netdev(netdev);
 
@@ -526,6 +533,7 @@ ixgb_remove(struct pci_dev *pdev)
        pci_release_regions(pdev);
 
        free_netdev(netdev);
+       pci_disable_device(pdev);
 }
 
 /**
@@ -661,20 +669,20 @@ ixgb_setup_tx_resources(struct ixgb_adapter *adapter)
        int size;
 
        size = sizeof(struct ixgb_buffer) * txdr->count;
-       txdr->buffer_info = vmalloc(size);
+       txdr->buffer_info = vzalloc(size);
        if (!txdr->buffer_info) {
                netif_err(adapter, probe, adapter->netdev,
                          "Unable to allocate transmit descriptor ring memory\n");
                return -ENOMEM;
        }
-       memset(txdr->buffer_info, 0, size);
 
        /* round up to nearest 4K */
 
        txdr->size = txdr->count * sizeof(struct ixgb_tx_desc);
        txdr->size = ALIGN(txdr->size, 4096);
 
-       txdr->desc = pci_alloc_consistent(pdev, txdr->size, &txdr->dma);
+       txdr->desc = dma_alloc_coherent(&pdev->dev, txdr->size, &txdr->dma,
+                                       GFP_KERNEL);
        if (!txdr->desc) {
                vfree(txdr->buffer_info);
                netif_err(adapter, probe, adapter->netdev,
@@ -750,20 +758,20 @@ ixgb_setup_rx_resources(struct ixgb_adapter *adapter)
        int size;
 
        size = sizeof(struct ixgb_buffer) * rxdr->count;
-       rxdr->buffer_info = vmalloc(size);
+       rxdr->buffer_info = vzalloc(size);
        if (!rxdr->buffer_info) {
                netif_err(adapter, probe, adapter->netdev,
                          "Unable to allocate receive descriptor ring\n");
                return -ENOMEM;
        }
-       memset(rxdr->buffer_info, 0, size);
 
        /* Round up to nearest 4K */
 
        rxdr->size = rxdr->count * sizeof(struct ixgb_rx_desc);
        rxdr->size = ALIGN(rxdr->size, 4096);
 
-       rxdr->desc = pci_alloc_consistent(pdev, rxdr->size, &rxdr->dma);
+       rxdr->desc = dma_alloc_coherent(&pdev->dev, rxdr->size, &rxdr->dma,
+                                       GFP_KERNEL);
 
        if (!rxdr->desc) {
                vfree(rxdr->buffer_info);
@@ -884,8 +892,8 @@ ixgb_free_tx_resources(struct ixgb_adapter *adapter)
        vfree(adapter->tx_ring.buffer_info);
        adapter->tx_ring.buffer_info = NULL;
 
-       pci_free_consistent(pdev, adapter->tx_ring.size,
-                           adapter->tx_ring.desc, adapter->tx_ring.dma);
+       dma_free_coherent(&pdev->dev, adapter->tx_ring.size,
+                         adapter->tx_ring.desc, adapter->tx_ring.dma);
 
        adapter->tx_ring.desc = NULL;
 }
@@ -896,12 +904,11 @@ ixgb_unmap_and_free_tx_resource(struct ixgb_adapter *adapter,
 {
        if (buffer_info->dma) {
                if (buffer_info->mapped_as_page)
-                       pci_unmap_page(adapter->pdev, buffer_info->dma,
-                                      buffer_info->length, PCI_DMA_TODEVICE);
+                       dma_unmap_page(&adapter->pdev->dev, buffer_info->dma,
+                                      buffer_info->length, DMA_TO_DEVICE);
                else
-                       pci_unmap_single(adapter->pdev, buffer_info->dma,
-                                        buffer_info->length,
-                                        PCI_DMA_TODEVICE);
+                       dma_unmap_single(&adapter->pdev->dev, buffer_info->dma,
+                                        buffer_info->length, DMA_TO_DEVICE);
                buffer_info->dma = 0;
        }
 
@@ -967,7 +974,8 @@ ixgb_free_rx_resources(struct ixgb_adapter *adapter)
        vfree(rx_ring->buffer_info);
        rx_ring->buffer_info = NULL;
 
-       pci_free_consistent(pdev, rx_ring->size, rx_ring->desc, rx_ring->dma);
+       dma_free_coherent(&pdev->dev, rx_ring->size, rx_ring->desc,
+                         rx_ring->dma);
 
        rx_ring->desc = NULL;
 }
@@ -991,10 +999,10 @@ ixgb_clean_rx_ring(struct ixgb_adapter *adapter)
        for (i = 0; i < rx_ring->count; i++) {
                buffer_info = &rx_ring->buffer_info[i];
                if (buffer_info->dma) {
-                       pci_unmap_single(pdev,
+                       dma_unmap_single(&pdev->dev,
                                         buffer_info->dma,
                                         buffer_info->length,
-                                        PCI_DMA_FROMDEVICE);
+                                        DMA_FROM_DEVICE);
                        buffer_info->dma = 0;
                        buffer_info->length = 0;
                }
@@ -1058,7 +1066,7 @@ ixgb_set_multi(struct net_device *netdev)
 {
        struct ixgb_adapter *adapter = netdev_priv(netdev);
        struct ixgb_hw *hw = &adapter->hw;
-       struct dev_mc_list *mc_ptr;
+       struct netdev_hw_addr *ha;
        u32 rctl;
        int i;
 
@@ -1068,6 +1076,8 @@ ixgb_set_multi(struct net_device *netdev)
 
        if (netdev->flags & IFF_PROMISC) {
                rctl |= (IXGB_RCTL_UPE | IXGB_RCTL_MPE);
+               /* disable VLAN filtering */
+               rctl &= ~IXGB_RCTL_CFIEN;
                rctl &= ~IXGB_RCTL_VFE;
        } else {
                if (netdev->flags & IFF_ALLMULTI) {
@@ -1076,7 +1086,9 @@ ixgb_set_multi(struct net_device *netdev)
                } else {
                        rctl &= ~(IXGB_RCTL_UPE | IXGB_RCTL_MPE);
                }
+               /* enable VLAN filtering */
                rctl |= IXGB_RCTL_VFE;
+               rctl &= ~IXGB_RCTL_CFIEN;
        }
 
        if (netdev_mc_count(netdev) > IXGB_MAX_NUM_MULTICAST_ADDRESSES) {
@@ -1088,14 +1100,19 @@ ixgb_set_multi(struct net_device *netdev)
 
                IXGB_WRITE_REG(hw, RCTL, rctl);
 
-               for (i = 0, mc_ptr = netdev->mc_list;
-                    mc_ptr;
-                    i++, mc_ptr = mc_ptr->next)
-                       memcpy(&mta[i * IXGB_ETH_LENGTH_OF_ADDRESS],
-                              mc_ptr->dmi_addr, IXGB_ETH_LENGTH_OF_ADDRESS);
+               i = 0;
+               netdev_for_each_mc_addr(ha, netdev)
+                       memcpy(&mta[i++ * IXGB_ETH_LENGTH_OF_ADDRESS],
+                              ha->addr, IXGB_ETH_LENGTH_OF_ADDRESS);
 
                ixgb_mc_addr_list_update(hw, mta, netdev_mc_count(netdev), 0);
        }
+
+       if (netdev->features & NETIF_F_HW_VLAN_RX)
+               ixgb_vlan_strip_enable(adapter);
+       else
+               ixgb_vlan_strip_disable(adapter);
+
 }
 
 /**
@@ -1119,15 +1136,14 @@ ixgb_watchdog(unsigned long data)
 
        if (adapter->hw.link_up) {
                if (!netif_carrier_ok(netdev)) {
-                       printk(KERN_INFO "ixgb: %s NIC Link is Up 10 Gbps "
-                              "Full Duplex, Flow Control: %s\n",
-                              netdev->name,
-                              (adapter->hw.fc.type == ixgb_fc_full) ?
-                               "RX/TX" :
-                               ((adapter->hw.fc.type == ixgb_fc_rx_pause) ?
-                                "RX" :
-                                ((adapter->hw.fc.type == ixgb_fc_tx_pause) ?
-                                 "TX" : "None")));
+                       netdev_info(netdev,
+                                   "NIC Link is Up 10 Gbps Full Duplex, Flow Control: %s\n",
+                                   (adapter->hw.fc.type == ixgb_fc_full) ?
+                                   "RX/TX" :
+                                   (adapter->hw.fc.type == ixgb_fc_rx_pause) ?
+                                    "RX" :
+                                   (adapter->hw.fc.type == ixgb_fc_tx_pause) ?
+                                   "TX" : "None");
                        adapter->link_speed = 10000;
                        adapter->link_duplex = FULL_DUPLEX;
                        netif_carrier_on(netdev);
@@ -1136,8 +1152,7 @@ ixgb_watchdog(unsigned long data)
                if (netif_carrier_ok(netdev)) {
                        adapter->link_speed = 0;
                        adapter->link_duplex = 0;
-                       printk(KERN_INFO "ixgb: %s NIC Link is Down\n",
-                              netdev->name);
+                       netdev_info(netdev, "NIC Link is Down\n");
                        netif_carrier_off(netdev);
                }
        }
@@ -1245,7 +1260,7 @@ ixgb_tx_csum(struct ixgb_adapter *adapter, struct sk_buff *skb)
 
        if (likely(skb->ip_summed == CHECKSUM_PARTIAL)) {
                struct ixgb_buffer *buffer_info;
-               css = skb_transport_offset(skb);
+               css = skb_checksum_start_offset(skb);
                cso = css + skb->csum_offset;
 
                i = adapter->tx_ring.next_to_use;
@@ -1304,9 +1319,10 @@ ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb,
                WARN_ON(buffer_info->dma != 0);
                buffer_info->time_stamp = jiffies;
                buffer_info->mapped_as_page = false;
-               buffer_info->dma = pci_map_single(pdev, skb->data + offset,
-                                                 size, PCI_DMA_TODEVICE);
-               if (pci_dma_mapping_error(pdev, buffer_info->dma))
+               buffer_info->dma = dma_map_single(&pdev->dev,
+                                                 skb->data + offset,
+                                                 size, DMA_TO_DEVICE);
+               if (dma_mapping_error(&pdev->dev, buffer_info->dma))
                        goto dma_error;
                buffer_info->next_to_watch = 0;
 
@@ -1345,10 +1361,9 @@ ixgb_tx_map(struct ixgb_adapter *adapter, struct sk_buff *skb,
                        buffer_info->time_stamp = jiffies;
                        buffer_info->mapped_as_page = true;
                        buffer_info->dma =
-                               pci_map_page(pdev, frag->page,
-                                            offset, size,
-                                            PCI_DMA_TODEVICE);
-                       if (pci_dma_mapping_error(pdev, buffer_info->dma))
+                               dma_map_page(&pdev->dev, frag->page,
+                                            offset, size, DMA_TO_DEVICE);
+                       if (dma_mapping_error(&pdev->dev, buffer_info->dma))
                                goto dma_error;
                        buffer_info->next_to_watch = 0;
 
@@ -1491,7 +1506,7 @@ ixgb_xmit_frame(struct sk_buff *skb, struct net_device *netdev)
                      DESC_NEEDED)))
                return NETDEV_TX_BUSY;
 
-       if (adapter->vlgrp && vlan_tx_tag_present(skb)) {
+       if (vlan_tx_tag_present(skb)) {
                tx_flags |= IXGB_TX_FLAGS_VLAN;
                vlan_id = vlan_tx_tag_get(skb);
        }
@@ -1812,6 +1827,7 @@ ixgb_clean_tx_irq(struct ixgb_adapter *adapter)
 
        while (eop_desc->status & IXGB_TX_DESC_STATUS_DD) {
 
+               rmb(); /* read buffer_info after eop_desc */
                for (cleaned = false; !cleaned; ) {
                        tx_desc = IXGB_TX_DESC(*tx_ring, i);
                        buffer_info = &tx_ring->buffer_info[i];
@@ -1900,7 +1916,7 @@ ixgb_rx_checksum(struct ixgb_adapter *adapter,
         */
        if ((rx_desc->status & IXGB_RX_DESC_STATUS_IXSM) ||
           (!(rx_desc->status & IXGB_RX_DESC_STATUS_TCPCS))) {
-               skb->ip_summed = CHECKSUM_NONE;
+               skb_checksum_none_assert(skb);
                return;
        }
 
@@ -1908,7 +1924,7 @@ ixgb_rx_checksum(struct ixgb_adapter *adapter,
        /* now look at the TCP checksum error bit */
        if (rx_desc->errors & IXGB_RX_DESC_ERRORS_TCPE) {
                /* let the stack verify checksum errors */
-               skb->ip_summed = CHECKSUM_NONE;
+               skb_checksum_none_assert(skb);
                adapter->hw_csum_rx_error++;
        } else {
                /* TCP checksum is good */
@@ -1917,6 +1933,31 @@ ixgb_rx_checksum(struct ixgb_adapter *adapter,
        }
 }
 
+/*
+ * this should improve performance for small packets with large amounts
+ * of reassembly being done in the stack
+ */
+static void ixgb_check_copybreak(struct net_device *netdev,
+                                struct ixgb_buffer *buffer_info,
+                                u32 length, struct sk_buff **skb)
+{
+       struct sk_buff *new_skb;
+
+       if (length > copybreak)
+               return;
+
+       new_skb = netdev_alloc_skb_ip_align(netdev, length);
+       if (!new_skb)
+               return;
+
+       skb_copy_to_linear_data_offset(new_skb, -NET_IP_ALIGN,
+                                      (*skb)->data - NET_IP_ALIGN,
+                                      length + NET_IP_ALIGN);
+       /* save the skb in buffer_info as good */
+       buffer_info->skb = *skb;
+       *skb = new_skb;
+}
+
 /**
  * ixgb_clean_rx_irq - Send received data up the network stack,
  * @adapter: board private structure
@@ -1947,17 +1988,21 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter, int *work_done, int work_to_do)
                        break;
 
                (*work_done)++;
+               rmb();  /* read descriptor and rx_buffer_info after status DD */
                status = rx_desc->status;
                skb = buffer_info->skb;
                buffer_info->skb = NULL;
 
                prefetch(skb->data - NET_IP_ALIGN);
 
-               if (++i == rx_ring->count) i = 0;
+               if (++i == rx_ring->count)
+                       i = 0;
                next_rxd = IXGB_RX_DESC(*rx_ring, i);
                prefetch(next_rxd);
 
-               if ((j = i + 1) == rx_ring->count) j = 0;
+               j = i + 1;
+               if (j == rx_ring->count)
+                       j = 0;
                next2_buffer = &rx_ring->buffer_info[j];
                prefetch(next2_buffer);
 
@@ -1966,10 +2011,10 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter, int *work_done, int work_to_do)
                cleaned = true;
                cleaned_count++;
 
-               pci_unmap_single(pdev,
+               dma_unmap_single(&pdev->dev,
                                 buffer_info->dma,
                                 buffer_info->length,
-                                PCI_DMA_FROMDEVICE);
+                                DMA_FROM_DEVICE);
                buffer_info->dma = 0;
 
                length = le16_to_cpu(rx_desc->length);
@@ -1993,25 +2038,7 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter, int *work_done, int work_to_do)
                        goto rxdesc_done;
                }
 
-               /* code added for copybreak, this should improve
-                * performance for small packets with large amounts
-                * of reassembly being done in the stack */
-               if (length < copybreak) {
-                       struct sk_buff *new_skb =
-                           netdev_alloc_skb_ip_align(netdev, length);
-                       if (new_skb) {
-                               skb_copy_to_linear_data_offset(new_skb,
-                                                              -NET_IP_ALIGN,
-                                                              (skb->data -
-                                                               NET_IP_ALIGN),
-                                                              (length +
-                                                               NET_IP_ALIGN));
-                               /* save the skb in buffer_info as good */
-                               buffer_info->skb = skb;
-                               skb = new_skb;
-                       }
-               }
-               /* end copybreak code */
+               ixgb_check_copybreak(netdev, buffer_info, length, &skb);
 
                /* Good Receive */
                skb_put(skb, length);
@@ -2020,12 +2047,11 @@ ixgb_clean_rx_irq(struct ixgb_adapter *adapter, int *work_done, int work_to_do)
                ixgb_rx_checksum(adapter, rx_desc, skb);
 
                skb->protocol = eth_type_trans(skb, netdev);
-               if (adapter->vlgrp && (status & IXGB_RX_DESC_STATUS_VP)) {
-                       vlan_hwaccel_receive_skb(skb, adapter->vlgrp,
-                                               le16_to_cpu(rx_desc->special));
-               } else {
-                       netif_receive_skb(skb);
-               }
+               if (status & IXGB_RX_DESC_STATUS_VP)
+                       __vlan_hwaccel_put_tag(skb,
+                                              le16_to_cpu(rx_desc->special));
+
+               netif_receive_skb(skb);
 
 rxdesc_done:
                /* clean up descriptor, might be written over by hw */
@@ -2092,10 +2118,10 @@ ixgb_alloc_rx_buffers(struct ixgb_adapter *adapter, int cleaned_count)
                buffer_info->skb = skb;
                buffer_info->length = adapter->rx_buffer_len;
 map_skb:
-               buffer_info->dma = pci_map_single(pdev,
+               buffer_info->dma = dma_map_single(&pdev->dev,
                                                  skb->data,
                                                  adapter->rx_buffer_len,
-                                                 PCI_DMA_FROMDEVICE);
+                                                 DMA_FROM_DEVICE);
 
                rx_desc = IXGB_RX_DESC(*rx_ring, i);
                rx_desc->buff_addr = cpu_to_le64(buffer_info->dma);
@@ -2123,43 +2149,26 @@ map_skb:
        }
 }
 
-/**
- * ixgb_vlan_rx_register - enables or disables vlan tagging/stripping.
- *
- * @param netdev network interface device structure
- * @param grp indicates to enable or disable tagging/stripping
- **/
 static void
-ixgb_vlan_rx_register(struct net_device *netdev, struct vlan_group *grp)
+ixgb_vlan_strip_enable(struct ixgb_adapter *adapter)
 {
-       struct ixgb_adapter *adapter = netdev_priv(netdev);
-       u32 ctrl, rctl;
+       u32 ctrl;
 
-       ixgb_irq_disable(adapter);
-       adapter->vlgrp = grp;
-
-       if (grp) {
-               /* enable VLAN tag insert/strip */
-               ctrl = IXGB_READ_REG(&adapter->hw, CTRL0);
-               ctrl |= IXGB_CTRL0_VME;
-               IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl);
-
-               /* enable VLAN receive filtering */
-
-               rctl = IXGB_READ_REG(&adapter->hw, RCTL);
-               rctl &= ~IXGB_RCTL_CFIEN;
-               IXGB_WRITE_REG(&adapter->hw, RCTL, rctl);
-       } else {
-               /* disable VLAN tag insert/strip */
+       /* enable VLAN tag insert/strip */
+       ctrl = IXGB_READ_REG(&adapter->hw, CTRL0);
+       ctrl |= IXGB_CTRL0_VME;
+       IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl);
+}
 
-               ctrl = IXGB_READ_REG(&adapter->hw, CTRL0);
-               ctrl &= ~IXGB_CTRL0_VME;
-               IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl);
-       }
+static void
+ixgb_vlan_strip_disable(struct ixgb_adapter *adapter)
+{
+       u32 ctrl;
 
-       /* don't enable interrupts unless we are UP */
-       if (adapter->netdev->flags & IFF_UP)
-               ixgb_irq_enable(adapter);
+       /* disable VLAN tag insert/strip */
+       ctrl = IXGB_READ_REG(&adapter->hw, CTRL0);
+       ctrl &= ~IXGB_CTRL0_VME;
+       IXGB_WRITE_REG(&adapter->hw, CTRL0, ctrl);
 }
 
 static void
@@ -2174,6 +2183,7 @@ ixgb_vlan_rx_add_vid(struct net_device *netdev, u16 vid)
        vfta = IXGB_READ_REG_ARRAY(&adapter->hw, VFTA, index);
        vfta |= (1 << (vid & 0x1F));
        ixgb_write_vfta(&adapter->hw, index, vfta);
+       set_bit(vid, adapter->active_vlans);
 }
 
 static void
@@ -2182,35 +2192,22 @@ ixgb_vlan_rx_kill_vid(struct net_device *netdev, u16 vid)
        struct ixgb_adapter *adapter = netdev_priv(netdev);
        u32 vfta, index;
 
-       ixgb_irq_disable(adapter);
-
-       vlan_group_set_device(adapter->vlgrp, vid, NULL);
-
-       /* don't enable interrupts unless we are UP */
-       if (adapter->netdev->flags & IFF_UP)
-               ixgb_irq_enable(adapter);
-
        /* remove VID from filter table */
 
        index = (vid >> 5) & 0x7F;
        vfta = IXGB_READ_REG_ARRAY(&adapter->hw, VFTA, index);
        vfta &= ~(1 << (vid & 0x1F));
        ixgb_write_vfta(&adapter->hw, index, vfta);
+       clear_bit(vid, adapter->active_vlans);
 }
 
 static void
 ixgb_restore_vlan(struct ixgb_adapter *adapter)
 {
-       ixgb_vlan_rx_register(adapter->netdev, adapter->vlgrp);
-
-       if (adapter->vlgrp) {
-               u16 vid;
-               for (vid = 0; vid < VLAN_GROUP_ARRAY_LEN; vid++) {
-                       if (!vlan_group_get_device(adapter->vlgrp, vid))
-                               continue;
-                       ixgb_vlan_rx_add_vid(adapter->netdev, vid);
-               }
-       }
+       u16 vid;
+
+       for_each_set_bit(vid, adapter->active_vlans, VLAN_N_VID)
+               ixgb_vlan_rx_add_vid(adapter->netdev, vid);
 }
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
@@ -2323,7 +2320,7 @@ static void ixgb_io_resume(struct pci_dev *pdev)
 
        if (netif_running(netdev)) {
                if (ixgb_up(adapter)) {
-                       printk ("ixgb: can't bring device back up after reset\n");
+                       pr_err("can't bring device back up after reset\n");
                        return;
                }
        }