add NAPI support to sb1250-mac.c (693aa947) · Commits · jan.koester / Linux

drivers/net/sb1250-mac.c

+179 −92

Original line number	Original line	Diff line number	Diff line
	@@ -95,19 +95,28 @@ MODULE_PARM_DESC(full_duplex, "1-" __MODULE_STRING(MAX_UNITS));
	#endif		#endif

	#ifdef CONFIG_SBMAC_COALESCE		#ifdef CONFIG_SBMAC_COALESCE
	static int int_pktcnt = 0;		static int int_pktcnt_tx = 255;
	module_param(int_pktcnt, int, S_IRUGO);		module_param(int_pktcnt_tx, int, S_IRUGO);
	MODULE_PARM_DESC(int_pktcnt, "Packet count");		MODULE_PARM_DESC(int_pktcnt_tx, "TX packet count");

	static int int_timeout = 0;		static int int_timeout_tx = 255;
	module_param(int_timeout, int, S_IRUGO);		module_param(int_timeout_tx, int, S_IRUGO);
	MODULE_PARM_DESC(int_timeout, "Timeout value");		MODULE_PARM_DESC(int_timeout_tx, "TX timeout value");

			static int int_pktcnt_rx = 64;
			module_param(int_pktcnt_rx, int, S_IRUGO);
			MODULE_PARM_DESC(int_pktcnt_rx, "RX packet count");

			static int int_timeout_rx = 64;
			module_param(int_timeout_rx, int, S_IRUGO);
			MODULE_PARM_DESC(int_timeout_rx, "RX timeout value");
	#endif		#endif

	#include <asm/sibyte/sb1250.h>		#include <asm/sibyte/sb1250.h>
	#if defined(CONFIG_SIBYTE_BCM1x55) \|\| defined(CONFIG_SIBYTE_BCM1x80)		#if defined(CONFIG_SIBYTE_BCM1x55) \|\| defined(CONFIG_SIBYTE_BCM1x80)
	#include <asm/sibyte/bcm1480_regs.h>		#include <asm/sibyte/bcm1480_regs.h>
	#include <asm/sibyte/bcm1480_int.h>		#include <asm/sibyte/bcm1480_int.h>
			#define R_MAC_DMA_OODPKTLOST_RX R_MAC_DMA_OODPKTLOST
	#elif defined(CONFIG_SIBYTE_SB1250) \|\| defined(CONFIG_SIBYTE_BCM112X)		#elif defined(CONFIG_SIBYTE_SB1250) \|\| defined(CONFIG_SIBYTE_BCM112X)
	#include <asm/sibyte/sb1250_regs.h>		#include <asm/sibyte/sb1250_regs.h>
	#include <asm/sibyte/sb1250_int.h>		#include <asm/sibyte/sb1250_int.h>
	@@ -155,8 +164,8 @@ typedef enum { sbmac_state_uninit, sbmac_state_off, sbmac_state_on,

	#define NUMCACHEBLKS(x) (((x)+SMP_CACHE_BYTES-1)/SMP_CACHE_BYTES)		#define NUMCACHEBLKS(x) (((x)+SMP_CACHE_BYTES-1)/SMP_CACHE_BYTES)

	#define SBMAC_MAX_TXDESCR 32		#define SBMAC_MAX_TXDESCR 256
	#define SBMAC_MAX_RXDESCR 32		#define SBMAC_MAX_RXDESCR 256

	#define ETHER_ALIGN 2		#define ETHER_ALIGN 2
	#define ETHER_ADDR_LEN 6		#define ETHER_ADDR_LEN 6
	@@ -199,11 +208,14 @@ typedef struct sbmacdma_s {
	volatile void __iomem sbdma_dscrbase; / Descriptor base address */		volatile void __iomem sbdma_dscrbase; / Descriptor base address */
	volatile void __iomem sbdma_dscrcnt; / Descriptor count register */		volatile void __iomem sbdma_dscrcnt; / Descriptor count register */
	volatile void __iomem sbdma_curdscr; / current descriptor address */		volatile void __iomem sbdma_curdscr; / current descriptor address */
			volatile void __iomem sbdma_oodpktlost;/ pkt drop (rx only) */


	/*		/*
	* This stuff is for maintenance of the ring		* This stuff is for maintenance of the ring
	*/		*/

			sbdmadscr_t *sbdma_dscrtable_unaligned;
	sbdmadscr_t sbdma_dscrtable; / base of descriptor table */		sbdmadscr_t sbdma_dscrtable; / base of descriptor table */
	sbdmadscr_t sbdma_dscrtable_end; / end of descriptor table */		sbdmadscr_t sbdma_dscrtable_end; / end of descriptor table */

	@@ -286,8 +298,8 @@ static int sbdma_add_rcvbuffer(sbmacdma_t d,struct sk_buff m);
	static int sbdma_add_txbuffer(sbmacdma_t d,struct sk_buff m);		static int sbdma_add_txbuffer(sbmacdma_t d,struct sk_buff m);
	static void sbdma_emptyring(sbmacdma_t *d);		static void sbdma_emptyring(sbmacdma_t *d);
	static void sbdma_fillring(sbmacdma_t *d);		static void sbdma_fillring(sbmacdma_t *d);
	static void sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d);		static int sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d, int work_to_do, int poll);
	static void sbdma_tx_process(struct sbmac_softc sc,sbmacdma_t d);		static void sbdma_tx_process(struct sbmac_softc sc,sbmacdma_t d, int poll);
	static int sbmac_initctx(struct sbmac_softc *s);		static int sbmac_initctx(struct sbmac_softc *s);
	static void sbmac_channel_start(struct sbmac_softc *s);		static void sbmac_channel_start(struct sbmac_softc *s);
	static void sbmac_channel_stop(struct sbmac_softc *s);		static void sbmac_channel_stop(struct sbmac_softc *s);
	@@ -308,6 +320,8 @@ static struct net_device_stats sbmac_get_stats(struct net_device dev);
	static void sbmac_set_rx_mode(struct net_device *dev);		static void sbmac_set_rx_mode(struct net_device *dev);
	static int sbmac_mii_ioctl(struct net_device dev, struct ifreq rq, int cmd);		static int sbmac_mii_ioctl(struct net_device dev, struct ifreq rq, int cmd);
	static int sbmac_close(struct net_device *dev);		static int sbmac_close(struct net_device *dev);
			static int sbmac_poll(struct net_device poll_dev, int budget);

	static int sbmac_mii_poll(struct sbmac_softc *s,int noisy);		static int sbmac_mii_poll(struct sbmac_softc *s,int noisy);
	static int sbmac_mii_probe(struct net_device *dev);		static int sbmac_mii_probe(struct net_device *dev);

	@@ -679,6 +693,10 @@ static void sbdma_initctx(sbmacdma_t *d,
	int txrx,		int txrx,
	int maxdescr)		int maxdescr)
	{		{
			#ifdef CONFIG_SBMAC_COALESCE
			int int_pktcnt, int_timeout;
			#endif

	/*		/*
	* Save away interesting stuff in the structure		* Save away interesting stuff in the structure
	*/		*/
	@@ -728,6 +746,11 @@ static void sbdma_initctx(sbmacdma_t *d,
	s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_DSCR_CNT);		s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_DSCR_CNT);
	d->sbdma_curdscr =		d->sbdma_curdscr =
	s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_CUR_DSCRADDR);		s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_CUR_DSCRADDR);
			if (d->sbdma_txdir)
			d->sbdma_oodpktlost = NULL;
			else
			d->sbdma_oodpktlost =
			s->sbm_base + R_MAC_DMA_REGISTER(txrx,chan,R_MAC_DMA_OODPKTLOST_RX);

	/*		/*
	* Allocate memory for the ring		* Allocate memory for the ring
	@@ -735,6 +758,7 @@ static void sbdma_initctx(sbmacdma_t *d,

	d->sbdma_maxdescr = maxdescr;		d->sbdma_maxdescr = maxdescr;

			d->sbdma_dscrtable_unaligned =
	d->sbdma_dscrtable = (sbdmadscr_t *)		d->sbdma_dscrtable = (sbdmadscr_t *)
	kmalloc((d->sbdma_maxdescr+1)*sizeof(sbdmadscr_t), GFP_KERNEL);		kmalloc((d->sbdma_maxdescr+1)*sizeof(sbdmadscr_t), GFP_KERNEL);

	@@ -765,12 +789,14 @@ static void sbdma_initctx(sbmacdma_t *d,
	* Setup Rx/Tx DMA coalescing defaults		* Setup Rx/Tx DMA coalescing defaults
	*/		*/

			int_pktcnt = (txrx == DMA_TX) ? int_pktcnt_tx : int_pktcnt_rx;
	if ( int_pktcnt ) {		if ( int_pktcnt ) {
	d->sbdma_int_pktcnt = int_pktcnt;		d->sbdma_int_pktcnt = int_pktcnt;
	} else {		} else {
	d->sbdma_int_pktcnt = 1;		d->sbdma_int_pktcnt = 1;
	}		}

			int_timeout = (txrx == DMA_TX) ? int_timeout_tx : int_timeout_rx;
	if ( int_timeout ) {		if ( int_timeout ) {
	d->sbdma_int_timeout = int_timeout;		d->sbdma_int_timeout = int_timeout;
	} else {		} else {
	@@ -1147,30 +1173,41 @@ static void sbmac_netpoll(struct net_device *netdev)
	#endif		#endif

	/**********************************************************************		/**********************************************************************
	* SBDMA_RX_PROCESS(sc,d)		* SBDMA_RX_PROCESS(sc,d,work_to_do,poll)
	*		*
	* Process "completed" receive buffers on the specified DMA channel.		* Process "completed" receive buffers on the specified DMA channel.
	* Note that this isn't really ideal for priority channels, since
	* it processes all of the packets on a given channel before
	* returning.
	*		*
	* Input parameters:		* Input parameters:
	* sc - softc structure		* sc - softc structure
	* d - DMA channel context		* d - DMA channel context
			* work_to_do - no. of packets to process before enabling interrupt
			* again (for NAPI)
			* poll - 1: using polling (for NAPI)
	*		*
	* Return value:		* Return value:
	* nothing		* nothing
	********************************************************************* */		********************************************************************* */

	static void sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d)		static int sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d,
			int work_to_do, int poll)
	{		{
	int curidx;		int curidx;
	int hwidx;		int hwidx;
	sbdmadscr_t *dsc;		sbdmadscr_t *dsc;
	struct sk_buff *sb;		struct sk_buff *sb;
	int len;		int len;
			int work_done = 0;
			int dropped = 0;

	for (;;) {		prefetch(d);

			again:
			/* Check if the HW dropped any frames */
			sc->sbm_stats.rx_fifo_errors
			+= __raw_readq(sc->sbm_rxdma.sbdma_oodpktlost) & 0xffff;
			__raw_writeq(0, sc->sbm_rxdma.sbdma_oodpktlost);

			while (work_to_do-- > 0) {
	/*		/*
	* figure out where we are (as an index) and where		* figure out where we are (as an index) and where
	* the hardware is (also as an index)		* the hardware is (also as an index)
	@@ -1182,7 +1219,12 @@ static void sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d)
	* (sbdma_remptr) and the physical address (sbdma_curdscr CSR)		* (sbdma_remptr) and the physical address (sbdma_curdscr CSR)
	*/		*/

	curidx = d->sbdma_remptr - d->sbdma_dscrtable;		dsc = d->sbdma_remptr;
			curidx = dsc - d->sbdma_dscrtable;

			prefetch(dsc);
			prefetch(&d->sbdma_ctxtable[curidx]);

	hwidx = (int) (((__raw_readq(d->sbdma_curdscr) & M_DMA_CURDSCR_ADDR) -		hwidx = (int) (((__raw_readq(d->sbdma_curdscr) & M_DMA_CURDSCR_ADDR) -
	d->sbdma_dscrtable_phys) / sizeof(sbdmadscr_t));		d->sbdma_dscrtable_phys) / sizeof(sbdmadscr_t));

	@@ -1193,13 +1235,12 @@ static void sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d)
	*/		*/

	if (curidx == hwidx)		if (curidx == hwidx)
	break;		goto done;

	/*		/*
	* Otherwise, get the packet's sk_buff ptr back		* Otherwise, get the packet's sk_buff ptr back
	*/		*/

	dsc = &(d->sbdma_dscrtable[curidx]);
	sb = d->sbdma_ctxtable[curidx];		sb = d->sbdma_ctxtable[curidx];
	d->sbdma_ctxtable[curidx] = NULL;		d->sbdma_ctxtable[curidx] = NULL;

	@@ -1211,7 +1252,7 @@ static void sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d)
	* receive ring.		* receive ring.
	*/		*/

	if (!(dsc->dscr_a & M_DMA_ETHRX_BAD)) {		if (likely (!(dsc->dscr_a & M_DMA_ETHRX_BAD))) {

	/*		/*
	* Add a new buffer to replace the old one. If we fail		* Add a new buffer to replace the old one. If we fail
	@@ -1219,9 +1260,14 @@ static void sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d)
	* packet and put it right back on the receive ring.		* packet and put it right back on the receive ring.
	*/		*/

	if (sbdma_add_rcvbuffer(d,NULL) == -ENOBUFS) {		if (unlikely (sbdma_add_rcvbuffer(d,NULL) ==
			-ENOBUFS)) {
	sc->sbm_stats.rx_dropped++;		sc->sbm_stats.rx_dropped++;
	sbdma_add_rcvbuffer(d,sb); /* re-add old buffer */		sbdma_add_rcvbuffer(d,sb); /* re-add old buffer */
			/* No point in continuing at the moment */
			printk(KERN_ERR "dropped packet (1)\n");
			d->sbdma_remptr = SBDMA_NEXTBUF(d,sbdma_remptr);
			goto done;
	} else {		} else {
	/*		/*
	* Set length into the packet		* Set length into the packet
	@@ -1233,8 +1279,6 @@ static void sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d)
	* receive ring. Pass the buffer to		* receive ring. Pass the buffer to
	* the kernel		* the kernel
	*/		*/
	sc->sbm_stats.rx_bytes += len;
	sc->sbm_stats.rx_packets++;
	sb->protocol = eth_type_trans(sb,d->sbdma_eth->sbm_dev);		sb->protocol = eth_type_trans(sb,d->sbdma_eth->sbm_dev);
	/* Check hw IPv4/TCP checksum if supported */		/* Check hw IPv4/TCP checksum if supported */
	if (sc->rx_hw_checksum == ENABLE) {		if (sc->rx_hw_checksum == ENABLE) {
	@@ -1246,8 +1290,22 @@ static void sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d)
	sb->ip_summed = CHECKSUM_NONE;		sb->ip_summed = CHECKSUM_NONE;
	}		}
	}		}
			prefetch(sb->data);
			prefetch((const void )(((char )sb->data)+32));
			if (poll)
			dropped = netif_receive_skb(sb);
			else
			dropped = netif_rx(sb);

	netif_rx(sb);		if (dropped == NET_RX_DROP) {
			sc->sbm_stats.rx_dropped++;
			d->sbdma_remptr = SBDMA_NEXTBUF(d,sbdma_remptr);
			goto done;
			}
			else {
			sc->sbm_stats.rx_bytes += len;
			sc->sbm_stats.rx_packets++;
			}
	}		}
	} else {		} else {
	/*		/*
	@@ -1264,11 +1322,15 @@ static void sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d)
	*/		*/

	d->sbdma_remptr = SBDMA_NEXTBUF(d,sbdma_remptr);		d->sbdma_remptr = SBDMA_NEXTBUF(d,sbdma_remptr);
			work_done++;
	}		}
			if (!poll) {
			work_to_do = 32;
			goto again; /* collect fifo drop statistics again */
			}
			done:
			return work_done;
	}		}



	/**********************************************************************		/**********************************************************************
	* SBDMA_TX_PROCESS(sc,d)		* SBDMA_TX_PROCESS(sc,d)
	@@ -1282,21 +1344,29 @@ static void sbdma_rx_process(struct sbmac_softc sc,sbmacdma_t d)
	* Input parameters:		* Input parameters:
	* sc - softc structure		* sc - softc structure
	* d - DMA channel context		* d - DMA channel context
			* poll - 1: using polling (for NAPI)
	*		*
	* Return value:		* Return value:
	* nothing		* nothing
	********************************************************************* */		********************************************************************* */

	static void sbdma_tx_process(struct sbmac_softc sc,sbmacdma_t d)		static void sbdma_tx_process(struct sbmac_softc sc,sbmacdma_t d, int poll)
	{		{
	int curidx;		int curidx;
	int hwidx;		int hwidx;
	sbdmadscr_t *dsc;		sbdmadscr_t *dsc;
	struct sk_buff *sb;		struct sk_buff *sb;
	unsigned long flags;		unsigned long flags;
			int packets_handled = 0;

	spin_lock_irqsave(&(sc->sbm_lock), flags);		spin_lock_irqsave(&(sc->sbm_lock), flags);

			if (d->sbdma_remptr == d->sbdma_addptr)
			goto end_unlock;

			hwidx = (int) (((__raw_readq(d->sbdma_curdscr) & M_DMA_CURDSCR_ADDR) -
			d->sbdma_dscrtable_phys) / sizeof(sbdmadscr_t));

	for (;;) {		for (;;) {
	/*		/*
	* figure out where we are (as an index) and where		* figure out where we are (as an index) and where
	@@ -1310,8 +1380,6 @@ static void sbdma_tx_process(struct sbmac_softc sc,sbmacdma_t d)
	*/		*/

	curidx = d->sbdma_remptr - d->sbdma_dscrtable;		curidx = d->sbdma_remptr - d->sbdma_dscrtable;
	hwidx = (int) (((__raw_readq(d->sbdma_curdscr) & M_DMA_CURDSCR_ADDR) -
	d->sbdma_dscrtable_phys) / sizeof(sbdmadscr_t));

	/*		/*
	* If they're the same, that means we've processed all		* If they're the same, that means we've processed all
	@@ -1349,6 +1417,8 @@ static void sbdma_tx_process(struct sbmac_softc sc,sbmacdma_t d)

	d->sbdma_remptr = SBDMA_NEXTBUF(d,sbdma_remptr);		d->sbdma_remptr = SBDMA_NEXTBUF(d,sbdma_remptr);

			packets_handled++;

	}		}

	/*		/*
	@@ -1357,8 +1427,10 @@ static void sbdma_tx_process(struct sbmac_softc sc,sbmacdma_t d)
	* watermark on the transmit queue.		* watermark on the transmit queue.
	*/		*/

			if (packets_handled)
	netif_wake_queue(d->sbdma_eth->sbm_dev);		netif_wake_queue(d->sbdma_eth->sbm_dev);

			end_unlock:
	spin_unlock_irqrestore(&(sc->sbm_lock), flags);		spin_unlock_irqrestore(&(sc->sbm_lock), flags);

	}		}
	@@ -1432,9 +1504,9 @@ static int sbmac_initctx(struct sbmac_softc *s)

	static void sbdma_uninitctx(struct sbmacdma_s *d)		static void sbdma_uninitctx(struct sbmacdma_s *d)
	{		{
	if (d->sbdma_dscrtable) {		if (d->sbdma_dscrtable_unaligned) {
	kfree(d->sbdma_dscrtable);		kfree(d->sbdma_dscrtable_unaligned);
	d->sbdma_dscrtable = NULL;		d->sbdma_dscrtable_unaligned = d->sbdma_dscrtable = NULL;
	}		}

	if (d->sbdma_ctxtable) {		if (d->sbdma_ctxtable) {
	@@ -1632,15 +1704,9 @@ static void sbmac_channel_start(struct sbmac_softc *s)
	#endif		#endif

	#ifdef CONFIG_SBMAC_COALESCE		#ifdef CONFIG_SBMAC_COALESCE
	/*
	* Accept any TX interrupt and EOP count/timer RX interrupts on ch 0
	*/
	__raw_writeq(((M_MAC_INT_EOP_COUNT \| M_MAC_INT_EOP_TIMER) << S_MAC_TX_CH0) \|		__raw_writeq(((M_MAC_INT_EOP_COUNT \| M_MAC_INT_EOP_TIMER) << S_MAC_TX_CH0) \|
	((M_MAC_INT_EOP_COUNT \| M_MAC_INT_EOP_TIMER) << S_MAC_RX_CH0), s->sbm_imr);		((M_MAC_INT_EOP_COUNT \| M_MAC_INT_EOP_TIMER) << S_MAC_RX_CH0), s->sbm_imr);
	#else		#else
	/*
	* Accept any kind of interrupt on TX and RX DMA channel 0
	*/
	__raw_writeq((M_MAC_INT_CHANNEL << S_MAC_TX_CH0) \|		__raw_writeq((M_MAC_INT_CHANNEL << S_MAC_TX_CH0) \|
	(M_MAC_INT_CHANNEL << S_MAC_RX_CH0), s->sbm_imr);		(M_MAC_INT_CHANNEL << S_MAC_RX_CH0), s->sbm_imr);
	#endif		#endif
	@@ -2073,8 +2139,6 @@ static irqreturn_t sbmac_intr(int irq,void *dev_instance)
	uint64_t isr;		uint64_t isr;
	int handled = 0;		int handled = 0;

	for (;;) {

	/*		/*
	* Read the ISR (this clears the bits in the real		* Read the ISR (this clears the bits in the real
	* register, except for counter addr)		* register, except for counter addr)
	@@ -2083,8 +2147,7 @@ static irqreturn_t sbmac_intr(int irq,void *dev_instance)
	isr = __raw_readq(sc->sbm_isr) & ~M_MAC_COUNTER_ADDR;		isr = __raw_readq(sc->sbm_isr) & ~M_MAC_COUNTER_ADDR;

	if (isr == 0)		if (isr == 0)
	break;		return IRQ_RETVAL(0);

	handled = 1;		handled = 1;

	/*		/*
	@@ -2092,38 +2155,30 @@ static irqreturn_t sbmac_intr(int irq,void *dev_instance)
	*/		*/

	if (isr & (M_MAC_INT_CHANNEL << S_MAC_TX_CH0)) {		if (isr & (M_MAC_INT_CHANNEL << S_MAC_TX_CH0)) {
	sbdma_tx_process(sc,&(sc->sbm_txdma));		sbdma_tx_process(sc,&(sc->sbm_txdma), 0);
			#ifdef CONFIG_NETPOLL_TRAP
			if (netpoll_trap()) {
			if (test_and_clear_bit(__LINK_STATE_XOFF, &dev->state))
			__netif_schedule(dev);
			}
			#endif
	}		}

	/*
	* Receives on channel 0
	*/

	/*
	* It's important to test all the bits (or at least the
	* EOP_SEEN bit) when deciding to do the RX process
	* particularly when coalescing, to make sure we
	* take care of the following:
	*
	* If you have some packets waiting (have been received
	* but no interrupt) and get a TX interrupt before
	* the RX timer or counter expires, reading the ISR
	* above will clear the timer and counter, and you
	* won't get another interrupt until a packet shows
	* up to start the timer again. Testing
	* EOP_SEEN here takes care of this case.
	* (EOP_SEEN is part of M_MAC_INT_CHANNEL << S_MAC_RX_CH0)
	*/


	if (isr & (M_MAC_INT_CHANNEL << S_MAC_RX_CH0)) {		if (isr & (M_MAC_INT_CHANNEL << S_MAC_RX_CH0)) {
	sbdma_rx_process(sc,&(sc->sbm_rxdma));		if (netif_rx_schedule_prep(dev)) {
			__raw_writeq(0, sc->sbm_imr);
			__netif_rx_schedule(dev);
			/* Depend on the exit from poll to reenable intr */
			}
			else {
			/* may leave some packets behind */
			sbdma_rx_process(sc,&(sc->sbm_rxdma),
			SBMAC_MAX_RXDESCR * 2, 0);
	}		}
	}		}
	return IRQ_RETVAL(handled);		return IRQ_RETVAL(handled);
	}		}


	/**********************************************************************		/**********************************************************************
	* SBMAC_START_TX(skb,dev)		* SBMAC_START_TX(skb,dev)
	*		*
	@@ -2253,8 +2308,6 @@ static void sbmac_setmulti(struct sbmac_softc *sc)
	}		}
	}		}



	#if defined(SBMAC_ETH0_HWADDR) \|\| defined(SBMAC_ETH1_HWADDR) \|\| defined(SBMAC_ETH2_HWADDR) \|\| defined(SBMAC_ETH3_HWADDR)		#if defined(SBMAC_ETH0_HWADDR) \|\| defined(SBMAC_ETH1_HWADDR) \|\| defined(SBMAC_ETH2_HWADDR) \|\| defined(SBMAC_ETH3_HWADDR)
	/**********************************************************************		/**********************************************************************
	* SBMAC_PARSE_XDIGIT(str)		* SBMAC_PARSE_XDIGIT(str)
	@@ -2417,6 +2470,8 @@ static int sbmac_init(struct net_device *dev, int idx)
	dev->do_ioctl = sbmac_mii_ioctl;		dev->do_ioctl = sbmac_mii_ioctl;
	dev->tx_timeout = sbmac_tx_timeout;		dev->tx_timeout = sbmac_tx_timeout;
	dev->watchdog_timeo = TX_TIMEOUT;		dev->watchdog_timeo = TX_TIMEOUT;
			dev->poll = sbmac_poll;
			dev->weight = 16;

	dev->change_mtu = sb1250_change_mtu;		dev->change_mtu = sb1250_change_mtu;
	#ifdef CONFIG_NET_POLL_CONTROLLER		#ifdef CONFIG_NET_POLL_CONTROLLER
	@@ -2819,7 +2874,39 @@ static int sbmac_close(struct net_device *dev)
	return 0;		return 0;
	}		}

			static int sbmac_poll(struct net_device dev, int budget)
			{
			int work_to_do;
			int work_done;
			struct sbmac_softc *sc = netdev_priv(dev);

			work_to_do = min(*budget, dev->quota);
			work_done = sbdma_rx_process(sc, &(sc->sbm_rxdma), work_to_do, 1);

			if (work_done > work_to_do)
			printk(KERN_ERR "%s exceeded work_to_do budget=%d quota=%d work-done=%d\n",
			sc->sbm_dev->name, *budget, dev->quota, work_done);

			sbdma_tx_process(sc, &(sc->sbm_txdma), 1);

			*budget -= work_done;
			dev->quota -= work_done;

			if (work_done < work_to_do) {
			netif_rx_complete(dev);

			#ifdef CONFIG_SBMAC_COALESCE
			__raw_writeq(((M_MAC_INT_EOP_COUNT \| M_MAC_INT_EOP_TIMER) << S_MAC_TX_CH0) \|
			((M_MAC_INT_EOP_COUNT \| M_MAC_INT_EOP_TIMER) << S_MAC_RX_CH0),
			sc->sbm_imr);
			#else
			__raw_writeq((M_MAC_INT_CHANNEL << S_MAC_TX_CH0) \|
			(M_MAC_INT_CHANNEL << S_MAC_RX_CH0), sc->sbm_imr);
			#endif
			}

			return (work_done >= work_to_do);
			}

	#if defined(SBMAC_ETH0_HWADDR) \|\| defined(SBMAC_ETH1_HWADDR) \|\| defined(SBMAC_ETH2_HWADDR) \|\| defined(SBMAC_ETH3_HWADDR)		#if defined(SBMAC_ETH0_HWADDR) \|\| defined(SBMAC_ETH1_HWADDR) \|\| defined(SBMAC_ETH2_HWADDR) \|\| defined(SBMAC_ETH3_HWADDR)
	static void		static void
	@@ -2906,7 +2993,7 @@ sbmac_init_module(void)

	/*		/*
	* The R_MAC_ETHERNET_ADDR register will be set to some nonzero		* The R_MAC_ETHERNET_ADDR register will be set to some nonzero
	* value for us by the firmware if we're going to use this MAC.		* value for us by the firmware if we are going to use this MAC.
	* If we find a zero, skip this MAC.		* If we find a zero, skip this MAC.
	*/		*/