
From: Roger Luethi <rl@hellgate.ch>

This patch renames symbols:
via_rhine_* -> rhine_*
struct netdev_private *np -> struct rhine_private *rp


---

 25-akpm/drivers/net/via-rhine.c |  730 ++++++++++++++++++++--------------------
 1 files changed, 365 insertions(+), 365 deletions(-)

diff -puN drivers/net/via-rhine.c~via-rhine-rename-some-symbols drivers/net/via-rhine.c
--- 25/drivers/net/via-rhine.c~via-rhine-rename-some-symbols	2004-05-23 12:45:29.701268544 -0700
+++ 25-akpm/drivers/net/via-rhine.c	2004-05-23 12:45:29.713266720 -0700
@@ -361,14 +361,14 @@ enum pci_flags_bit {
 	PCI_ADDR0=0x10<<0, PCI_ADDR1=0x10<<1, PCI_ADDR2=0x10<<2, PCI_ADDR3=0x10<<3,
 };
 
-enum via_rhine_chips {
+enum rhine_chips {
 	VT86C100A = 0,
 	VT6102,
 	VT6105,
 	VT6105M
 };
 
-struct via_rhine_chip_info {
+struct rhine_chip_info {
 	const char *name;
 	u16 pci_flags;
 	int io_size;
@@ -388,8 +388,8 @@ enum chip_capability_flags {
 /* Beware of PCI posted writes */
 #define IOSYNC	do { readb(dev->base_addr + StationAddr); } while (0)
 
-/* directly indexed by enum via_rhine_chips, above */
-static struct via_rhine_chip_info via_rhine_chip_info[] __devinitdata =
+/* directly indexed by enum rhine_chips, above */
+static struct rhine_chip_info rhine_chip_info[] __devinitdata =
 {
 	{ "VIA VT86C100A Rhine", RHINE_IOTYPE, 128,
 	  CanHaveMII | ReqTxAlign | HasDavicomPhy },
@@ -401,7 +401,7 @@ static struct via_rhine_chip_info via_rh
 	  CanHaveMII | HasWOL },
 };
 
-static struct pci_device_id via_rhine_pci_tbl[] =
+static struct pci_device_id rhine_pci_tbl[] =
 {
 	{0x1106, 0x3043, PCI_ANY_ID, PCI_ANY_ID, 0, 0, VT86C100A},
 	{0x1106, 0x3065, PCI_ANY_ID, PCI_ANY_ID, 0, 0, VT6102},
@@ -409,7 +409,7 @@ static struct pci_device_id via_rhine_pc
 	{0x1106, 0x3053, PCI_ANY_ID, PCI_ANY_ID, 0, 0, VT6105M},
 	{0,}			/* terminate list */
 };
-MODULE_DEVICE_TABLE(pci, via_rhine_pci_tbl);
+MODULE_DEVICE_TABLE(pci, rhine_pci_tbl);
 
 
 /* Offsets to the device registers. */
@@ -489,7 +489,7 @@ enum chip_cmd_bits {
 };
 
 #define MAX_MII_CNT	4
-struct netdev_private {
+struct rhine_private {
 	/* Descriptor rings */
 	struct rx_desc *rx_ring;
 	struct tx_desc *tx_ring;
@@ -535,30 +535,30 @@ struct netdev_private {
 
 static int  mdio_read(struct net_device *dev, int phy_id, int location);
 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
-static int  via_rhine_open(struct net_device *dev);
-static void via_rhine_check_duplex(struct net_device *dev);
-static void via_rhine_timer(unsigned long data);
-static void via_rhine_tx_timeout(struct net_device *dev);
-static int  via_rhine_start_tx(struct sk_buff *skb, struct net_device *dev);
-static irqreturn_t via_rhine_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
-static void via_rhine_tx(struct net_device *dev);
-static void via_rhine_rx(struct net_device *dev);
-static void via_rhine_error(struct net_device *dev, int intr_status);
-static void via_rhine_set_rx_mode(struct net_device *dev);
-static struct net_device_stats *via_rhine_get_stats(struct net_device *dev);
+static int  rhine_open(struct net_device *dev);
+static void rhine_check_duplex(struct net_device *dev);
+static void rhine_timer(unsigned long data);
+static void rhine_tx_timeout(struct net_device *dev);
+static int  rhine_start_tx(struct sk_buff *skb, struct net_device *dev);
+static irqreturn_t rhine_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
+static void rhine_tx(struct net_device *dev);
+static void rhine_rx(struct net_device *dev);
+static void rhine_error(struct net_device *dev, int intr_status);
+static void rhine_set_rx_mode(struct net_device *dev);
+static struct net_device_stats *rhine_get_stats(struct net_device *dev);
 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
 static struct ethtool_ops netdev_ethtool_ops;
-static int  via_rhine_close(struct net_device *dev);
+static int  rhine_close(struct net_device *dev);
 
 static inline u32 get_intr_status(struct net_device *dev)
 {
 	long ioaddr = dev->base_addr;
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	u32 intr_status;
 
 	intr_status = readw(ioaddr + IntrStatus);
 	/* On Rhine-II, Bit 3 indicates Tx descriptor write-back race. */
-	if (np->chip_id == VT6102)
+	if (rp->chip_id == VT6102)
 		intr_status |= readb(ioaddr + IntrStatus2) << 16;
 	return intr_status;
 }
@@ -616,19 +616,19 @@ static void __devinit reload_eeprom(long
 }
 
 #ifdef CONFIG_NET_POLL_CONTROLLER
-static void via_rhine_poll(struct net_device *dev)
+static void rhine_poll(struct net_device *dev)
 {
 	disable_irq(dev->irq);
-	via_rhine_interrupt(dev->irq, (void *)dev, NULL);
+	rhine_interrupt(dev->irq, (void *)dev, NULL);
 	enable_irq(dev->irq);
 }
 #endif
 
-static int __devinit via_rhine_init_one (struct pci_dev *pdev,
+static int __devinit rhine_init_one (struct pci_dev *pdev,
 					 const struct pci_device_id *ent)
 {
 	struct net_device *dev;
-	struct netdev_private *np;
+	struct rhine_private *rp;
 	int i, option;
 	int chip_id = (int) ent->driver_data;
 	static int card_idx = -1;
@@ -649,8 +649,8 @@ static int __devinit via_rhine_init_one 
 
 	card_idx++;
 	option = card_idx < MAX_UNITS ? options[card_idx] : 0;
-	io_size = via_rhine_chip_info[chip_id].io_size;
-	pci_flags = via_rhine_chip_info[chip_id].pci_flags;
+	io_size = rhine_chip_info[chip_id].io_size;
+	pci_flags = rhine_chip_info[chip_id].pci_flags;
 
 	if (pci_enable_device (pdev))
 		goto err_out;
@@ -674,7 +674,7 @@ static int __devinit via_rhine_init_one 
 	if (pci_flags & PCI_USES_MASTER)
 		pci_set_master (pdev);
 
-	dev = alloc_etherdev(sizeof(*np));
+	dev = alloc_etherdev(sizeof(*rp));
 	if (dev == NULL) {
 		printk (KERN_ERR "init_ethernet failed for card #%d\n", card_idx);
 		goto err_out;
@@ -711,7 +711,7 @@ static int __devinit via_rhine_init_one 
 #endif
 
 	/* D-Link provided reset code (with comment additions) */
-	if (via_rhine_chip_info[chip_id].drv_flags & HasWOL) {
+	if (rhine_chip_info[chip_id].drv_flags & HasWOL) {
 		unsigned char byOrgValue;
 
 		/* clear sticky bit before reset & read ethernet address */
@@ -769,34 +769,34 @@ static int __devinit via_rhine_init_one 
 
 	dev->irq = pdev->irq;
 
-	np = dev->priv;
-	spin_lock_init (&np->lock);
-	np->chip_id = chip_id;
-	np->drv_flags = via_rhine_chip_info[chip_id].drv_flags;
-	np->pdev = pdev;
-	np->mii_if.dev = dev;
-	np->mii_if.mdio_read = mdio_read;
-	np->mii_if.mdio_write = mdio_write;
-	np->mii_if.phy_id_mask = 0x1f;
-	np->mii_if.reg_num_mask = 0x1f;
+	rp = dev->priv;
+	spin_lock_init (&rp->lock);
+	rp->chip_id = chip_id;
+	rp->drv_flags = rhine_chip_info[chip_id].drv_flags;
+	rp->pdev = pdev;
+	rp->mii_if.dev = dev;
+	rp->mii_if.mdio_read = mdio_read;
+	rp->mii_if.mdio_write = mdio_write;
+	rp->mii_if.phy_id_mask = 0x1f;
+	rp->mii_if.reg_num_mask = 0x1f;
 
 	if (dev->mem_start)
 		option = dev->mem_start;
 
 	/* The chip-specific entries in the device structure. */
-	dev->open = via_rhine_open;
-	dev->hard_start_xmit = via_rhine_start_tx;
-	dev->stop = via_rhine_close;
-	dev->get_stats = via_rhine_get_stats;
-	dev->set_multicast_list = via_rhine_set_rx_mode;
+	dev->open = rhine_open;
+	dev->hard_start_xmit = rhine_start_tx;
+	dev->stop = rhine_close;
+	dev->get_stats = rhine_get_stats;
+	dev->set_multicast_list = rhine_set_rx_mode;
 	dev->do_ioctl = netdev_ioctl;
 	dev->ethtool_ops = &netdev_ethtool_ops;
-	dev->tx_timeout = via_rhine_tx_timeout;
+	dev->tx_timeout = rhine_tx_timeout;
 	dev->watchdog_timeo = TX_TIMEOUT;
 #ifdef CONFIG_NET_POLL_CONTROLLER
-	dev->poll_controller = via_rhine_poll;
+	dev->poll_controller = rhine_poll;
 #endif
-	if (np->drv_flags & ReqTxAlign)
+	if (rp->drv_flags & ReqTxAlign)
 		dev->features |= NETIF_F_SG|NETIF_F_HW_CSUM;
 
 	/* dev->name not defined before register_netdev()! */
@@ -807,20 +807,20 @@ static int __devinit via_rhine_init_one 
 	/* The lower four bits are the media type. */
 	if (option > 0) {
 		if (option & 0x220)
-			np->mii_if.full_duplex = 1;
-		np->default_port = option & 15;
+			rp->mii_if.full_duplex = 1;
+		rp->default_port = option & 15;
 	}
 	if (card_idx < MAX_UNITS  &&  full_duplex[card_idx] > 0)
-		np->mii_if.full_duplex = 1;
+		rp->mii_if.full_duplex = 1;
 
-	if (np->mii_if.full_duplex) {
+	if (rp->mii_if.full_duplex) {
 		printk(KERN_INFO "%s: Set to forced full duplex, autonegotiation"
 			   " disabled.\n", dev->name);
-		np->mii_if.force_media = 1;
+		rp->mii_if.force_media = 1;
 	}
 
 	printk(KERN_INFO "%s: %s at 0x%lx, ",
-		   dev->name, via_rhine_chip_info[chip_id].name,
+		   dev->name, rhine_chip_info[chip_id].name,
 		   (pci_flags & PCI_USES_IO) ? ioaddr : memaddr);
 
 	for (i = 0; i < 5; i++)
@@ -829,17 +829,17 @@ static int __devinit via_rhine_init_one 
 
 	pci_set_drvdata(pdev, dev);
 
-	if (np->drv_flags & CanHaveMII) {
+	if (rp->drv_flags & CanHaveMII) {
 		int phy, phy_idx = 0;
-		np->phys[0] = 1;		/* Standard for this chip. */
+		rp->phys[0] = 1;		/* Standard for this chip. */
 		for (phy = 1; phy < 32 && phy_idx < MAX_MII_CNT; phy++) {
 			int mii_status = mdio_read(dev, phy, 1);
 			if (mii_status != 0xffff  &&  mii_status != 0x0000) {
-				np->phys[phy_idx++] = phy;
-				np->mii_if.advertising = mdio_read(dev, phy, 4);
+				rp->phys[phy_idx++] = phy;
+				rp->mii_if.advertising = mdio_read(dev, phy, 4);
 				printk(KERN_INFO "%s: MII PHY found at address %d, status "
 					   "0x%4.4x advertising %4.4x Link %4.4x.\n",
-					   dev->name, phy, mii_status, np->mii_if.advertising,
+					   dev->name, phy, mii_status, rp->mii_if.advertising,
 					   mdio_read(dev, phy, 5));
 
 				/* set IFF_RUNNING */
@@ -851,23 +851,23 @@ static int __devinit via_rhine_init_one 
 				break;
 			}
 		}
-		np->mii_cnt = phy_idx;
-		np->mii_if.phy_id = np->phys[0];
+		rp->mii_cnt = phy_idx;
+		rp->mii_if.phy_id = rp->phys[0];
 	}
 
 	/* Allow forcing the media type. */
 	if (option > 0) {
 		if (option & 0x220)
-			np->mii_if.full_duplex = 1;
-		np->default_port = option & 0x3ff;
+			rp->mii_if.full_duplex = 1;
+		rp->default_port = option & 0x3ff;
 		if (option & 0x330) {
 			/* FIXME: shouldn't someone check this variable? */
-			/* np->medialock = 1; */
+			/* rp->medialock = 1; */
 			printk(KERN_INFO "  Forcing %dMbs %s-duplex operation.\n",
 				   (option & 0x300 ? 100 : 10),
 				   (option & 0x220 ? "full" : "half"));
-			if (np->mii_cnt)
-				mdio_write(dev, np->phys[0], MII_BMCR,
+			if (rp->mii_cnt)
+				mdio_write(dev, rp->phys[0], MII_BMCR,
 						   ((option & 0x300) ? 0x2000 : 0) |  /* 100mbps? */
 						   ((option & 0x220) ? 0x0100 : 0));  /* Full duplex? */
 		}
@@ -889,11 +889,11 @@ err_out:
 
 static int alloc_ring(struct net_device* dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	void *ring;
 	dma_addr_t ring_dma;
 
-	ring = pci_alloc_consistent(np->pdev,
+	ring = pci_alloc_consistent(rp->pdev,
 				    RX_RING_SIZE * sizeof(struct rx_desc) +
 				    TX_RING_SIZE * sizeof(struct tx_desc),
 				    &ring_dma);
@@ -901,11 +901,11 @@ static int alloc_ring(struct net_device*
 		printk(KERN_ERR "Could not allocate DMA memory.\n");
 		return -ENOMEM;
 	}
-	if (np->drv_flags & ReqTxAlign) {
-		np->tx_bufs = pci_alloc_consistent(np->pdev, PKT_BUF_SZ * TX_RING_SIZE,
-								   &np->tx_bufs_dma);
-		if (np->tx_bufs == NULL) {
-			pci_free_consistent(np->pdev,
+	if (rp->drv_flags & ReqTxAlign) {
+		rp->tx_bufs = pci_alloc_consistent(rp->pdev, PKT_BUF_SZ * TX_RING_SIZE,
+								   &rp->tx_bufs_dma);
+		if (rp->tx_bufs == NULL) {
+			pci_free_consistent(rp->pdev,
 				    RX_RING_SIZE * sizeof(struct rx_desc) +
 				    TX_RING_SIZE * sizeof(struct tx_desc),
 				    ring, ring_dma);
@@ -913,137 +913,137 @@ static int alloc_ring(struct net_device*
 		}
 	}
 
-	np->rx_ring = ring;
-	np->tx_ring = ring + RX_RING_SIZE * sizeof(struct rx_desc);
-	np->rx_ring_dma = ring_dma;
-	np->tx_ring_dma = ring_dma + RX_RING_SIZE * sizeof(struct rx_desc);
+	rp->rx_ring = ring;
+	rp->tx_ring = ring + RX_RING_SIZE * sizeof(struct rx_desc);
+	rp->rx_ring_dma = ring_dma;
+	rp->tx_ring_dma = ring_dma + RX_RING_SIZE * sizeof(struct rx_desc);
 
 	return 0;
 }
 
 void free_ring(struct net_device* dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 
-	pci_free_consistent(np->pdev,
+	pci_free_consistent(rp->pdev,
 			    RX_RING_SIZE * sizeof(struct rx_desc) +
 			    TX_RING_SIZE * sizeof(struct tx_desc),
-			    np->rx_ring, np->rx_ring_dma);
-	np->tx_ring = NULL;
+			    rp->rx_ring, rp->rx_ring_dma);
+	rp->tx_ring = NULL;
 
-	if (np->tx_bufs)
-		pci_free_consistent(np->pdev, PKT_BUF_SZ * TX_RING_SIZE,
-							np->tx_bufs, np->tx_bufs_dma);
+	if (rp->tx_bufs)
+		pci_free_consistent(rp->pdev, PKT_BUF_SZ * TX_RING_SIZE,
+							rp->tx_bufs, rp->tx_bufs_dma);
 
-	np->tx_bufs = NULL;
+	rp->tx_bufs = NULL;
 
 }
 
 static void alloc_rbufs(struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	dma_addr_t next;
 	int i;
 
-	np->dirty_rx = np->cur_rx = 0;
+	rp->dirty_rx = rp->cur_rx = 0;
 
-	np->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
-	np->rx_head_desc = &np->rx_ring[0];
-	next = np->rx_ring_dma;
+	rp->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
+	rp->rx_head_desc = &rp->rx_ring[0];
+	next = rp->rx_ring_dma;
 
 	/* Init the ring entries */
 	for (i = 0; i < RX_RING_SIZE; i++) {
-		np->rx_ring[i].rx_status = 0;
-		np->rx_ring[i].desc_length = cpu_to_le32(np->rx_buf_sz);
+		rp->rx_ring[i].rx_status = 0;
+		rp->rx_ring[i].desc_length = cpu_to_le32(rp->rx_buf_sz);
 		next += sizeof(struct rx_desc);
-		np->rx_ring[i].next_desc = cpu_to_le32(next);
-		np->rx_skbuff[i] = 0;
+		rp->rx_ring[i].next_desc = cpu_to_le32(next);
+		rp->rx_skbuff[i] = 0;
 	}
 	/* Mark the last entry as wrapping the ring. */
-	np->rx_ring[i-1].next_desc = cpu_to_le32(np->rx_ring_dma);
+	rp->rx_ring[i-1].next_desc = cpu_to_le32(rp->rx_ring_dma);
 
 	/* Fill in the Rx buffers.  Handle allocation failure gracefully. */
 	for (i = 0; i < RX_RING_SIZE; i++) {
-		struct sk_buff *skb = dev_alloc_skb(np->rx_buf_sz);
-		np->rx_skbuff[i] = skb;
+		struct sk_buff *skb = dev_alloc_skb(rp->rx_buf_sz);
+		rp->rx_skbuff[i] = skb;
 		if (skb == NULL)
 			break;
 		skb->dev = dev;                 /* Mark as being used by this device. */
 
-		np->rx_skbuff_dma[i] =
-			pci_map_single(np->pdev, skb->tail, np->rx_buf_sz,
+		rp->rx_skbuff_dma[i] =
+			pci_map_single(rp->pdev, skb->tail, rp->rx_buf_sz,
 						   PCI_DMA_FROMDEVICE);
 
-		np->rx_ring[i].addr = cpu_to_le32(np->rx_skbuff_dma[i]);
-		np->rx_ring[i].rx_status = cpu_to_le32(DescOwn);
+		rp->rx_ring[i].addr = cpu_to_le32(rp->rx_skbuff_dma[i]);
+		rp->rx_ring[i].rx_status = cpu_to_le32(DescOwn);
 	}
-	np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
+	rp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
 }
 
 static void free_rbufs(struct net_device* dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	int i;
 
 	/* Free all the skbuffs in the Rx queue. */
 	for (i = 0; i < RX_RING_SIZE; i++) {
-		np->rx_ring[i].rx_status = 0;
-		np->rx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
-		if (np->rx_skbuff[i]) {
-			pci_unmap_single(np->pdev,
-							 np->rx_skbuff_dma[i],
-							 np->rx_buf_sz, PCI_DMA_FROMDEVICE);
-			dev_kfree_skb(np->rx_skbuff[i]);
+		rp->rx_ring[i].rx_status = 0;
+		rp->rx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
+		if (rp->rx_skbuff[i]) {
+			pci_unmap_single(rp->pdev,
+							 rp->rx_skbuff_dma[i],
+							 rp->rx_buf_sz, PCI_DMA_FROMDEVICE);
+			dev_kfree_skb(rp->rx_skbuff[i]);
 		}
-		np->rx_skbuff[i] = 0;
+		rp->rx_skbuff[i] = 0;
 	}
 }
 
 static void alloc_tbufs(struct net_device* dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	dma_addr_t next;
 	int i;
 
-	np->dirty_tx = np->cur_tx = 0;
-	next = np->tx_ring_dma;
+	rp->dirty_tx = rp->cur_tx = 0;
+	next = rp->tx_ring_dma;
 	for (i = 0; i < TX_RING_SIZE; i++) {
-		np->tx_skbuff[i] = 0;
-		np->tx_ring[i].tx_status = 0;
-		np->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
+		rp->tx_skbuff[i] = 0;
+		rp->tx_ring[i].tx_status = 0;
+		rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
 		next += sizeof(struct tx_desc);
-		np->tx_ring[i].next_desc = cpu_to_le32(next);
-		np->tx_buf[i] = &np->tx_bufs[i * PKT_BUF_SZ];
+		rp->tx_ring[i].next_desc = cpu_to_le32(next);
+		rp->tx_buf[i] = &rp->tx_bufs[i * PKT_BUF_SZ];
 	}
-	np->tx_ring[i-1].next_desc = cpu_to_le32(np->tx_ring_dma);
+	rp->tx_ring[i-1].next_desc = cpu_to_le32(rp->tx_ring_dma);
 
 }
 
 static void free_tbufs(struct net_device* dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	int i;
 
 	for (i = 0; i < TX_RING_SIZE; i++) {
-		np->tx_ring[i].tx_status = 0;
-		np->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
-		np->tx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
-		if (np->tx_skbuff[i]) {
-			if (np->tx_skbuff_dma[i]) {
-				pci_unmap_single(np->pdev,
-								 np->tx_skbuff_dma[i],
-								 np->tx_skbuff[i]->len, PCI_DMA_TODEVICE);
+		rp->tx_ring[i].tx_status = 0;
+		rp->tx_ring[i].desc_length = cpu_to_le32(TXDESC);
+		rp->tx_ring[i].addr = cpu_to_le32(0xBADF00D0); /* An invalid address. */
+		if (rp->tx_skbuff[i]) {
+			if (rp->tx_skbuff_dma[i]) {
+				pci_unmap_single(rp->pdev,
+								 rp->tx_skbuff_dma[i],
+								 rp->tx_skbuff[i]->len, PCI_DMA_TODEVICE);
 			}
-			dev_kfree_skb(np->tx_skbuff[i]);
+			dev_kfree_skb(rp->tx_skbuff[i]);
 		}
-		np->tx_skbuff[i] = 0;
-		np->tx_buf[i] = 0;
+		rp->tx_skbuff[i] = 0;
+		rp->tx_buf[i] = 0;
 	}
 }
 
 static void init_registers(struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	long ioaddr = dev->base_addr;
 	int i;
 
@@ -1054,17 +1054,17 @@ static void init_registers(struct net_de
 	writew(0x0006, ioaddr + PCIBusConfig);	/* Tune configuration??? */
 	/* Configure initial FIFO thresholds. */
 	writeb(0x20, ioaddr + TxConfig);
-	np->tx_thresh = 0x20;
-	np->rx_thresh = 0x60;			/* Written in via_rhine_set_rx_mode(). */
-	np->mii_if.full_duplex = 0;
+	rp->tx_thresh = 0x20;
+	rp->rx_thresh = 0x60;			/* Written in rhine_set_rx_mode(). */
+	rp->mii_if.full_duplex = 0;
 
 	if (dev->if_port == 0)
-		dev->if_port = np->default_port;
+		dev->if_port = rp->default_port;
 
-	writel(np->rx_ring_dma, ioaddr + RxRingPtr);
-	writel(np->tx_ring_dma, ioaddr + TxRingPtr);
+	writel(rp->rx_ring_dma, ioaddr + RxRingPtr);
+	writel(rp->tx_ring_dma, ioaddr + TxRingPtr);
 
-	via_rhine_set_rx_mode(dev);
+	rhine_set_rx_mode(dev);
 
 	/* Enable interrupts by setting the interrupt mask. */
 	writew(IntrRxDone | IntrRxErr | IntrRxEmpty| IntrRxOverflow |
@@ -1073,18 +1073,18 @@ static void init_registers(struct net_de
 		   IntrPCIErr | IntrStatsMax | IntrLinkChange,
 		   ioaddr + IntrEnable);
 
-	np->chip_cmd = CmdStart|CmdTxOn|CmdRxOn|CmdNoTxPoll;
-	if (np->mii_if.force_media)
-		np->chip_cmd |= CmdFDuplex;
-	writew(np->chip_cmd, ioaddr + ChipCmd);
+	rp->chip_cmd = CmdStart|CmdTxOn|CmdRxOn|CmdNoTxPoll;
+	if (rp->mii_if.force_media)
+		rp->chip_cmd |= CmdFDuplex;
+	writew(rp->chip_cmd, ioaddr + ChipCmd);
 
-	via_rhine_check_duplex(dev);
+	rhine_check_duplex(dev);
 
 	/* The LED outputs of various MII xcvrs should be configured.  */
 	/* For NS or Mison phys, turn on bit 1 in register 0x17 */
 	/* For ESI phys, turn on bit 7 in register 0x17. */
-	mdio_write(dev, np->phys[0], 0x17, mdio_read(dev, np->phys[0], 0x17) |
-			   (np->drv_flags & HasESIPhy) ? 0x0080 : 0x0001);
+	mdio_write(dev, rp->phys[0], 0x17, mdio_read(dev, rp->phys[0], 0x17) |
+			   (rp->drv_flags & HasESIPhy) ? 0x0080 : 0x0001);
 }
 /* Read and write over the MII Management Data I/O (MDIO) interface. */
 
@@ -1108,20 +1108,20 @@ static int mdio_read(struct net_device *
 
 static void mdio_write(struct net_device *dev, int phy_id, int regnum, int value)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	long ioaddr = dev->base_addr;
 	int boguscnt = 1024;
 
-	if (phy_id == np->phys[0]) {
+	if (phy_id == rp->phys[0]) {
 		switch (regnum) {
 		case MII_BMCR:					/* Is user forcing speed/duplex? */
 			if (value & 0x9000)			/* Autonegotiation. */
-				np->mii_if.force_media = 0;
+				rp->mii_if.force_media = 0;
 			else
-				np->mii_if.full_duplex = (value & 0x0100) ? 1 : 0;
+				rp->mii_if.full_duplex = (value & 0x0100) ? 1 : 0;
 			break;
 		case MII_ADVERTISE:
-			np->mii_if.advertising = value;
+			rp->mii_if.advertising = value;
 			break;
 		}
 	}
@@ -1137,78 +1137,78 @@ static void mdio_write(struct net_device
 }
 
 
-static int via_rhine_open(struct net_device *dev)
+static int rhine_open(struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	long ioaddr = dev->base_addr;
 	int i;
 
 	/* Reset the chip. */
 	writew(CmdReset, ioaddr + ChipCmd);
 
-	i = request_irq(np->pdev->irq, &via_rhine_interrupt, SA_SHIRQ, dev->name, dev);
+	i = request_irq(rp->pdev->irq, &rhine_interrupt, SA_SHIRQ, dev->name, dev);
 	if (i)
 		return i;
 
 	if (debug > 1)
-		printk(KERN_DEBUG "%s: via_rhine_open() irq %d.\n",
-			   dev->name, np->pdev->irq);
+		printk(KERN_DEBUG "%s: rhine_open() irq %d.\n",
+			   dev->name, rp->pdev->irq);
 
 	i = alloc_ring(dev);
 	if (i)
 		return i;
 	alloc_rbufs(dev);
 	alloc_tbufs(dev);
-	wait_for_reset(dev, np->chip_id, dev->name);
+	wait_for_reset(dev, rp->chip_id, dev->name);
 	init_registers(dev);
 	if (debug > 2)
-		printk(KERN_DEBUG "%s: Done via_rhine_open(), status %4.4x "
+		printk(KERN_DEBUG "%s: Done rhine_open(), status %4.4x "
 			   "MII status: %4.4x.\n",
 			   dev->name, readw(ioaddr + ChipCmd),
-			   mdio_read(dev, np->phys[0], MII_BMSR));
+			   mdio_read(dev, rp->phys[0], MII_BMSR));
 
 	netif_start_queue(dev);
 
 	/* Set the timer to check for link beat. */
-	init_timer(&np->timer);
-	np->timer.expires = jiffies + 2 * HZ/100;
-	np->timer.data = (unsigned long)dev;
-	np->timer.function = &via_rhine_timer;				/* timer handler */
-	add_timer(&np->timer);
+	init_timer(&rp->timer);
+	rp->timer.expires = jiffies + 2 * HZ/100;
+	rp->timer.data = (unsigned long)dev;
+	rp->timer.function = &rhine_timer;				/* timer handler */
+	add_timer(&rp->timer);
 
 	return 0;
 }
 
-static void via_rhine_check_duplex(struct net_device *dev)
+static void rhine_check_duplex(struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	long ioaddr = dev->base_addr;
-	int mii_lpa = mdio_read(dev, np->phys[0], MII_LPA);
-	int negotiated = mii_lpa & np->mii_if.advertising;
+	int mii_lpa = mdio_read(dev, rp->phys[0], MII_LPA);
+	int negotiated = mii_lpa & rp->mii_if.advertising;
 	int duplex;
 
-	if (np->mii_if.force_media  ||  mii_lpa == 0xffff)
+	if (rp->mii_if.force_media  ||  mii_lpa == 0xffff)
 		return;
 	duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
-	if (np->mii_if.full_duplex != duplex) {
-		np->mii_if.full_duplex = duplex;
+	if (rp->mii_if.full_duplex != duplex) {
+		rp->mii_if.full_duplex = duplex;
 		if (debug)
 			printk(KERN_INFO "%s: Setting %s-duplex based on MII #%d link"
 				   " partner capability of %4.4x.\n", dev->name,
-				   duplex ? "full" : "half", np->phys[0], mii_lpa);
+				   duplex ? "full" : "half", rp->phys[0], mii_lpa);
 		if (duplex)
-			np->chip_cmd |= CmdFDuplex;
+			rp->chip_cmd |= CmdFDuplex;
 		else
-			np->chip_cmd &= ~CmdFDuplex;
-		writew(np->chip_cmd, ioaddr + ChipCmd);
+			rp->chip_cmd &= ~CmdFDuplex;
+		writew(rp->chip_cmd, ioaddr + ChipCmd);
 	}
 }
 
 
-static void via_rhine_timer(unsigned long data)
+static void rhine_timer(unsigned long data)
 {
 	struct net_device *dev = (struct net_device *)data;
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	long ioaddr = dev->base_addr;
 	int next_tick = 10*HZ;
 	int mii_status;
@@ -1218,43 +1218,43 @@ static void via_rhine_timer(unsigned lon
 			   dev->name, readw(ioaddr + IntrStatus));
 	}
 
-	spin_lock_irq (&np->lock);
+	spin_lock_irq (&rp->lock);
 
-	via_rhine_check_duplex(dev);
+	rhine_check_duplex(dev);
 
 	/* make IFF_RUNNING follow the MII status bit "Link established" */
-	mii_status = mdio_read(dev, np->phys[0], MII_BMSR);
-	if ( (mii_status & BMSR_LSTATUS) != (np->mii_status & BMSR_LSTATUS) ) {
+	mii_status = mdio_read(dev, rp->phys[0], MII_BMSR);
+	if ( (mii_status & BMSR_LSTATUS) != (rp->mii_status & BMSR_LSTATUS) ) {
 		if (mii_status & BMSR_LSTATUS)
 			netif_carrier_on(dev);
 		else
 			netif_carrier_off(dev);
 	}
-	np->mii_status = mii_status;
+	rp->mii_status = mii_status;
 
-	spin_unlock_irq (&np->lock);
+	spin_unlock_irq (&rp->lock);
 
-	np->timer.expires = jiffies + next_tick;
-	add_timer(&np->timer);
+	rp->timer.expires = jiffies + next_tick;
+	add_timer(&rp->timer);
 }
 
 
-static void via_rhine_tx_timeout (struct net_device *dev)
+static void rhine_tx_timeout (struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	long ioaddr = dev->base_addr;
 
 	printk (KERN_WARNING "%s: Transmit timed out, status %4.4x, PHY status "
 		"%4.4x, resetting...\n",
 		dev->name, readw (ioaddr + IntrStatus),
-		mdio_read (dev, np->phys[0], MII_BMSR));
+		mdio_read (dev, rp->phys[0], MII_BMSR));
 
 	dev->if_port = 0;
 
 	/* protect against concurrent rx interrupts */
-	disable_irq(np->pdev->irq);
+	disable_irq(rp->pdev->irq);
 
-	spin_lock(&np->lock);
+	spin_lock(&rp->lock);
 
 	/* Reset the chip. */
 	writew(CmdReset, ioaddr + ChipCmd);
@@ -1266,20 +1266,20 @@ static void via_rhine_tx_timeout (struct
 	alloc_rbufs(dev);
 
 	/* Reinitialize the hardware. */
-	wait_for_reset(dev, np->chip_id, dev->name);
+	wait_for_reset(dev, rp->chip_id, dev->name);
 	init_registers(dev);
 
-	spin_unlock(&np->lock);
-	enable_irq(np->pdev->irq);
+	spin_unlock(&rp->lock);
+	enable_irq(rp->pdev->irq);
 
 	dev->trans_start = jiffies;
-	np->stats.tx_errors++;
+	rp->stats.tx_errors++;
 	netif_wake_queue(dev);
 }
 
-static int via_rhine_start_tx(struct sk_buff *skb, struct net_device *dev)
+static int rhine_start_tx(struct sk_buff *skb, struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	unsigned entry;
 	u32 intr_status;
 
@@ -1287,7 +1287,7 @@ static int via_rhine_start_tx(struct sk_
 	   with the "ownership" bits last. */
 
 	/* Calculate the next Tx descriptor entry. */
-	entry = np->cur_tx % TX_RING_SIZE;
+	entry = rp->cur_tx % TX_RING_SIZE;
 
 	if (skb->len < ETH_ZLEN) {
 		skb = skb_padto(skb, ETH_ZLEN);
@@ -1295,39 +1295,39 @@ static int via_rhine_start_tx(struct sk_
 			return 0;
 	}
 
-	np->tx_skbuff[entry] = skb;
+	rp->tx_skbuff[entry] = skb;
 
-	if ((np->drv_flags & ReqTxAlign) &&
+	if ((rp->drv_flags & ReqTxAlign) &&
 		(((long)skb->data & 3) || skb_shinfo(skb)->nr_frags != 0 || skb->ip_summed == CHECKSUM_HW)
 		) {
 		/* Must use alignment buffer. */
 		if (skb->len > PKT_BUF_SZ) {
 			/* packet too long, drop it */
 			dev_kfree_skb(skb);
-			np->tx_skbuff[entry] = NULL;
-			np->stats.tx_dropped++;
+			rp->tx_skbuff[entry] = NULL;
+			rp->stats.tx_dropped++;
 			return 0;
 		}
-		skb_copy_and_csum_dev(skb, np->tx_buf[entry]);
-		np->tx_skbuff_dma[entry] = 0;
-		np->tx_ring[entry].addr = cpu_to_le32(np->tx_bufs_dma +
-										  (np->tx_buf[entry] - np->tx_bufs));
+		skb_copy_and_csum_dev(skb, rp->tx_buf[entry]);
+		rp->tx_skbuff_dma[entry] = 0;
+		rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_bufs_dma +
+										  (rp->tx_buf[entry] - rp->tx_bufs));
 	} else {
-		np->tx_skbuff_dma[entry] =
-			pci_map_single(np->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
-		np->tx_ring[entry].addr = cpu_to_le32(np->tx_skbuff_dma[entry]);
+		rp->tx_skbuff_dma[entry] =
+			pci_map_single(rp->pdev, skb->data, skb->len, PCI_DMA_TODEVICE);
+		rp->tx_ring[entry].addr = cpu_to_le32(rp->tx_skbuff_dma[entry]);
 	}
 
-	np->tx_ring[entry].desc_length =
+	rp->tx_ring[entry].desc_length =
 		cpu_to_le32(TXDESC | (skb->len >= ETH_ZLEN ? skb->len : ETH_ZLEN));
 
 	/* lock eth irq */
-	spin_lock_irq (&np->lock);
+	spin_lock_irq (&rp->lock);
 	wmb();
-	np->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
+	rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
 	wmb();
 
-	np->cur_tx++;
+	rp->cur_tx++;
 
 	/* Non-x86 Todo: explicitly flush cache lines here. */
 
@@ -1337,27 +1337,27 @@ static int via_rhine_start_tx(struct sk_
 	 */
 	intr_status = get_intr_status(dev);
 	if ((intr_status & IntrTxErrSummary) == 0) {
-		writew(CmdTxDemand | np->chip_cmd, dev->base_addr + ChipCmd);
+		writew(CmdTxDemand | rp->chip_cmd, dev->base_addr + ChipCmd);
 	}
 	IOSYNC;
 
-	if (np->cur_tx == np->dirty_tx + TX_QUEUE_LEN)
+	if (rp->cur_tx == rp->dirty_tx + TX_QUEUE_LEN)
 		netif_stop_queue(dev);
 
 	dev->trans_start = jiffies;
 
-	spin_unlock_irq (&np->lock);
+	spin_unlock_irq (&rp->lock);
 
 	if (debug > 4) {
 		printk(KERN_DEBUG "%s: Transmit frame #%d queued in slot %d.\n",
-			   dev->name, np->cur_tx-1, entry);
+			   dev->name, rp->cur_tx-1, entry);
 	}
 	return 0;
 }
 
 /* The interrupt handler does all of the Rx thread work and cleans up
    after the Tx thread. */
-static irqreturn_t via_rhine_interrupt(int irq, void *dev_instance, struct pt_regs *rgs)
+static irqreturn_t rhine_interrupt(int irq, void *dev_instance, struct pt_regs *rgs)
 {
 	struct net_device *dev = dev_instance;
 	long ioaddr;
@@ -1382,7 +1382,7 @@ static irqreturn_t via_rhine_interrupt(i
 
 		if (intr_status & (IntrRxDone | IntrRxErr | IntrRxDropped |
 						   IntrRxWakeUp | IntrRxEmpty | IntrRxNoBuf))
-			via_rhine_rx(dev);
+			rhine_rx(dev);
 
 		if (intr_status & (IntrTxErrSummary | IntrTxDone)) {
 			if (intr_status & IntrTxErrSummary) {
@@ -1391,18 +1391,18 @@ static irqreturn_t via_rhine_interrupt(i
 				while ((readw(ioaddr+ChipCmd) & CmdTxOn) && --cnt)
 					udelay(5);
 				if (debug > 2 && !cnt)
-					printk(KERN_WARNING "%s: via_rhine_interrupt() "
+					printk(KERN_WARNING "%s: rhine_interrupt() "
 						   "Tx engine still on.\n",
 						   dev->name);
 			}
-			via_rhine_tx(dev);
+			rhine_tx(dev);
 		}
 
 		/* Abnormal error summary/uncommon events handlers. */
 		if (intr_status & (IntrPCIErr | IntrLinkChange |
 				   IntrStatsMax | IntrTxError | IntrTxAborted |
 				   IntrTxUnderrun | IntrTxDescRace))
-			via_rhine_error(dev, intr_status);
+			rhine_error(dev, intr_status);
 
 		if (--boguscnt < 0) {
 			printk(KERN_WARNING "%s: Too much work at interrupt, "
@@ -1420,16 +1420,16 @@ static irqreturn_t via_rhine_interrupt(i
 
 /* This routine is logically part of the interrupt handler, but isolated
    for clarity. */
-static void via_rhine_tx(struct net_device *dev)
+static void rhine_tx(struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
-	int txstatus = 0, entry = np->dirty_tx % TX_RING_SIZE;
+	struct rhine_private *rp = dev->priv;
+	int txstatus = 0, entry = rp->dirty_tx % TX_RING_SIZE;
 
-	spin_lock (&np->lock);
+	spin_lock (&rp->lock);
 
 	/* find and cleanup dirty tx descriptors */
-	while (np->dirty_tx != np->cur_tx) {
-		txstatus = le32_to_cpu(np->tx_ring[entry].tx_status);
+	while (rp->dirty_tx != rp->cur_tx) {
+		txstatus = le32_to_cpu(rp->tx_ring[entry].tx_status);
 		if (debug > 6)
 			printk(KERN_DEBUG " Tx scavenge %d status %8.8x.\n",
 				   entry, txstatus);
@@ -1439,67 +1439,67 @@ static void via_rhine_tx(struct net_devi
 			if (debug > 1)
 				printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n",
 					   dev->name, txstatus);
-			np->stats.tx_errors++;
-			if (txstatus & 0x0400) np->stats.tx_carrier_errors++;
-			if (txstatus & 0x0200) np->stats.tx_window_errors++;
-			if (txstatus & 0x0100) np->stats.tx_aborted_errors++;
-			if (txstatus & 0x0080) np->stats.tx_heartbeat_errors++;
-			if (((np->chip_id == VT86C100A) && txstatus & 0x0002) ||
+			rp->stats.tx_errors++;
+			if (txstatus & 0x0400) rp->stats.tx_carrier_errors++;
+			if (txstatus & 0x0200) rp->stats.tx_window_errors++;
+			if (txstatus & 0x0100) rp->stats.tx_aborted_errors++;
+			if (txstatus & 0x0080) rp->stats.tx_heartbeat_errors++;
+			if (((rp->chip_id == VT86C100A) && txstatus & 0x0002) ||
 				(txstatus & 0x0800) || (txstatus & 0x1000)) {
-				np->stats.tx_fifo_errors++;
-				np->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
+				rp->stats.tx_fifo_errors++;
+				rp->tx_ring[entry].tx_status = cpu_to_le32(DescOwn);
 				break; /* Keep the skb - we try again */
 			}
 			/* Transmitter restarted in 'abnormal' handler. */
 		} else {
-			if (np->chip_id == VT86C100A)
-				np->stats.collisions += (txstatus >> 3) & 0x0F;
+			if (rp->chip_id == VT86C100A)
+				rp->stats.collisions += (txstatus >> 3) & 0x0F;
 			else
-				np->stats.collisions += txstatus & 0x0F;
+				rp->stats.collisions += txstatus & 0x0F;
 			if (debug > 6)
 				printk(KERN_DEBUG "collisions: %1.1x:%1.1x\n",
 					(txstatus >> 3) & 0xF,
 					txstatus & 0xF);
-			np->stats.tx_bytes += np->tx_skbuff[entry]->len;
-			np->stats.tx_packets++;
+			rp->stats.tx_bytes += rp->tx_skbuff[entry]->len;
+			rp->stats.tx_packets++;
 		}
 		/* Free the original skb. */
-		if (np->tx_skbuff_dma[entry]) {
-			pci_unmap_single(np->pdev,
-							 np->tx_skbuff_dma[entry],
-							 np->tx_skbuff[entry]->len, PCI_DMA_TODEVICE);
+		if (rp->tx_skbuff_dma[entry]) {
+			pci_unmap_single(rp->pdev,
+							 rp->tx_skbuff_dma[entry],
+							 rp->tx_skbuff[entry]->len, PCI_DMA_TODEVICE);
 		}
-		dev_kfree_skb_irq(np->tx_skbuff[entry]);
-		np->tx_skbuff[entry] = NULL;
-		entry = (++np->dirty_tx) % TX_RING_SIZE;
+		dev_kfree_skb_irq(rp->tx_skbuff[entry]);
+		rp->tx_skbuff[entry] = NULL;
+		entry = (++rp->dirty_tx) % TX_RING_SIZE;
 	}
-	if ((np->cur_tx - np->dirty_tx) < TX_QUEUE_LEN - 4)
+	if ((rp->cur_tx - rp->dirty_tx) < TX_QUEUE_LEN - 4)
 		netif_wake_queue (dev);
 
-	spin_unlock (&np->lock);
+	spin_unlock (&rp->lock);
 }
 
 /* This routine is logically part of the interrupt handler, but isolated
    for clarity and better register allocation. */
-static void via_rhine_rx(struct net_device *dev)
+static void rhine_rx(struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
-	int entry = np->cur_rx % RX_RING_SIZE;
-	int boguscnt = np->dirty_rx + RX_RING_SIZE - np->cur_rx;
+	struct rhine_private *rp = dev->priv;
+	int entry = rp->cur_rx % RX_RING_SIZE;
+	int boguscnt = rp->dirty_rx + RX_RING_SIZE - rp->cur_rx;
 
 	if (debug > 4) {
-		printk(KERN_DEBUG "%s: via_rhine_rx(), entry %d status %8.8x.\n",
-			   dev->name, entry, le32_to_cpu(np->rx_head_desc->rx_status));
+		printk(KERN_DEBUG "%s: rhine_rx(), entry %d status %8.8x.\n",
+			   dev->name, entry, le32_to_cpu(rp->rx_head_desc->rx_status));
 	}
 
 	/* If EOP is set on the next entry, it's a new packet. Send it up. */
-	while ( ! (np->rx_head_desc->rx_status & cpu_to_le32(DescOwn))) {
-		struct rx_desc *desc = np->rx_head_desc;
+	while ( ! (rp->rx_head_desc->rx_status & cpu_to_le32(DescOwn))) {
+		struct rx_desc *desc = rp->rx_head_desc;
 		u32 desc_status = le32_to_cpu(desc->rx_status);
 		int data_size = desc_status >> 16;
 
 		if (debug > 4)
-			printk(KERN_DEBUG "  via_rhine_rx() status is %8.8x.\n",
+			printk(KERN_DEBUG "  rhine_rx() status is %8.8x.\n",
 				   desc_status);
 		if (--boguscnt < 0)
 			break;
@@ -1509,22 +1509,22 @@ static void via_rhine_rx(struct net_devi
 					   "multiple buffers, entry %#x length %d status %8.8x!\n",
 					   dev->name, entry, data_size, desc_status);
 				printk(KERN_WARNING "%s: Oversized Ethernet frame %p vs %p.\n",
-					   dev->name, np->rx_head_desc, &np->rx_ring[entry]);
-				np->stats.rx_length_errors++;
+					   dev->name, rp->rx_head_desc, &rp->rx_ring[entry]);
+				rp->stats.rx_length_errors++;
 			} else if (desc_status & RxErr) {
 				/* There was a error. */
 				if (debug > 2)
-					printk(KERN_DEBUG "  via_rhine_rx() Rx error was %8.8x.\n",
+					printk(KERN_DEBUG "  rhine_rx() Rx error was %8.8x.\n",
 						   desc_status);
-				np->stats.rx_errors++;
-				if (desc_status & 0x0030) np->stats.rx_length_errors++;
-				if (desc_status & 0x0048) np->stats.rx_fifo_errors++;
-				if (desc_status & 0x0004) np->stats.rx_frame_errors++;
+				rp->stats.rx_errors++;
+				if (desc_status & 0x0030) rp->stats.rx_length_errors++;
+				if (desc_status & 0x0048) rp->stats.rx_fifo_errors++;
+				if (desc_status & 0x0004) rp->stats.rx_frame_errors++;
 				if (desc_status & 0x0002) {
 					/* this can also be updated outside the interrupt handler */
-					spin_lock (&np->lock);
-					np->stats.rx_crc_errors++;
-					spin_unlock (&np->lock);
+					spin_lock (&rp->lock);
+					rp->stats.rx_crc_errors++;
+					spin_unlock (&rp->lock);
 				}
 			}
 		} else {
@@ -1538,59 +1538,59 @@ static void via_rhine_rx(struct net_devi
 				(skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
 				skb->dev = dev;
 				skb_reserve(skb, 2);	/* 16 byte align the IP header */
-				pci_dma_sync_single_for_cpu(np->pdev, np->rx_skbuff_dma[entry],
-						    np->rx_buf_sz, PCI_DMA_FROMDEVICE);
+				pci_dma_sync_single_for_cpu(rp->pdev, rp->rx_skbuff_dma[entry],
+						    rp->rx_buf_sz, PCI_DMA_FROMDEVICE);
 
 				/* *_IP_COPYSUM isn't defined anywhere and eth_copy_and_sum
 				   is memcpy for all archs so this is kind of pointless right
 				   now ... or? */
 #if HAS_IP_COPYSUM                     /* Call copy + cksum if available. */
-				eth_copy_and_sum(skb, np->rx_skbuff[entry]->tail, pkt_len, 0);
+				eth_copy_and_sum(skb, rp->rx_skbuff[entry]->tail, pkt_len, 0);
 				skb_put(skb, pkt_len);
 #else
-				memcpy(skb_put(skb, pkt_len), np->rx_skbuff[entry]->tail,
+				memcpy(skb_put(skb, pkt_len), rp->rx_skbuff[entry]->tail,
 					   pkt_len);
 #endif
-				pci_dma_sync_single_for_device(np->pdev, np->rx_skbuff_dma[entry],
-						    np->rx_buf_sz, PCI_DMA_FROMDEVICE);
+				pci_dma_sync_single_for_device(rp->pdev, rp->rx_skbuff_dma[entry],
+						    rp->rx_buf_sz, PCI_DMA_FROMDEVICE);
 			} else {
-				skb = np->rx_skbuff[entry];
+				skb = rp->rx_skbuff[entry];
 				if (skb == NULL) {
 					printk(KERN_ERR "%s: Inconsistent Rx descriptor chain.\n",
 						   dev->name);
 					break;
 				}
-				np->rx_skbuff[entry] = NULL;
+				rp->rx_skbuff[entry] = NULL;
 				skb_put(skb, pkt_len);
-				pci_unmap_single(np->pdev, np->rx_skbuff_dma[entry],
-								 np->rx_buf_sz, PCI_DMA_FROMDEVICE);
+				pci_unmap_single(rp->pdev, rp->rx_skbuff_dma[entry],
+								 rp->rx_buf_sz, PCI_DMA_FROMDEVICE);
 			}
 			skb->protocol = eth_type_trans(skb, dev);
 			netif_rx(skb);
 			dev->last_rx = jiffies;
-			np->stats.rx_bytes += pkt_len;
-			np->stats.rx_packets++;
+			rp->stats.rx_bytes += pkt_len;
+			rp->stats.rx_packets++;
 		}
-		entry = (++np->cur_rx) % RX_RING_SIZE;
-		np->rx_head_desc = &np->rx_ring[entry];
+		entry = (++rp->cur_rx) % RX_RING_SIZE;
+		rp->rx_head_desc = &rp->rx_ring[entry];
 	}
 
 	/* Refill the Rx ring buffers. */
-	for (; np->cur_rx - np->dirty_rx > 0; np->dirty_rx++) {
+	for (; rp->cur_rx - rp->dirty_rx > 0; rp->dirty_rx++) {
 		struct sk_buff *skb;
-		entry = np->dirty_rx % RX_RING_SIZE;
-		if (np->rx_skbuff[entry] == NULL) {
-			skb = dev_alloc_skb(np->rx_buf_sz);
-			np->rx_skbuff[entry] = skb;
+		entry = rp->dirty_rx % RX_RING_SIZE;
+		if (rp->rx_skbuff[entry] == NULL) {
+			skb = dev_alloc_skb(rp->rx_buf_sz);
+			rp->rx_skbuff[entry] = skb;
 			if (skb == NULL)
 				break;			/* Better luck next round. */
 			skb->dev = dev;			/* Mark as being used by this device. */
-			np->rx_skbuff_dma[entry] =
-				pci_map_single(np->pdev, skb->tail, np->rx_buf_sz,
+			rp->rx_skbuff_dma[entry] =
+				pci_map_single(rp->pdev, skb->tail, rp->rx_buf_sz,
 							   PCI_DMA_FROMDEVICE);
-			np->rx_ring[entry].addr = cpu_to_le32(np->rx_skbuff_dma[entry]);
+			rp->rx_ring[entry].addr = cpu_to_le32(rp->rx_skbuff_dma[entry]);
 		}
-		np->rx_ring[entry].rx_status = cpu_to_le32(DescOwn);
+		rp->rx_ring[entry].rx_status = cpu_to_le32(DescOwn);
 	}
 
 	/* Pre-emptively restart Rx engine. */
@@ -1609,10 +1609,10 @@ static inline void clear_tally_counters(
 	readw(ioaddr + RxMissed);
 }
 
-static void via_rhine_restart_tx(struct net_device *dev) {
-	struct netdev_private *np = dev->priv;
+static void rhine_restart_tx(struct net_device *dev) {
+	struct rhine_private *rp = dev->priv;
 	long ioaddr = dev->base_addr;
-	int entry = np->dirty_tx % TX_RING_SIZE;
+	int entry = rp->dirty_tx % TX_RING_SIZE;
 	u32 intr_status;
 
 	/*
@@ -1624,45 +1624,45 @@ static void via_rhine_restart_tx(struct 
 	if ((intr_status & IntrTxErrSummary) == 0) {
 
 		/* We know better than the chip where it should continue. */
-		writel(np->tx_ring_dma + entry * sizeof(struct tx_desc),
+		writel(rp->tx_ring_dma + entry * sizeof(struct tx_desc),
 			   ioaddr + TxRingPtr);
 
-		writew(CmdTxDemand | np->chip_cmd, ioaddr + ChipCmd);
+		writew(CmdTxDemand | rp->chip_cmd, ioaddr + ChipCmd);
 		IOSYNC;
 	}
 	else {
 		/* This should never happen */
 		if (debug > 1)
-			printk(KERN_WARNING "%s: via_rhine_restart_tx() "
+			printk(KERN_WARNING "%s: rhine_restart_tx() "
 				   "Another error occured %8.8x.\n",
 				   dev->name, intr_status);
 	}
 
 }
 
-static void via_rhine_error(struct net_device *dev, int intr_status)
+static void rhine_error(struct net_device *dev, int intr_status)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	long ioaddr = dev->base_addr;
 
-	spin_lock (&np->lock);
+	spin_lock (&rp->lock);
 
 	if (intr_status & (IntrLinkChange)) {
 		if (readb(ioaddr + MIIStatus) & 0x02) {
 			/* Link failed, restart autonegotiation. */
-			if (np->drv_flags & HasDavicomPhy)
-				mdio_write(dev, np->phys[0], MII_BMCR, 0x3300);
+			if (rp->drv_flags & HasDavicomPhy)
+				mdio_write(dev, rp->phys[0], MII_BMCR, 0x3300);
 		} else
-			via_rhine_check_duplex(dev);
+			rhine_check_duplex(dev);
 		if (debug)
 			printk(KERN_ERR "%s: MII status changed: Autonegotiation "
 				   "advertising %4.4x  partner %4.4x.\n", dev->name,
-			   mdio_read(dev, np->phys[0], MII_ADVERTISE),
-			   mdio_read(dev, np->phys[0], MII_LPA));
+			   mdio_read(dev, rp->phys[0], MII_ADVERTISE),
+			   mdio_read(dev, rp->phys[0], MII_LPA));
 	}
 	if (intr_status & IntrStatsMax) {
-		np->stats.rx_crc_errors	+= readw(ioaddr + RxCRCErrs);
-		np->stats.rx_missed_errors	+= readw(ioaddr + RxMissed);
+		rp->stats.rx_crc_errors	+= readw(ioaddr + RxCRCErrs);
+		rp->stats.rx_missed_errors	+= readw(ioaddr + RxMissed);
 		clear_tally_counters(ioaddr);
 	}
 	if (intr_status & IntrTxAborted) {
@@ -1671,12 +1671,12 @@ static void via_rhine_error(struct net_d
 				   dev->name, intr_status);
 	}
 	if (intr_status & IntrTxUnderrun) {
-		if (np->tx_thresh < 0xE0)
-			writeb(np->tx_thresh += 0x20, ioaddr + TxConfig);
+		if (rp->tx_thresh < 0xE0)
+			writeb(rp->tx_thresh += 0x20, ioaddr + TxConfig);
 		if (debug > 1)
 			printk(KERN_INFO "%s: Transmitter underrun, Tx "
 				   "threshold now %2.2x.\n",
-				   dev->name, np->tx_thresh);
+				   dev->name, rp->tx_thresh);
 	}
 	if (intr_status & IntrTxDescRace) {
 		if (debug > 2)
@@ -1686,17 +1686,17 @@ static void via_rhine_error(struct net_d
 	if ((intr_status & IntrTxError) &&
 			(intr_status & ( IntrTxAborted |
 			IntrTxUnderrun | IntrTxDescRace )) == 0) {
-		if (np->tx_thresh < 0xE0) {
-			writeb(np->tx_thresh += 0x20, ioaddr + TxConfig);
+		if (rp->tx_thresh < 0xE0) {
+			writeb(rp->tx_thresh += 0x20, ioaddr + TxConfig);
 		}
 		if (debug > 1)
 			printk(KERN_INFO "%s: Unspecified error. Tx "
 				   "threshold now %2.2x.\n",
-				   dev->name, np->tx_thresh);
+				   dev->name, rp->tx_thresh);
 	}
 	if (intr_status & ( IntrTxAborted | IntrTxUnderrun | IntrTxDescRace |
 						IntrTxError ))
-		via_rhine_restart_tx(dev);
+		rhine_restart_tx(dev);
 
 	if (intr_status & ~( IntrLinkChange | IntrStatsMax | IntrTxUnderrun |
 						 IntrTxError | IntrTxAborted | IntrNormalSummary |
@@ -1706,27 +1706,27 @@ static void via_rhine_error(struct net_d
 				   dev->name, intr_status);
 	}
 
-	spin_unlock (&np->lock);
+	spin_unlock (&rp->lock);
 }
 
-static struct net_device_stats *via_rhine_get_stats(struct net_device *dev)
+static struct net_device_stats *rhine_get_stats(struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	long ioaddr = dev->base_addr;
 	unsigned long flags;
 
-	spin_lock_irqsave(&np->lock, flags);
-	np->stats.rx_crc_errors	+= readw(ioaddr + RxCRCErrs);
-	np->stats.rx_missed_errors	+= readw(ioaddr + RxMissed);
+	spin_lock_irqsave(&rp->lock, flags);
+	rp->stats.rx_crc_errors	+= readw(ioaddr + RxCRCErrs);
+	rp->stats.rx_missed_errors	+= readw(ioaddr + RxMissed);
 	clear_tally_counters(ioaddr);
-	spin_unlock_irqrestore(&np->lock, flags);
+	spin_unlock_irqrestore(&rp->lock, flags);
 
-	return &np->stats;
+	return &rp->stats;
 }
 
-static void via_rhine_set_rx_mode(struct net_device *dev)
+static void rhine_set_rx_mode(struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	long ioaddr = dev->base_addr;
 	u32 mc_filter[2];			/* Multicast hash filter */
 	u8 rx_mode;					/* Note: 0x02=accept runt, 0x01=accept errs */
@@ -1757,66 +1757,66 @@ static void via_rhine_set_rx_mode(struct
 		writel(mc_filter[1], ioaddr + MulticastFilter1);
 		rx_mode = 0x0C;
 	}
-	writeb(np->rx_thresh | rx_mode, ioaddr + RxConfig);
+	writeb(rp->rx_thresh | rx_mode, ioaddr + RxConfig);
 }
 
 static void netdev_get_drvinfo (struct net_device *dev, struct ethtool_drvinfo *info)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 
 	strcpy (info->driver, DRV_NAME);
 	strcpy (info->version, DRV_VERSION);
-	strcpy (info->bus_info, pci_name(np->pdev));
+	strcpy (info->bus_info, pci_name(rp->pdev));
 }
 
 static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	int rc;
 
-	if (!(np->drv_flags & CanHaveMII))
+	if (!(rp->drv_flags & CanHaveMII))
 		return -EINVAL;
 
-	spin_lock_irq(&np->lock);
-	rc = mii_ethtool_gset(&np->mii_if, cmd);
-	spin_unlock_irq(&np->lock);
+	spin_lock_irq(&rp->lock);
+	rc = mii_ethtool_gset(&rp->mii_if, cmd);
+	spin_unlock_irq(&rp->lock);
 
 	return rc;
 }
 
 static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	int rc;
 
-	if (!(np->drv_flags & CanHaveMII))
+	if (!(rp->drv_flags & CanHaveMII))
 		return -EINVAL;
 
-	spin_lock_irq(&np->lock);
-	rc = mii_ethtool_sset(&np->mii_if, cmd);
-	spin_unlock_irq(&np->lock);
+	spin_lock_irq(&rp->lock);
+	rc = mii_ethtool_sset(&rp->mii_if, cmd);
+	spin_unlock_irq(&rp->lock);
 
 	return rc;
 }
 
 static int netdev_nway_reset(struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 
-	if (!(np->drv_flags & CanHaveMII))
+	if (!(rp->drv_flags & CanHaveMII))
 		return -EINVAL;
 
-	return mii_nway_restart(&np->mii_if);
+	return mii_nway_restart(&rp->mii_if);
 }
 
 static u32 netdev_get_link(struct net_device *dev)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 
-	if (!(np->drv_flags & CanHaveMII))
+	if (!(rp->drv_flags & CanHaveMII))
 		return 0;	/* -EINVAL */
 
-	return mii_link_ok(&np->mii_if);
+	return mii_link_ok(&rp->mii_if);
 }
 
 static u32 netdev_get_msglevel(struct net_device *dev)
@@ -1843,28 +1843,28 @@ static struct ethtool_ops netdev_ethtool
 
 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
 {
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 	struct mii_ioctl_data *data = (struct mii_ioctl_data *) & rq->ifr_data;
 	int rc;
 
 	if (!netif_running(dev))
 		return -EINVAL;
 
-	spin_lock_irq(&np->lock);
-	rc = generic_mii_ioctl(&np->mii_if, data, cmd, NULL);
-	spin_unlock_irq(&np->lock);
+	spin_lock_irq(&rp->lock);
+	rc = generic_mii_ioctl(&rp->mii_if, data, cmd, NULL);
+	spin_unlock_irq(&rp->lock);
 
 	return rc;
 }
 
-static int via_rhine_close(struct net_device *dev)
+static int rhine_close(struct net_device *dev)
 {
 	long ioaddr = dev->base_addr;
-	struct netdev_private *np = dev->priv;
+	struct rhine_private *rp = dev->priv;
 
-	del_timer_sync(&np->timer);
+	del_timer_sync(&rp->timer);
 
-	spin_lock_irq(&np->lock);
+	spin_lock_irq(&rp->lock);
 
 	netif_stop_queue(dev);
 
@@ -1873,7 +1873,7 @@ static int via_rhine_close(struct net_de
 			   dev->name, readw(ioaddr + ChipCmd));
 
 	/* Switch to loopback mode to avoid hardware races. */
-	writeb(np->tx_thresh | 0x02, ioaddr + TxConfig);
+	writeb(rp->tx_thresh | 0x02, ioaddr + TxConfig);
 
 	/* Disable interrupts by clearing the interrupt mask. */
 	writew(0x0000, ioaddr + IntrEnable);
@@ -1881,9 +1881,9 @@ static int via_rhine_close(struct net_de
 	/* Stop the chip's Tx and Rx processes. */
 	writew(CmdStop, ioaddr + ChipCmd);
 
-	spin_unlock_irq(&np->lock);
+	spin_unlock_irq(&rp->lock);
 
-	free_irq(np->pdev->irq, dev);
+	free_irq(rp->pdev->irq, dev);
 	free_rbufs(dev);
 	free_tbufs(dev);
 	free_ring(dev);
@@ -1892,7 +1892,7 @@ static int via_rhine_close(struct net_de
 }
 
 
-static void __devexit via_rhine_remove_one (struct pci_dev *pdev)
+static void __devexit rhine_remove_one (struct pci_dev *pdev)
 {
 	struct net_device *dev = pci_get_drvdata(pdev);
 
@@ -1910,32 +1910,32 @@ static void __devexit via_rhine_remove_o
 }
 
 
-static struct pci_driver via_rhine_driver = {
+static struct pci_driver rhine_driver = {
 	.name		= "via-rhine",
-	.id_table	= via_rhine_pci_tbl,
-	.probe		= via_rhine_init_one,
-	.remove		= __devexit_p(via_rhine_remove_one),
+	.id_table	= rhine_pci_tbl,
+	.probe		= rhine_init_one,
+	.remove		= __devexit_p(rhine_remove_one),
 };
 
 
-static int __init via_rhine_init (void)
+static int __init rhine_init (void)
 {
 /* when a module, this is printed whether or not devices are found in probe */
 #ifdef MODULE
 	printk(version);
 #endif
-	return pci_module_init (&via_rhine_driver);
+	return pci_module_init (&rhine_driver);
 }
 
 
-static void __exit via_rhine_cleanup (void)
+static void __exit rhine_cleanup (void)
 {
-	pci_unregister_driver (&via_rhine_driver);
+	pci_unregister_driver (&rhine_driver);
 }
 
 
-module_init(via_rhine_init);
-module_exit(via_rhine_cleanup);
+module_init(rhine_init);
+module_exit(rhine_cleanup);
 
 
 /*

_
