[2/4][PATCH 2.6] via-rhine: Rename some symbols

From: Roger Luethi
Date: Sun May 23 2004 - 05:55:07 EST

This patch renames symbols:
via_rhine_* -> rhine_*
struct netdev_private *np -> struct rhine_private *rp
--- linux-2.6.6/drivers/net/via-rhine.c 2004-05-20 18:13:30.000000000 +0200
+++ linux-2.6.6-patch/drivers/net/via-rhine.c 2004-05-23 10:23:00.792437570 +0200
@@ -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);


/*