void *card;
        struct net_device *dev;
 
-       struct net_device_stats stats;
        struct net_device *mesh_dev; /* Virtual device */
        struct net_device *rtap_net_dev;
 
 
        len = if_cs_read16(priv->card, IF_CS_READ_LEN);
        if (len == 0 || len > MRVDRV_ETH_RX_PACKET_BUFFER_SIZE) {
                lbs_pr_err("card data buffer has invalid # of bytes (%d)\n", len);
-               priv->stats.rx_dropped++;
+               priv->dev->stats.rx_dropped++;
                goto dat_err;
        }
 
 
 }
 EXPORT_SYMBOL_GPL(lbs_host_to_card_done);
 
-/**
- *  @brief This function returns the network statistics
- *
- *  @param dev     A pointer to struct lbs_private structure
- *  @return       A pointer to net_device_stats structure
- */
-static struct net_device_stats *lbs_get_stats(struct net_device *dev)
-{
-       struct lbs_private *priv = dev->ml_priv;
-
-       lbs_deb_enter(LBS_DEB_NET);
-       return &priv->stats;
-}
-
 static int lbs_set_mac_address(struct net_device *dev, void *addr)
 {
        int ret = 0;
        dev->stop = lbs_eth_stop;
        dev->set_mac_address = lbs_set_mac_address;
        dev->tx_timeout = lbs_tx_timeout;
-       dev->get_stats = lbs_get_stats;
+
        dev->watchdog_timeo = 5 * HZ;
        dev->ethtool_ops = &lbs_ethtool_ops;
 #ifdef WIRELESS_EXT
        mesh_dev->open = lbs_dev_open;
        mesh_dev->hard_start_xmit = lbs_hard_start_xmit;
        mesh_dev->stop = lbs_mesh_stop;
-       mesh_dev->get_stats = lbs_get_stats;
        mesh_dev->set_mac_address = lbs_set_mac_address;
        mesh_dev->ethtool_ops = &lbs_ethtool_ops;
        memcpy(mesh_dev->dev_addr, priv->dev->dev_addr,
        return NETDEV_TX_BUSY;
 }
 
-static struct net_device_stats *lbs_rtap_get_stats(struct net_device *dev)
-{
-       struct lbs_private *priv = dev->ml_priv;
-       lbs_deb_enter(LBS_DEB_NET);
-       return &priv->stats;
-}
-
-
 static void lbs_remove_rtap(struct lbs_private *priv)
 {
        lbs_deb_enter(LBS_DEB_MAIN);
        rtap_dev->type = ARPHRD_IEEE80211_RADIOTAP;
        rtap_dev->open = lbs_rtap_open;
        rtap_dev->stop = lbs_rtap_stop;
-       rtap_dev->get_stats = lbs_rtap_get_stats;
        rtap_dev->hard_start_xmit = lbs_rtap_hard_start_xmit;
        rtap_dev->ml_priv = priv;
        SET_NETDEV_DEV(rtap_dev, priv->dev->dev.parent);
 
 
        if (skb->len < (ETH_HLEN + 8 + sizeof(struct rxpd))) {
                lbs_deb_rx("rx err: frame received with bad length\n");
-               priv->stats.rx_length_errors++;
+               dev->stats.rx_length_errors++;
                ret = 0;
                goto done;
        }
        if (!(p_rx_pd->status & cpu_to_le16(MRVDRV_RXPD_STATUS_OK))) {
                lbs_deb_rx("rx err: frame received with bad status\n");
                lbs_pr_alert("rxpd not ok\n");
-               priv->stats.rx_errors++;
+               dev->stats.rx_errors++;
                ret = 0;
                goto done;
        }
        lbs_compute_rssi(priv, p_rx_pd);
 
        lbs_deb_rx("rx data: size of actual packet %d\n", skb->len);
-       priv->stats.rx_bytes += skb->len;
-       priv->stats.rx_packets++;
+       dev->stats.rx_bytes += skb->len;
+       dev->stats.rx_packets++;
 
        skb->protocol = eth_type_trans(skb, dev);
        if (in_interrupt())
        struct sk_buff *skb)
 {
        int ret = 0;
-
+       struct net_device *dev = priv->dev;
        struct rx80211packethdr *p_rx_pkt;
        struct rxpd *prxpd;
        struct rx_radiotap_hdr radiotap_hdr;
 
        if (skb->len < (ETH_HLEN + 8 + sizeof(struct rxpd))) {
                lbs_deb_rx("rx err: frame received with bad length\n");
-               priv->stats.rx_length_errors++;
+               dev->stats.rx_length_errors++;
                ret = -EINVAL;
                kfree_skb(skb);
                goto done;
         */
        if (!(prxpd->status & cpu_to_le16(MRVDRV_RXPD_STATUS_OK))) {
                //lbs_deb_rx("rx err: frame received with bad status\n");
-               priv->stats.rx_errors++;
+               dev->stats.rx_errors++;
        }
 
        lbs_deb_rx("rx data: skb->len-sizeof(RxPd) = %d-%zd = %zd\n",
        lbs_compute_rssi(priv, prxpd);
 
        lbs_deb_rx("rx data: size of actual packet %d\n", skb->len);
-       priv->stats.rx_bytes += skb->len;
-       priv->stats.rx_packets++;
+       dev->stats.rx_bytes += skb->len;
+       dev->stats.rx_packets++;
 
        skb->protocol = eth_type_trans(skb, priv->rtap_net_dev);
        netif_rx(skb);
 
                       skb->len, MRVDRV_ETH_TX_PACKET_BUFFER_SIZE);
                /* We'll never manage to send this one; drop it and return 'OK' */
 
-               priv->stats.tx_dropped++;
-               priv->stats.tx_errors++;
+               dev->stats.tx_dropped++;
+               dev->stats.tx_errors++;
                goto free;
        }
 
 
        lbs_deb_tx("%s lined up packet\n", __func__);
 
-       priv->stats.tx_packets++;
-       priv->stats.tx_bytes += skb->len;
+       dev->stats.tx_packets++;
+       dev->stats.tx_bytes += skb->len;
 
        dev->trans_start = jiffies;
 
 
        quality = rssi_qual;
 
        /* Quality by TX errors */
-       priv->wstats.discard.retries = priv->stats.tx_errors;
+       priv->wstats.discard.retries = dev->stats.tx_errors;
 
        memset(&log, 0, sizeof(log));
        log.hdr.size = cpu_to_le16(sizeof(log));