pcnet32: constify function table (1d70cb06) · Commits · e / devices / android_kernel_oneplus_sm8150

drivers/net/ethernet/amd/pcnet32.c

+101 −101

Original line number	Original line	Diff line number	Diff line
	@@ -270,7 +270,7 @@ struct pcnet32_private {
	struct sk_buff **rx_skbuff;		struct sk_buff **rx_skbuff;
	dma_addr_t *tx_dma_addr;		dma_addr_t *tx_dma_addr;
	dma_addr_t *rx_dma_addr;		dma_addr_t *rx_dma_addr;
	struct pcnet32_access a;		const struct pcnet32_access *a;
	spinlock_t lock; /* Guard lock */		spinlock_t lock; /* Guard lock */
	unsigned int cur_rx, cur_tx; /* The next free ring entry */		unsigned int cur_rx, cur_tx; /* The next free ring entry */
	unsigned int rx_ring_size; /* current rx ring size */		unsigned int rx_ring_size; /* current rx ring size */
	@@ -379,7 +379,7 @@ static int pcnet32_wio_check(unsigned long addr)
	return inw(addr + PCNET32_WIO_RAP) == 88;		return inw(addr + PCNET32_WIO_RAP) == 88;
	}		}

	static struct pcnet32_access pcnet32_wio = {		static const struct pcnet32_access pcnet32_wio = {
	.read_csr = pcnet32_wio_read_csr,		.read_csr = pcnet32_wio_read_csr,
	.write_csr = pcnet32_wio_write_csr,		.write_csr = pcnet32_wio_write_csr,
	.read_bcr = pcnet32_wio_read_bcr,		.read_bcr = pcnet32_wio_read_bcr,
	@@ -434,7 +434,7 @@ static int pcnet32_dwio_check(unsigned long addr)
	return (inl(addr + PCNET32_DWIO_RAP) & 0xffff) == 88;		return (inl(addr + PCNET32_DWIO_RAP) & 0xffff) == 88;
	}		}

	static struct pcnet32_access pcnet32_dwio = {		static const struct pcnet32_access pcnet32_dwio = {
	.read_csr = pcnet32_dwio_read_csr,		.read_csr = pcnet32_dwio_read_csr,
	.write_csr = pcnet32_dwio_write_csr,		.write_csr = pcnet32_dwio_write_csr,
	.read_bcr = pcnet32_dwio_read_bcr,		.read_bcr = pcnet32_dwio_read_bcr,
	@@ -460,9 +460,9 @@ static void pcnet32_netif_start(struct net_device *dev)
	u16 val;		u16 val;

	netif_wake_queue(dev);		netif_wake_queue(dev);
	val = lp->a.read_csr(ioaddr, CSR3);		val = lp->a->read_csr(ioaddr, CSR3);
	val &= 0x00ff;		val &= 0x00ff;
	lp->a.write_csr(ioaddr, CSR3, val);		lp->a->write_csr(ioaddr, CSR3, val);
	napi_enable(&lp->napi);		napi_enable(&lp->napi);
	}		}

	@@ -730,7 +730,7 @@ static u32 pcnet32_get_link(struct net_device *dev)
	r = mii_link_ok(&lp->mii_if);		r = mii_link_ok(&lp->mii_if);
	} else if (lp->chip_version >= PCNET32_79C970A) {		} else if (lp->chip_version >= PCNET32_79C970A) {
	ulong ioaddr = dev->base_addr; /* card base I/O address */		ulong ioaddr = dev->base_addr; /* card base I/O address */
	r = (lp->a.read_bcr(ioaddr, 4) != 0xc0);		r = (lp->a->read_bcr(ioaddr, 4) != 0xc0);
	} else { /* can not detect link on really old chips */		} else { /* can not detect link on really old chips */
	r = 1;		r = 1;
	}		}
	@@ -792,7 +792,7 @@ static int pcnet32_set_ringparam(struct net_device *dev,
	pcnet32_netif_stop(dev);		pcnet32_netif_stop(dev);

	spin_lock_irqsave(&lp->lock, flags);		spin_lock_irqsave(&lp->lock, flags);
	lp->a.write_csr(ioaddr, CSR0, CSR0_STOP); /* stop the chip */		lp->a->write_csr(ioaddr, CSR0, CSR0_STOP); /* stop the chip */

	size = min(ering->tx_pending, (unsigned int)TX_MAX_RING_SIZE);		size = min(ering->tx_pending, (unsigned int)TX_MAX_RING_SIZE);

	@@ -868,7 +868,7 @@ static void pcnet32_ethtool_test(struct net_device *dev,
	static int pcnet32_loopback_test(struct net_device dev, uint64_t data1)		static int pcnet32_loopback_test(struct net_device dev, uint64_t data1)
	{		{
	struct pcnet32_private *lp = netdev_priv(dev);		struct pcnet32_private *lp = netdev_priv(dev);
	struct pcnet32_access a = &lp->a; / access to registers */		const struct pcnet32_access a = lp->a; / access to registers */
	ulong ioaddr = dev->base_addr; /* card base I/O address */		ulong ioaddr = dev->base_addr; /* card base I/O address */
	struct sk_buff skb; / sk buff */		struct sk_buff skb; / sk buff */
	int x, i; /* counters */		int x, i; /* counters */
	@@ -888,21 +888,21 @@ static int pcnet32_loopback_test(struct net_device dev, uint64_t data1)
	pcnet32_netif_stop(dev);		pcnet32_netif_stop(dev);

	spin_lock_irqsave(&lp->lock, flags);		spin_lock_irqsave(&lp->lock, flags);
	lp->a.write_csr(ioaddr, CSR0, CSR0_STOP); /* stop the chip */		lp->a->write_csr(ioaddr, CSR0, CSR0_STOP); /* stop the chip */

	numbuffs = min(numbuffs, (int)min(lp->rx_ring_size, lp->tx_ring_size));		numbuffs = min(numbuffs, (int)min(lp->rx_ring_size, lp->tx_ring_size));

	/* Reset the PCNET32 */		/* Reset the PCNET32 */
	lp->a.reset(ioaddr);		lp->a->reset(ioaddr);
	lp->a.write_csr(ioaddr, CSR4, 0x0915); /* auto tx pad */		lp->a->write_csr(ioaddr, CSR4, 0x0915); /* auto tx pad */

	/* switch pcnet32 to 32bit mode */		/* switch pcnet32 to 32bit mode */
	lp->a.write_bcr(ioaddr, 20, 2);		lp->a->write_bcr(ioaddr, 20, 2);

	/* purge & init rings but don't actually restart */		/* purge & init rings but don't actually restart */
	pcnet32_restart(dev, 0x0000);		pcnet32_restart(dev, 0x0000);

	lp->a.write_csr(ioaddr, CSR0, CSR0_STOP); /* Set STOP bit */		lp->a->write_csr(ioaddr, CSR0, CSR0_STOP); /* Set STOP bit */

	/* Initialize Transmit buffers. */		/* Initialize Transmit buffers. */
	size = data_len + 15;		size = data_len + 15;
	@@ -947,10 +947,10 @@ static int pcnet32_loopback_test(struct net_device dev, uint64_t data1)

	/* set int loopback in CSR15 */		/* set int loopback in CSR15 */
	x = a->read_csr(ioaddr, CSR15) & 0xfffc;		x = a->read_csr(ioaddr, CSR15) & 0xfffc;
	lp->a.write_csr(ioaddr, CSR15, x \| 0x0044);		lp->a->write_csr(ioaddr, CSR15, x \| 0x0044);

	teststatus = cpu_to_le16(0x8000);		teststatus = cpu_to_le16(0x8000);
	lp->a.write_csr(ioaddr, CSR0, CSR0_START); /* Set STRT bit */		lp->a->write_csr(ioaddr, CSR0, CSR0_START); /* Set STRT bit */

	/* Check status of descriptors */		/* Check status of descriptors */
	for (x = 0; x < numbuffs; x++) {		for (x = 0; x < numbuffs; x++) {
	@@ -969,7 +969,7 @@ static int pcnet32_loopback_test(struct net_device dev, uint64_t data1)
	}		}
	}		}

	lp->a.write_csr(ioaddr, CSR0, CSR0_STOP); /* Set STOP bit */		lp->a->write_csr(ioaddr, CSR0, CSR0_STOP); /* Set STOP bit */
	wmb();		wmb();
	if (netif_msg_hw(lp) && netif_msg_pktdata(lp)) {		if (netif_msg_hw(lp) && netif_msg_pktdata(lp)) {
	netdev_printk(KERN_DEBUG, dev, "RX loopback packets:\n");		netdev_printk(KERN_DEBUG, dev, "RX loopback packets:\n");
	@@ -1015,7 +1015,7 @@ static int pcnet32_loopback_test(struct net_device dev, uint64_t data1)
	pcnet32_restart(dev, CSR0_NORMAL);		pcnet32_restart(dev, CSR0_NORMAL);
	} else {		} else {
	pcnet32_purge_rx_ring(dev);		pcnet32_purge_rx_ring(dev);
	lp->a.write_bcr(ioaddr, 20, 4); /* return to 16bit mode */		lp->a->write_bcr(ioaddr, 20, 4); /* return to 16bit mode */
	}		}
	spin_unlock_irqrestore(&lp->lock, flags);		spin_unlock_irqrestore(&lp->lock, flags);

	@@ -1026,7 +1026,7 @@ static int pcnet32_set_phys_id(struct net_device *dev,
	enum ethtool_phys_id_state state)		enum ethtool_phys_id_state state)
	{		{
	struct pcnet32_private *lp = netdev_priv(dev);		struct pcnet32_private *lp = netdev_priv(dev);
	struct pcnet32_access *a = &lp->a;		const struct pcnet32_access *a = lp->a;
	ulong ioaddr = dev->base_addr;		ulong ioaddr = dev->base_addr;
	unsigned long flags;		unsigned long flags;
	int i;		int i;
	@@ -1067,7 +1067,7 @@ static int pcnet32_suspend(struct net_device dev, unsigned long flags,
	{		{
	int csr5;		int csr5;
	struct pcnet32_private *lp = netdev_priv(dev);		struct pcnet32_private *lp = netdev_priv(dev);
	struct pcnet32_access *a = &lp->a;		const struct pcnet32_access *a = lp->a;
	ulong ioaddr = dev->base_addr;		ulong ioaddr = dev->base_addr;
	int ticks;		int ticks;

	@@ -1324,8 +1324,8 @@ static int pcnet32_poll(struct napi_struct *napi, int budget)
	spin_lock_irqsave(&lp->lock, flags);		spin_lock_irqsave(&lp->lock, flags);
	if (pcnet32_tx(dev)) {		if (pcnet32_tx(dev)) {
	/* reset the chip to clear the error condition, then restart */		/* reset the chip to clear the error condition, then restart */
	lp->a.reset(ioaddr);		lp->a->reset(ioaddr);
	lp->a.write_csr(ioaddr, CSR4, 0x0915); /* auto tx pad */		lp->a->write_csr(ioaddr, CSR4, 0x0915); /* auto tx pad */
	pcnet32_restart(dev, CSR0_START);		pcnet32_restart(dev, CSR0_START);
	netif_wake_queue(dev);		netif_wake_queue(dev);
	}		}
	@@ -1337,12 +1337,12 @@ static int pcnet32_poll(struct napi_struct *napi, int budget)
	__napi_complete(napi);		__napi_complete(napi);

	/* clear interrupt masks */		/* clear interrupt masks */
	val = lp->a.read_csr(ioaddr, CSR3);		val = lp->a->read_csr(ioaddr, CSR3);
	val &= 0x00ff;		val &= 0x00ff;
	lp->a.write_csr(ioaddr, CSR3, val);		lp->a->write_csr(ioaddr, CSR3, val);

	/* Set interrupt enable. */		/* Set interrupt enable. */
	lp->a.write_csr(ioaddr, CSR0, CSR0_INTEN);		lp->a->write_csr(ioaddr, CSR0, CSR0_INTEN);

	spin_unlock_irqrestore(&lp->lock, flags);		spin_unlock_irqrestore(&lp->lock, flags);
	}		}
	@@ -1365,7 +1365,7 @@ static void pcnet32_get_regs(struct net_device dev, struct ethtool_regs regs,
	int i, csr0;		int i, csr0;
	u16 *buff = ptr;		u16 *buff = ptr;
	struct pcnet32_private *lp = netdev_priv(dev);		struct pcnet32_private *lp = netdev_priv(dev);
	struct pcnet32_access *a = &lp->a;		const struct pcnet32_access *a = lp->a;
	ulong ioaddr = dev->base_addr;		ulong ioaddr = dev->base_addr;
	unsigned long flags;		unsigned long flags;

	@@ -1401,9 +1401,9 @@ static void pcnet32_get_regs(struct net_device dev, struct ethtool_regs regs,
	for (j = 0; j < PCNET32_MAX_PHYS; j++) {		for (j = 0; j < PCNET32_MAX_PHYS; j++) {
	if (lp->phymask & (1 << j)) {		if (lp->phymask & (1 << j)) {
	for (i = 0; i < PCNET32_REGS_PER_PHY; i++) {		for (i = 0; i < PCNET32_REGS_PER_PHY; i++) {
	lp->a.write_bcr(ioaddr, 33,		lp->a->write_bcr(ioaddr, 33,
	(j << 5) \| i);		(j << 5) \| i);
	*buff++ = lp->a.read_bcr(ioaddr, 34);		*buff++ = lp->a->read_bcr(ioaddr, 34);
	}		}
	}		}
	}		}
	@@ -1528,7 +1528,7 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
	int chip_version;		int chip_version;
	char *chipname;		char *chipname;
	struct net_device *dev;		struct net_device *dev;
	struct pcnet32_access *a = NULL;		const struct pcnet32_access *a = NULL;
	u8 promaddr[6];		u8 promaddr[6];
	int ret = -ENODEV;		int ret = -ENODEV;

	@@ -1785,7 +1785,7 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
	((cards_found >= MAX_UNITS) \|\| full_duplex[cards_found]))		((cards_found >= MAX_UNITS) \|\| full_duplex[cards_found]))
	lp->options \|= PCNET32_PORT_FD;		lp->options \|= PCNET32_PORT_FD;

	lp->a = *a;		lp->a = a;

	/* prior to register_netdev, dev->name is not yet correct */		/* prior to register_netdev, dev->name is not yet correct */
	if (pcnet32_alloc_ring(dev, pci_name(lp->pci_dev))) {		if (pcnet32_alloc_ring(dev, pci_name(lp->pci_dev))) {
	@@ -1844,7 +1844,7 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
	if (lp->mii) {		if (lp->mii) {
	/* lp->phycount and lp->phymask are set to 0 by memset above */		/* lp->phycount and lp->phymask are set to 0 by memset above */

	lp->mii_if.phy_id = ((lp->a.read_bcr(ioaddr, 33)) >> 5) & 0x1f;		lp->mii_if.phy_id = ((lp->a->read_bcr(ioaddr, 33)) >> 5) & 0x1f;
	/* scan for PHYs */		/* scan for PHYs */
	for (i = 0; i < PCNET32_MAX_PHYS; i++) {		for (i = 0; i < PCNET32_MAX_PHYS; i++) {
	unsigned short id1, id2;		unsigned short id1, id2;
	@@ -1864,7 +1864,7 @@ pcnet32_probe1(unsigned long ioaddr, int shared, struct pci_dev *pdev)
	pr_info("Found PHY %04x:%04x at address %d\n",		pr_info("Found PHY %04x:%04x at address %d\n",
	id1, id2, i);		id1, id2, i);
	}		}
	lp->a.write_bcr(ioaddr, 33, (lp->mii_if.phy_id) << 5);		lp->a->write_bcr(ioaddr, 33, (lp->mii_if.phy_id) << 5);
	if (lp->phycount > 1)		if (lp->phycount > 1)
	lp->options \|= PCNET32_PORT_MII;		lp->options \|= PCNET32_PORT_MII;
	}		}
	@@ -2020,10 +2020,10 @@ static int pcnet32_open(struct net_device *dev)
	}		}

	/* Reset the PCNET32 */		/* Reset the PCNET32 */
	lp->a.reset(ioaddr);		lp->a->reset(ioaddr);

	/* switch pcnet32 to 32bit mode */		/* switch pcnet32 to 32bit mode */
	lp->a.write_bcr(ioaddr, 20, 2);		lp->a->write_bcr(ioaddr, 20, 2);

	netif_printk(lp, ifup, KERN_DEBUG, dev,		netif_printk(lp, ifup, KERN_DEBUG, dev,
	"%s() irq %d tx/rx rings %#x/%#x init %#x\n",		"%s() irq %d tx/rx rings %#x/%#x init %#x\n",
	@@ -2032,14 +2032,14 @@ static int pcnet32_open(struct net_device *dev)
	(u32) (lp->init_dma_addr));		(u32) (lp->init_dma_addr));

	/* set/reset autoselect bit */		/* set/reset autoselect bit */
	val = lp->a.read_bcr(ioaddr, 2) & ~2;		val = lp->a->read_bcr(ioaddr, 2) & ~2;
	if (lp->options & PCNET32_PORT_ASEL)		if (lp->options & PCNET32_PORT_ASEL)
	val \|= 2;		val \|= 2;
	lp->a.write_bcr(ioaddr, 2, val);		lp->a->write_bcr(ioaddr, 2, val);

	/* handle full duplex setting */		/* handle full duplex setting */
	if (lp->mii_if.full_duplex) {		if (lp->mii_if.full_duplex) {
	val = lp->a.read_bcr(ioaddr, 9) & ~3;		val = lp->a->read_bcr(ioaddr, 9) & ~3;
	if (lp->options & PCNET32_PORT_FD) {		if (lp->options & PCNET32_PORT_FD) {
	val \|= 1;		val \|= 1;
	if (lp->options == (PCNET32_PORT_FD \| PCNET32_PORT_AUI))		if (lp->options == (PCNET32_PORT_FD \| PCNET32_PORT_AUI))
	@@ -2049,14 +2049,14 @@ static int pcnet32_open(struct net_device *dev)
	if (lp->chip_version == 0x2627)		if (lp->chip_version == 0x2627)
	val \|= 3;		val \|= 3;
	}		}
	lp->a.write_bcr(ioaddr, 9, val);		lp->a->write_bcr(ioaddr, 9, val);
	}		}

	/* set/reset GPSI bit in test register */		/* set/reset GPSI bit in test register */
	val = lp->a.read_csr(ioaddr, 124) & ~0x10;		val = lp->a->read_csr(ioaddr, 124) & ~0x10;
	if ((lp->options & PCNET32_PORT_PORTSEL) == PCNET32_PORT_GPSI)		if ((lp->options & PCNET32_PORT_PORTSEL) == PCNET32_PORT_GPSI)
	val \|= 0x10;		val \|= 0x10;
	lp->a.write_csr(ioaddr, 124, val);		lp->a->write_csr(ioaddr, 124, val);

	/* Allied Telesyn AT 2700/2701 FX are 100Mbit only and do not negotiate */		/* Allied Telesyn AT 2700/2701 FX are 100Mbit only and do not negotiate */
	if (pdev && pdev->subsystem_vendor == PCI_VENDOR_ID_AT &&		if (pdev && pdev->subsystem_vendor == PCI_VENDOR_ID_AT &&
	@@ -2075,24 +2075,24 @@ static int pcnet32_open(struct net_device *dev)
	* duplex, and/or enable auto negotiation, and clear DANAS		* duplex, and/or enable auto negotiation, and clear DANAS
	*/		*/
	if (lp->mii && !(lp->options & PCNET32_PORT_ASEL)) {		if (lp->mii && !(lp->options & PCNET32_PORT_ASEL)) {
	lp->a.write_bcr(ioaddr, 32,		lp->a->write_bcr(ioaddr, 32,
	lp->a.read_bcr(ioaddr, 32) \| 0x0080);		lp->a->read_bcr(ioaddr, 32) \| 0x0080);
	/* disable Auto Negotiation, set 10Mpbs, HD */		/* disable Auto Negotiation, set 10Mpbs, HD */
	val = lp->a.read_bcr(ioaddr, 32) & ~0xb8;		val = lp->a->read_bcr(ioaddr, 32) & ~0xb8;
	if (lp->options & PCNET32_PORT_FD)		if (lp->options & PCNET32_PORT_FD)
	val \|= 0x10;		val \|= 0x10;
	if (lp->options & PCNET32_PORT_100)		if (lp->options & PCNET32_PORT_100)
	val \|= 0x08;		val \|= 0x08;
	lp->a.write_bcr(ioaddr, 32, val);		lp->a->write_bcr(ioaddr, 32, val);
	} else {		} else {
	if (lp->options & PCNET32_PORT_ASEL) {		if (lp->options & PCNET32_PORT_ASEL) {
	lp->a.write_bcr(ioaddr, 32,		lp->a->write_bcr(ioaddr, 32,
	lp->a.read_bcr(ioaddr,		lp->a->read_bcr(ioaddr,
	32) \| 0x0080);		32) \| 0x0080);
	/* enable auto negotiate, setup, disable fd */		/* enable auto negotiate, setup, disable fd */
	val = lp->a.read_bcr(ioaddr, 32) & ~0x98;		val = lp->a->read_bcr(ioaddr, 32) & ~0x98;
	val \|= 0x20;		val \|= 0x20;
	lp->a.write_bcr(ioaddr, 32, val);		lp->a->write_bcr(ioaddr, 32, val);
	}		}
	}		}
	} else {		} else {
	@@ -2105,10 +2105,10 @@ static int pcnet32_open(struct net_device *dev)
	* There is really no good other way to handle multiple PHYs		* There is really no good other way to handle multiple PHYs
	* other than turning off all automatics		* other than turning off all automatics
	*/		*/
	val = lp->a.read_bcr(ioaddr, 2);		val = lp->a->read_bcr(ioaddr, 2);
	lp->a.write_bcr(ioaddr, 2, val & ~2);		lp->a->write_bcr(ioaddr, 2, val & ~2);
	val = lp->a.read_bcr(ioaddr, 32);		val = lp->a->read_bcr(ioaddr, 32);
	lp->a.write_bcr(ioaddr, 32, val & ~(1 << 7)); /* stop MII manager */		lp->a->write_bcr(ioaddr, 32, val & ~(1 << 7)); /* stop MII manager */

	if (!(lp->options & PCNET32_PORT_ASEL)) {		if (!(lp->options & PCNET32_PORT_ASEL)) {
	/* setup ecmd */		/* setup ecmd */
	@@ -2118,7 +2118,7 @@ static int pcnet32_open(struct net_device *dev)
	ethtool_cmd_speed_set(&ecmd,		ethtool_cmd_speed_set(&ecmd,
	(lp->options & PCNET32_PORT_100) ?		(lp->options & PCNET32_PORT_100) ?
	SPEED_100 : SPEED_10);		SPEED_100 : SPEED_10);
	bcr9 = lp->a.read_bcr(ioaddr, 9);		bcr9 = lp->a->read_bcr(ioaddr, 9);

	if (lp->options & PCNET32_PORT_FD) {		if (lp->options & PCNET32_PORT_FD) {
	ecmd.duplex = DUPLEX_FULL;		ecmd.duplex = DUPLEX_FULL;
	@@ -2127,7 +2127,7 @@ static int pcnet32_open(struct net_device *dev)
	ecmd.duplex = DUPLEX_HALF;		ecmd.duplex = DUPLEX_HALF;
	bcr9 \|= ~(1 << 0);		bcr9 \|= ~(1 << 0);
	}		}
	lp->a.write_bcr(ioaddr, 9, bcr9);		lp->a->write_bcr(ioaddr, 9, bcr9);
	}		}

	for (i = 0; i < PCNET32_MAX_PHYS; i++) {		for (i = 0; i < PCNET32_MAX_PHYS; i++) {
	@@ -2158,9 +2158,9 @@ static int pcnet32_open(struct net_device *dev)

	#ifdef DO_DXSUFLO		#ifdef DO_DXSUFLO
	if (lp->dxsuflo) { /* Disable transmit stop on underflow */		if (lp->dxsuflo) { /* Disable transmit stop on underflow */
	val = lp->a.read_csr(ioaddr, CSR3);		val = lp->a->read_csr(ioaddr, CSR3);
	val \|= 0x40;		val \|= 0x40;
	lp->a.write_csr(ioaddr, CSR3, val);		lp->a->write_csr(ioaddr, CSR3, val);
	}		}
	#endif		#endif

	@@ -2176,11 +2176,11 @@ static int pcnet32_open(struct net_device *dev)
	napi_enable(&lp->napi);		napi_enable(&lp->napi);

	/* Re-initialize the PCNET32, and start it when done. */		/* Re-initialize the PCNET32, and start it when done. */
	lp->a.write_csr(ioaddr, 1, (lp->init_dma_addr & 0xffff));		lp->a->write_csr(ioaddr, 1, (lp->init_dma_addr & 0xffff));
	lp->a.write_csr(ioaddr, 2, (lp->init_dma_addr >> 16));		lp->a->write_csr(ioaddr, 2, (lp->init_dma_addr >> 16));

	lp->a.write_csr(ioaddr, CSR4, 0x0915); /* auto tx pad */		lp->a->write_csr(ioaddr, CSR4, 0x0915); /* auto tx pad */
	lp->a.write_csr(ioaddr, CSR0, CSR0_INIT);		lp->a->write_csr(ioaddr, CSR0, CSR0_INIT);

	netif_start_queue(dev);		netif_start_queue(dev);

	@@ -2192,19 +2192,19 @@ static int pcnet32_open(struct net_device *dev)

	i = 0;		i = 0;
	while (i++ < 100)		while (i++ < 100)
	if (lp->a.read_csr(ioaddr, CSR0) & CSR0_IDON)		if (lp->a->read_csr(ioaddr, CSR0) & CSR0_IDON)
	break;		break;
	/*		/*
	* We used to clear the InitDone bit, 0x0100, here but Mark Stockton		* We used to clear the InitDone bit, 0x0100, here but Mark Stockton
	* reports that doing so triggers a bug in the '974.		* reports that doing so triggers a bug in the '974.
	*/		*/
	lp->a.write_csr(ioaddr, CSR0, CSR0_NORMAL);		lp->a->write_csr(ioaddr, CSR0, CSR0_NORMAL);

	netif_printk(lp, ifup, KERN_DEBUG, dev,		netif_printk(lp, ifup, KERN_DEBUG, dev,
	"pcnet32 open after %d ticks, init block %#x csr0 %4.4x\n",		"pcnet32 open after %d ticks, init block %#x csr0 %4.4x\n",
	i,		i,
	(u32) (lp->init_dma_addr),		(u32) (lp->init_dma_addr),
	lp->a.read_csr(ioaddr, CSR0));		lp->a->read_csr(ioaddr, CSR0));

	spin_unlock_irqrestore(&lp->lock, flags);		spin_unlock_irqrestore(&lp->lock, flags);

	@@ -2218,7 +2218,7 @@ static int pcnet32_open(struct net_device *dev)
	* Switch back to 16bit mode to avoid problems with dumb		* Switch back to 16bit mode to avoid problems with dumb
	* DOS packet driver after a warm reboot		* DOS packet driver after a warm reboot
	*/		*/
	lp->a.write_bcr(ioaddr, 20, 4);		lp->a->write_bcr(ioaddr, 20, 4);

	err_free_irq:		err_free_irq:
	spin_unlock_irqrestore(&lp->lock, flags);		spin_unlock_irqrestore(&lp->lock, flags);
	@@ -2323,7 +2323,7 @@ static void pcnet32_restart(struct net_device *dev, unsigned int csr0_bits)

	/* wait for stop */		/* wait for stop */
	for (i = 0; i < 100; i++)		for (i = 0; i < 100; i++)
	if (lp->a.read_csr(ioaddr, CSR0) & CSR0_STOP)		if (lp->a->read_csr(ioaddr, CSR0) & CSR0_STOP)
	break;		break;

	if (i >= 100)		if (i >= 100)
	@@ -2335,13 +2335,13 @@ static void pcnet32_restart(struct net_device *dev, unsigned int csr0_bits)
	return;		return;

	/* ReInit Ring */		/* ReInit Ring */
	lp->a.write_csr(ioaddr, CSR0, CSR0_INIT);		lp->a->write_csr(ioaddr, CSR0, CSR0_INIT);
	i = 0;		i = 0;
	while (i++ < 1000)		while (i++ < 1000)
	if (lp->a.read_csr(ioaddr, CSR0) & CSR0_IDON)		if (lp->a->read_csr(ioaddr, CSR0) & CSR0_IDON)
	break;		break;

	lp->a.write_csr(ioaddr, CSR0, csr0_bits);		lp->a->write_csr(ioaddr, CSR0, csr0_bits);
	}		}

	static void pcnet32_tx_timeout(struct net_device *dev)		static void pcnet32_tx_timeout(struct net_device *dev)
	@@ -2353,8 +2353,8 @@ static void pcnet32_tx_timeout(struct net_device *dev)
	/* Transmitter timeout, serious problems. */		/* Transmitter timeout, serious problems. */
	if (pcnet32_debug & NETIF_MSG_DRV)		if (pcnet32_debug & NETIF_MSG_DRV)
	pr_err("%s: transmit timed out, status %4.4x, resetting\n",		pr_err("%s: transmit timed out, status %4.4x, resetting\n",
	dev->name, lp->a.read_csr(ioaddr, CSR0));		dev->name, lp->a->read_csr(ioaddr, CSR0));
	lp->a.write_csr(ioaddr, CSR0, CSR0_STOP);		lp->a->write_csr(ioaddr, CSR0, CSR0_STOP);
	dev->stats.tx_errors++;		dev->stats.tx_errors++;
	if (netif_msg_tx_err(lp)) {		if (netif_msg_tx_err(lp)) {
	int i;		int i;
	@@ -2397,7 +2397,7 @@ static netdev_tx_t pcnet32_start_xmit(struct sk_buff *skb,

	netif_printk(lp, tx_queued, KERN_DEBUG, dev,		netif_printk(lp, tx_queued, KERN_DEBUG, dev,
	"%s() called, csr0 %4.4x\n",		"%s() called, csr0 %4.4x\n",
	__func__, lp->a.read_csr(ioaddr, CSR0));		__func__, lp->a->read_csr(ioaddr, CSR0));

	/* Default status -- will not enable Successful-TxDone		/* Default status -- will not enable Successful-TxDone
	* interrupt when that option is available to us.		* interrupt when that option is available to us.
	@@ -2427,7 +2427,7 @@ static netdev_tx_t pcnet32_start_xmit(struct sk_buff *skb,
	dev->stats.tx_bytes += skb->len;		dev->stats.tx_bytes += skb->len;

	/* Trigger an immediate send poll. */		/* Trigger an immediate send poll. */
	lp->a.write_csr(ioaddr, CSR0, CSR0_INTEN \| CSR0_TXPOLL);		lp->a->write_csr(ioaddr, CSR0, CSR0_INTEN \| CSR0_TXPOLL);

	if (lp->tx_ring[(entry + 1) & lp->tx_mod_mask].base != 0) {		if (lp->tx_ring[(entry + 1) & lp->tx_mod_mask].base != 0) {
	lp->tx_full = 1;		lp->tx_full = 1;
	@@ -2452,16 +2452,16 @@ pcnet32_interrupt(int irq, void *dev_id)

	spin_lock(&lp->lock);		spin_lock(&lp->lock);

	csr0 = lp->a.read_csr(ioaddr, CSR0);		csr0 = lp->a->read_csr(ioaddr, CSR0);
	while ((csr0 & 0x8f00) && --boguscnt >= 0) {		while ((csr0 & 0x8f00) && --boguscnt >= 0) {
	if (csr0 == 0xffff)		if (csr0 == 0xffff)
	break; /* PCMCIA remove happened */		break; /* PCMCIA remove happened */
	/* Acknowledge all of the current interrupt sources ASAP. */		/* Acknowledge all of the current interrupt sources ASAP. */
	lp->a.write_csr(ioaddr, CSR0, csr0 & ~0x004f);		lp->a->write_csr(ioaddr, CSR0, csr0 & ~0x004f);

	netif_printk(lp, intr, KERN_DEBUG, dev,		netif_printk(lp, intr, KERN_DEBUG, dev,
	"interrupt csr0=%#2.2x new csr=%#2.2x\n",		"interrupt csr0=%#2.2x new csr=%#2.2x\n",
	csr0, lp->a.read_csr(ioaddr, CSR0));		csr0, lp->a->read_csr(ioaddr, CSR0));

	/* Log misc errors. */		/* Log misc errors. */
	if (csr0 & 0x4000)		if (csr0 & 0x4000)
	@@ -2488,19 +2488,19 @@ pcnet32_interrupt(int irq, void *dev_id)
	if (napi_schedule_prep(&lp->napi)) {		if (napi_schedule_prep(&lp->napi)) {
	u16 val;		u16 val;
	/* set interrupt masks */		/* set interrupt masks */
	val = lp->a.read_csr(ioaddr, CSR3);		val = lp->a->read_csr(ioaddr, CSR3);
	val \|= 0x5f00;		val \|= 0x5f00;
	lp->a.write_csr(ioaddr, CSR3, val);		lp->a->write_csr(ioaddr, CSR3, val);

	__napi_schedule(&lp->napi);		__napi_schedule(&lp->napi);
	break;		break;
	}		}
	csr0 = lp->a.read_csr(ioaddr, CSR0);		csr0 = lp->a->read_csr(ioaddr, CSR0);
	}		}

	netif_printk(lp, intr, KERN_DEBUG, dev,		netif_printk(lp, intr, KERN_DEBUG, dev,
	"exiting interrupt, csr0=%#4.4x\n",		"exiting interrupt, csr0=%#4.4x\n",
	lp->a.read_csr(ioaddr, CSR0));		lp->a->read_csr(ioaddr, CSR0));

	spin_unlock(&lp->lock);		spin_unlock(&lp->lock);

	@@ -2520,20 +2520,20 @@ static int pcnet32_close(struct net_device *dev)

	spin_lock_irqsave(&lp->lock, flags);		spin_lock_irqsave(&lp->lock, flags);

	dev->stats.rx_missed_errors = lp->a.read_csr(ioaddr, 112);		dev->stats.rx_missed_errors = lp->a->read_csr(ioaddr, 112);

	netif_printk(lp, ifdown, KERN_DEBUG, dev,		netif_printk(lp, ifdown, KERN_DEBUG, dev,
	"Shutting down ethercard, status was %2.2x\n",		"Shutting down ethercard, status was %2.2x\n",
	lp->a.read_csr(ioaddr, CSR0));		lp->a->read_csr(ioaddr, CSR0));

	/* We stop the PCNET32 here -- it occasionally polls memory if we don't. */		/* We stop the PCNET32 here -- it occasionally polls memory if we don't. */
	lp->a.write_csr(ioaddr, CSR0, CSR0_STOP);		lp->a->write_csr(ioaddr, CSR0, CSR0_STOP);

	/*		/*
	* Switch back to 16bit mode to avoid problems with dumb		* Switch back to 16bit mode to avoid problems with dumb
	* DOS packet driver after a warm reboot		* DOS packet driver after a warm reboot
	*/		*/
	lp->a.write_bcr(ioaddr, 20, 4);		lp->a->write_bcr(ioaddr, 20, 4);

	spin_unlock_irqrestore(&lp->lock, flags);		spin_unlock_irqrestore(&lp->lock, flags);

	@@ -2556,7 +2556,7 @@ static struct net_device_stats pcnet32_get_stats(struct net_device dev)
	unsigned long flags;		unsigned long flags;

	spin_lock_irqsave(&lp->lock, flags);		spin_lock_irqsave(&lp->lock, flags);
	dev->stats.rx_missed_errors = lp->a.read_csr(ioaddr, 112);		dev->stats.rx_missed_errors = lp->a->read_csr(ioaddr, 112);
	spin_unlock_irqrestore(&lp->lock, flags);		spin_unlock_irqrestore(&lp->lock, flags);

	return &dev->stats;		return &dev->stats;
	@@ -2577,10 +2577,10 @@ static void pcnet32_load_multicast(struct net_device *dev)
	if (dev->flags & IFF_ALLMULTI) {		if (dev->flags & IFF_ALLMULTI) {
	ib->filter[0] = cpu_to_le32(~0U);		ib->filter[0] = cpu_to_le32(~0U);
	ib->filter[1] = cpu_to_le32(~0U);		ib->filter[1] = cpu_to_le32(~0U);
	lp->a.write_csr(ioaddr, PCNET32_MC_FILTER, 0xffff);		lp->a->write_csr(ioaddr, PCNET32_MC_FILTER, 0xffff);
	lp->a.write_csr(ioaddr, PCNET32_MC_FILTER+1, 0xffff);		lp->a->write_csr(ioaddr, PCNET32_MC_FILTER+1, 0xffff);
	lp->a.write_csr(ioaddr, PCNET32_MC_FILTER+2, 0xffff);		lp->a->write_csr(ioaddr, PCNET32_MC_FILTER+2, 0xffff);
	lp->a.write_csr(ioaddr, PCNET32_MC_FILTER+3, 0xffff);		lp->a->write_csr(ioaddr, PCNET32_MC_FILTER+3, 0xffff);
	return;		return;
	}		}
	/* clear the multicast filter */		/* clear the multicast filter */
	@@ -2594,7 +2594,7 @@ static void pcnet32_load_multicast(struct net_device *dev)
	mcast_table[crc >> 4] \|= cpu_to_le16(1 << (crc & 0xf));		mcast_table[crc >> 4] \|= cpu_to_le16(1 << (crc & 0xf));
	}		}
	for (i = 0; i < 4; i++)		for (i = 0; i < 4; i++)
	lp->a.write_csr(ioaddr, PCNET32_MC_FILTER + i,		lp->a->write_csr(ioaddr, PCNET32_MC_FILTER + i,
	le16_to_cpu(mcast_table[i]));		le16_to_cpu(mcast_table[i]));
	}		}

	@@ -2609,28 +2609,28 @@ static void pcnet32_set_multicast_list(struct net_device *dev)

	spin_lock_irqsave(&lp->lock, flags);		spin_lock_irqsave(&lp->lock, flags);
	suspended = pcnet32_suspend(dev, &flags, 0);		suspended = pcnet32_suspend(dev, &flags, 0);
	csr15 = lp->a.read_csr(ioaddr, CSR15);		csr15 = lp->a->read_csr(ioaddr, CSR15);
	if (dev->flags & IFF_PROMISC) {		if (dev->flags & IFF_PROMISC) {
	/* Log any net taps. */		/* Log any net taps. */
	netif_info(lp, hw, dev, "Promiscuous mode enabled\n");		netif_info(lp, hw, dev, "Promiscuous mode enabled\n");
	lp->init_block->mode =		lp->init_block->mode =
	cpu_to_le16(0x8000 \| (lp->options & PCNET32_PORT_PORTSEL) <<		cpu_to_le16(0x8000 \| (lp->options & PCNET32_PORT_PORTSEL) <<
	7);		7);
	lp->a.write_csr(ioaddr, CSR15, csr15 \| 0x8000);		lp->a->write_csr(ioaddr, CSR15, csr15 \| 0x8000);
	} else {		} else {
	lp->init_block->mode =		lp->init_block->mode =
	cpu_to_le16((lp->options & PCNET32_PORT_PORTSEL) << 7);		cpu_to_le16((lp->options & PCNET32_PORT_PORTSEL) << 7);
	lp->a.write_csr(ioaddr, CSR15, csr15 & 0x7fff);		lp->a->write_csr(ioaddr, CSR15, csr15 & 0x7fff);
	pcnet32_load_multicast(dev);		pcnet32_load_multicast(dev);
	}		}

	if (suspended) {		if (suspended) {
	int csr5;		int csr5;
	/* clear SUSPEND (SPND) - CSR5 bit 0 */		/* clear SUSPEND (SPND) - CSR5 bit 0 */
	csr5 = lp->a.read_csr(ioaddr, CSR5);		csr5 = lp->a->read_csr(ioaddr, CSR5);
	lp->a.write_csr(ioaddr, CSR5, csr5 & (~CSR5_SUSPEND));		lp->a->write_csr(ioaddr, CSR5, csr5 & (~CSR5_SUSPEND));
	} else {		} else {
	lp->a.write_csr(ioaddr, CSR0, CSR0_STOP);		lp->a->write_csr(ioaddr, CSR0, CSR0_STOP);
	pcnet32_restart(dev, CSR0_NORMAL);		pcnet32_restart(dev, CSR0_NORMAL);
	netif_wake_queue(dev);		netif_wake_queue(dev);
	}		}
	@@ -2648,8 +2648,8 @@ static int mdio_read(struct net_device *dev, int phy_id, int reg_num)
	if (!lp->mii)		if (!lp->mii)
	return 0;		return 0;

	lp->a.write_bcr(ioaddr, 33, ((phy_id & 0x1f) << 5) \| (reg_num & 0x1f));		lp->a->write_bcr(ioaddr, 33, ((phy_id & 0x1f) << 5) \| (reg_num & 0x1f));
	val_out = lp->a.read_bcr(ioaddr, 34);		val_out = lp->a->read_bcr(ioaddr, 34);

	return val_out;		return val_out;
	}		}
	@@ -2663,8 +2663,8 @@ static void mdio_write(struct net_device *dev, int phy_id, int reg_num, int val)
	if (!lp->mii)		if (!lp->mii)
	return;		return;

	lp->a.write_bcr(ioaddr, 33, ((phy_id & 0x1f) << 5) \| (reg_num & 0x1f));		lp->a->write_bcr(ioaddr, 33, ((phy_id & 0x1f) << 5) \| (reg_num & 0x1f));
	lp->a.write_bcr(ioaddr, 34, val);		lp->a->write_bcr(ioaddr, 34, val);
	}		}

	static int pcnet32_ioctl(struct net_device dev, struct ifreq rq, int cmd)		static int pcnet32_ioctl(struct net_device dev, struct ifreq rq, int cmd)
	@@ -2741,7 +2741,7 @@ static void pcnet32_check_media(struct net_device *dev, int verbose)
	curr_link = mii_link_ok(&lp->mii_if);		curr_link = mii_link_ok(&lp->mii_if);
	} else {		} else {
	ulong ioaddr = dev->base_addr; /* card base I/O address */		ulong ioaddr = dev->base_addr; /* card base I/O address */
	curr_link = (lp->a.read_bcr(ioaddr, 4) != 0xc0);		curr_link = (lp->a->read_bcr(ioaddr, 4) != 0xc0);
	}		}
	if (!curr_link) {		if (!curr_link) {
	if (prev_link \|\| verbose) {		if (prev_link \|\| verbose) {
	@@ -2764,13 +2764,13 @@ static void pcnet32_check_media(struct net_device *dev, int verbose)
	(ecmd.duplex == DUPLEX_FULL)		(ecmd.duplex == DUPLEX_FULL)
	? "full" : "half");		? "full" : "half");
	}		}
	bcr9 = lp->a.read_bcr(dev->base_addr, 9);		bcr9 = lp->a->read_bcr(dev->base_addr, 9);
	if ((bcr9 & (1 << 0)) != lp->mii_if.full_duplex) {		if ((bcr9 & (1 << 0)) != lp->mii_if.full_duplex) {
	if (lp->mii_if.full_duplex)		if (lp->mii_if.full_duplex)
	bcr9 \|= (1 << 0);		bcr9 \|= (1 << 0);
	else		else
	bcr9 &= ~(1 << 0);		bcr9 &= ~(1 << 0);
	lp->a.write_bcr(dev->base_addr, 9, bcr9);		lp->a->write_bcr(dev->base_addr, 9, bcr9);
	}		}
	} else {		} else {
	netif_info(lp, link, dev, "link up\n");		netif_info(lp, link, dev, "link up\n");