u_char mac1_mode;
        u_char mac2_mode;
        u_char hash_bytes[8];
-       struct net_device_stats stats;
 
        /* Rings for busmaster mode: */
        hp100_ring_t *rxrhead;  /* Head (oldest) index into rxring */
        spin_unlock_irqrestore(&lp->lock, flags);
 
        /* Update statistics */
-       lp->stats.tx_packets++;
-       lp->stats.tx_bytes += skb->len;
+       dev->stats.tx_packets++;
+       dev->stats.tx_bytes += skb->len;
 
        return NETDEV_TX_OK;
 
 
        hp100_outb(HP100_TX_CMD | HP100_SET_LB, OPTION_MSW);    /* send packet */
 
-       lp->stats.tx_packets++;
-       lp->stats.tx_bytes += skb->len;
+       dev->stats.tx_packets++;
+       dev->stats.tx_bytes += skb->len;
        hp100_ints_on();
        spin_unlock_irqrestore(&lp->lock, flags);
 
                        printk("hp100: %s: rx: couldn't allocate a sk_buff of size %d\n",
                                             dev->name, pkt_len);
 #endif
-                       lp->stats.rx_dropped++;
+                       dev->stats.rx_dropped++;
                } else {        /* skb successfully allocated */
 
                        u_char *ptr;
                                        ptr[9], ptr[10], ptr[11]);
 #endif
                        netif_rx(skb);
-                       lp->stats.rx_packets++;
-                       lp->stats.rx_bytes += pkt_len;
+                       dev->stats.rx_packets++;
+                       dev->stats.rx_bytes += pkt_len;
                }
 
                /* Indicate the card that we have got the packet */
                switch (header & 0x00070000) {
                case (HP100_MULTI_ADDR_HASH << 16):
                case (HP100_MULTI_ADDR_NO_HASH << 16):
-                       lp->stats.multicast++;
+                       dev->stats.multicast++;
                        break;
                }
        }                       /* end of while(there are packets) loop */
                        if (ptr->skb == NULL) {
                                printk("hp100: %s: rx_bm: skb null\n", dev->name);
                                /* can happen if we only allocated room for the pdh due to memory shortage. */
-                               lp->stats.rx_dropped++;
+                               dev->stats.rx_dropped++;
                        } else {
                                skb_trim(ptr->skb, pkt_len);    /* Shorten it */
                                ptr->skb->protocol =
 
                                netif_rx(ptr->skb);     /* Up and away... */
 
-                               lp->stats.rx_packets++;
-                               lp->stats.rx_bytes += pkt_len;
+                               dev->stats.rx_packets++;
+                               dev->stats.rx_bytes += pkt_len;
                        }
 
                        switch (header & 0x00070000) {
                        case (HP100_MULTI_ADDR_HASH << 16):
                        case (HP100_MULTI_ADDR_NO_HASH << 16):
-                               lp->stats.multicast++;
+                               dev->stats.multicast++;
                                break;
                        }
                } else {
 #endif
                        if (ptr->skb != NULL)
                                dev_kfree_skb_any(ptr->skb);
-                       lp->stats.rx_errors++;
+                       dev->stats.rx_errors++;
                }
 
                lp->rxrhead = lp->rxrhead->next;
        hp100_update_stats(dev);
        hp100_ints_on();
        spin_unlock_irqrestore(&lp->lock, flags);
-       return &(lp->stats);
+       return &(dev->stats);
 }
 
 static void hp100_update_stats(struct net_device *dev)
 {
        int ioaddr = dev->base_addr;
        u_short val;
-       struct hp100_private *lp = netdev_priv(dev);
 
 #ifdef HP100_DEBUG_B
        hp100_outw(0x4216, TRACE);
        /* Note: Statistics counters clear when read. */
        hp100_page(MAC_CTRL);
        val = hp100_inw(DROPPED) & 0x0fff;
-       lp->stats.rx_errors += val;
-       lp->stats.rx_over_errors += val;
+       dev->stats.rx_errors += val;
+       dev->stats.rx_over_errors += val;
        val = hp100_inb(CRC);
-       lp->stats.rx_errors += val;
-       lp->stats.rx_crc_errors += val;
+       dev->stats.rx_errors += val;
+       dev->stats.rx_crc_errors += val;
        val = hp100_inb(ABORT);
-       lp->stats.tx_errors += val;
-       lp->stats.tx_aborted_errors += val;
+       dev->stats.tx_errors += val;
+       dev->stats.tx_aborted_errors += val;
        hp100_page(PERFORMANCE);
 }
 
 #ifdef HP100_DEBUG_B
        int ioaddr = dev->base_addr;
 #endif
-       struct hp100_private *lp = netdev_priv(dev);
 
 #ifdef HP100_DEBUG_B
        int ioaddr = dev->base_addr;
 #endif
 
        /* Note: Statistics counters clear when read. */
-       lp->stats.rx_errors++;
-       lp->stats.tx_errors++;
+       dev->stats.rx_errors++;
+       dev->stats.tx_errors++;
 }
 
 static void hp100_clear_stats(struct hp100_private *lp, int ioaddr)