static void pcnet32_purge_rx_ring(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        int i;
 
        /* free all allocated skbuffs */
 
 static int pcnet32_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long flags;
        int r = -EOPNOTSUPP;
 
 
 static int pcnet32_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long flags;
        int r = -EOPNOTSUPP;
 
 static void pcnet32_get_drvinfo(struct net_device *dev,
                                struct ethtool_drvinfo *info)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
 
        strcpy(info->driver, DRV_NAME);
        strcpy(info->version, DRV_VERSION);
 
 static u32 pcnet32_get_link(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long flags;
        int r;
 
 
 static u32 pcnet32_get_msglevel(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        return lp->msg_enable;
 }
 
 static void pcnet32_set_msglevel(struct net_device *dev, u32 value)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        lp->msg_enable = value;
 }
 
 static int pcnet32_nway_reset(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long flags;
        int r = -EOPNOTSUPP;
 
 static void pcnet32_get_ringparam(struct net_device *dev,
                                  struct ethtool_ringparam *ering)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
 
        ering->tx_max_pending = TX_MAX_RING_SIZE;
        ering->tx_pending = lp->tx_ring_size;
 static int pcnet32_set_ringparam(struct net_device *dev,
                                 struct ethtool_ringparam *ering)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long flags;
        unsigned int size;
        ulong ioaddr = dev->base_addr;
 static void pcnet32_ethtool_test(struct net_device *dev,
                                 struct ethtool_test *test, u64 * data)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        int rc;
 
        if (test->flags == ETH_TEST_FL_OFFLINE) {
 
 static int pcnet32_loopback_test(struct net_device *dev, uint64_t * data1)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        struct pcnet32_access *a = &lp->a;      /* access to registers */
        ulong ioaddr = dev->base_addr;  /* card base I/O address */
        struct sk_buff *skb;    /* sk buff */
 
 static void pcnet32_led_blink_callback(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        struct pcnet32_access *a = &lp->a;
        ulong ioaddr = dev->base_addr;
        unsigned long flags;
 
 static int pcnet32_phys_id(struct net_device *dev, u32 data)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        struct pcnet32_access *a = &lp->a;
        ulong ioaddr = dev->base_addr;
        unsigned long flags;
                int can_sleep)
 {
        int csr5;
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        struct pcnet32_access *a = &lp->a;
        ulong ioaddr = dev->base_addr;
        int ticks;
 
 static int pcnet32_rx(struct net_device *dev, int quota)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        int entry = lp->cur_rx & lp->rx_mod_mask;
        struct pcnet32_rx_head *rxp = &lp->rx_ring[entry];
        int npackets = 0;
 
 static int pcnet32_tx(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned int dirty_tx = lp->dirty_tx;
        int delta;
        int must_restart = 0;
 #ifdef CONFIG_PCNET32_NAPI
 static int pcnet32_poll(struct net_device *dev, int *budget)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        int quota = min(dev->quota, *budget);
        unsigned long ioaddr = dev->base_addr;
        unsigned long flags;
 #define PCNET32_MAX_PHYS       32
 static int pcnet32_get_regs_len(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        int j = lp->phycount * PCNET32_REGS_PER_PHY;
 
        return ((PCNET32_NUM_REGS + j) * sizeof(u16));
 {
        int i, csr0;
        u16 *buff = ptr;
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        struct pcnet32_access *a = &lp->a;
        ulong ioaddr = dev->base_addr;
        unsigned long flags;
        }
 
        dev->base_addr = ioaddr;
-       lp = dev->priv;
+       lp = netdev_priv(dev);
        /* pci_alloc_consistent returns page-aligned memory, so we do not have to check the alignment */
        if ((lp->init_block =
             pci_alloc_consistent(pdev, sizeof(*lp->init_block), &lp->init_dma_addr)) == NULL) {
 /* if any allocation fails, caller must also call pcnet32_free_ring */
 static int pcnet32_alloc_ring(struct net_device *dev, char *name)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
 
        lp->tx_ring = pci_alloc_consistent(lp->pci_dev,
                                           sizeof(struct pcnet32_tx_head) *
 
 static void pcnet32_free_ring(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
 
        kfree(lp->tx_skbuff);
        lp->tx_skbuff = NULL;
 
 static int pcnet32_open(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        u16 val;
        int i;
 
 static void pcnet32_purge_tx_ring(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        int i;
 
        for (i = 0; i < lp->tx_ring_size; i++) {
 /* Initialize the PCNET32 Rx and Tx rings. */
 static int pcnet32_init_ring(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        int i;
 
        lp->tx_full = 0;
  */
 static void pcnet32_restart(struct net_device *dev, unsigned int csr0_bits)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        int i;
 
 
 static void pcnet32_tx_timeout(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr, flags;
 
        spin_lock_irqsave(&lp->lock, flags);
 
 static int pcnet32_start_xmit(struct sk_buff *skb, struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        u16 status;
        int entry;
        int boguscnt = max_interrupt_work;
 
        ioaddr = dev->base_addr;
-       lp = dev->priv;
+       lp = netdev_priv(dev);
 
        spin_lock(&lp->lock);
 
 static int pcnet32_close(struct net_device *dev)
 {
        unsigned long ioaddr = dev->base_addr;
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long flags;
 
        del_timer_sync(&lp->watchdog_timer);
 
 static struct net_device_stats *pcnet32_get_stats(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        unsigned long flags;
 
 /* taken from the sunlance driver, which it took from the depca driver */
 static void pcnet32_load_multicast(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        volatile struct pcnet32_init_block *ib = lp->init_block;
        volatile u16 *mcast_table = (u16 *) & ib->filter;
        struct dev_mc_list *dmi = dev->mc_list;
 static void pcnet32_set_multicast_list(struct net_device *dev)
 {
        unsigned long ioaddr = dev->base_addr, flags;
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        int csr15, suspended;
 
        spin_lock_irqsave(&lp->lock, flags);
 /* This routine assumes that the lp->lock is held */
 static int mdio_read(struct net_device *dev, int phy_id, int reg_num)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
        u16 val_out;
 
 /* This routine assumes that the lp->lock is held */
 static void mdio_write(struct net_device *dev, int phy_id, int reg_num, int val)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long ioaddr = dev->base_addr;
 
        if (!lp->mii)
 
 static int pcnet32_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        int rc;
        unsigned long flags;
 
 
 static int pcnet32_check_otherphy(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        struct mii_if_info mii = lp->mii_if;
        u16 bmcr;
        int i;
 
 static void pcnet32_check_media(struct net_device *dev, int verbose)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        int curr_link;
        int prev_link = netif_carrier_ok(dev) ? 1 : 0;
        u32 bcr9;
 
 static void pcnet32_watchdog(struct net_device *dev)
 {
-       struct pcnet32_private *lp = dev->priv;
+       struct pcnet32_private *lp = netdev_priv(dev);
        unsigned long flags;
 
        /* Print the link status if it has changed */
        struct net_device *dev = pci_get_drvdata(pdev);
 
        if (dev) {
-               struct pcnet32_private *lp = dev->priv;
+               struct pcnet32_private *lp = netdev_priv(dev);
 
                unregister_netdev(dev);
                pcnet32_free_ring(dev);
        struct net_device *next_dev;
 
        while (pcnet32_dev) {
-               struct pcnet32_private *lp = pcnet32_dev->priv;
+               struct pcnet32_private *lp = netdev_priv(pcnet32_dev);
                next_dev = lp->next;
                unregister_netdev(pcnet32_dev);
                pcnet32_free_ring(pcnet32_dev);