dev->poll should be set in the dev->probe() method. 

e.g:

dev->open = my_open;

.

.

/* two new additions */

/* first register my poll method */

dev->poll = my_poll;

/* next register my weight/quanta; can be overriden in /proc */

dev->weight = 16;

.

.

dev->stop = my_close;

----------------------------------------------------------------------


static void

netdevice_interrupt(int irq, void *dev_id, struct pt_regs *regs)

{


	struct net_device *dev = (struct net_device *)dev_instance;

	struct my_private *tp = (struct my_private *)dev->priv;


	int work_count = my_work_count;

        status = read_interrupt_status_reg();

        if (status == 0)

                return;         /* Shared IRQ: not us */

        if (status == 0xffff)

                return;         /* Hot unplug */

        if (status & error)

		do_some_error_handling()

        

	do {

		acknowledge_ints_ASAP();


		if (status & link_interrupt) {

			spin_lock(&tp->link_lock);

			do_some_link_stat_stuff();

			spin_lock(&tp->link_lock);

		}

		

		if (status & rx_interrupt) {

			receive_packets(dev);

		}


		if (status & rx_nobufs) {

			make_rx_buffs_avail();

		}

			

		if (status & tx_related) {

			spin_lock(&tp->lock);

			tx_ring_free(dev);

			if (tx_died)

				restart_tx();

			spin_unlock(&tp->lock);

		}


		status = read_interrupt_status_reg();


	} while (!(status & error) || more_work_to_be_done);


}


----------------------------------------------------------------------

----------------------------------------------------------------------

static void

netdevice_interrupt(int irq, void *dev_id, struct pt_regs *regs)

{

	struct net_device *dev = (struct net_device *)dev_instance;

	struct my_private *tp = (struct my_private *)dev->priv;


        status = read_interrupt_status_reg();

        if (status == 0)

                return;         /* Shared IRQ: not us */

        if (status == 0xffff)

                return;         /* Hot unplug */

        if (status & error)

		do_some_error_handling();

        

	do {

/************************ start note *********************************/		

		acknowledge_ints_ASAP();  // dont ack rx and rxnobuff here

/************************ end note *********************************/		


		if (status & link_interrupt) {

			spin_lock(&tp->link_lock);

			do_some_link_stat_stuff();

			spin_unlock(&tp->link_lock);

		}

/************************ start note *********************************/		

		if (status & rx_interrupt || (status & rx_nobuffs)) {

			if (netif_rx_schedule_prep(dev)) {


				/* disable interrupts caused 

			         *	by arriving packets */

				disable_rx_and_rxnobuff_ints();

				/* tell system we have work to be done. */

				__netif_rx_schedule(dev);

			} else {

				printk("driver bug! interrupt while in poll\n");

				/* FIX by disabling interrupts  */

				disable_rx_and_rxnobuff_ints();

			}

		}

/************************ end note note *********************************/		

			

		if (status & tx_related) {

			spin_lock(&tp->lock);

			tx_ring_free(dev);


			if (tx_died)

				restart_tx();

			spin_unlock(&tp->lock);

		}


		status = read_interrupt_status_reg();


/************************ start note *********************************/		

	} while (!(status & error) || more_work_to_be_done(status));

/************************ end note note *********************************/		


}


---------------------------------------------------------------------

-------------------------------------------------------------------


/* this is called by interrupt handler */

static void receive_packets (struct net_device *dev)

{


	struct my_private *tp = (struct my_private *)dev->priv;

	rx_ring = tp->rx_ring;

	cur_rx = tp->cur_rx;

	int entry = cur_rx % RX_RING_SIZE;

	int received = 0;

	int rx_work_limit = tp->dirty_rx + RX_RING_SIZE - tp->cur_rx;


	while (rx_ring_not_empty) {

		u32 rx_status;

		unsigned int rx_size;

		unsigned int pkt_size;

		struct sk_buff *skb;

                /* read size+status of next frame from DMA ring buffer */

		/* the number 16 and 4 are just examples */

                rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset));

                rx_size = rx_status >> 16;

                pkt_size = rx_size - 4;


		/* process errors */

                if ((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||

                    (!(rx_status & RxStatusOK))) {

                        netdrv_rx_err (rx_status, dev, tp, ioaddr);

                        return;

                }


                if (--rx_work_limit < 0)

                        break;


		/* grab a skb */

                skb = dev_alloc_skb (pkt_size + 2);

                if (skb) {

			.

			.

			netif_rx (skb);

			.

			.

                } else {  /* OOM */

			/*seems very driver specific ... some just pass

			whatever is on the ring already. */

                }


		/* move to the next skb on the ring */

		entry = (++tp->cur_rx) % RX_RING_SIZE;

		received++ ;


        }


	/* store current ring pointer state */

        tp->cur_rx = cur_rx;


        /* Refill the Rx ring buffers if they are needed */

	refill_rx_ring();

	.

	.


}

-------------------------------------------------------------------

새로운 파라메터에 주의하며 아래의 변경된 코드를 참조한다. 


-------------------------------------------------------------------


/* this is called by the network core */

static void my_poll (struct net_device *dev, int *budget)

{


	struct my_private *tp = (struct my_private *)dev->priv;

	rx_ring = tp->rx_ring;

	cur_rx = tp->cur_rx;

	int entry = cur_rx % RX_BUF_LEN;

	/* maximum packets to send to the stack */

/************************ note note *********************************/		

	int rx_work_limit = dev->quota;


/************************ end note note *********************************/		

    do {  // outer beggining loop starts here


	clear_rx_status_register_bit();


	while (rx_ring_not_empty) {

		u32 rx_status;

		unsigned int rx_size;

		unsigned int pkt_size;

		struct sk_buff *skb;

                /* read size+status of next frame from DMA ring buffer */

		/* the number 16 and 4 are just examples */

                rx_status = le32_to_cpu (*(u32 *) (rx_ring + ring_offset));

                rx_size = rx_status >> 16;

                pkt_size = rx_size - 4;


		/* process errors */

                if ((rx_size > (MAX_ETH_FRAME_SIZE+4)) ||

                    (!(rx_status & RxStatusOK))) {

                        netdrv_rx_err (rx_status, dev, tp, ioaddr);

                        return;

                }


/************************ note note *********************************/		

                if (--rx_work_limit < 0) { /* we got packets, but no quota */

			/* store current ring pointer state */

			tp->cur_rx = cur_rx;


			/* Refill the Rx ring buffers if they are needed */

			refill_rx_ring(dev);

                        goto not_done;

		}

/**********************  end note **********************************/


		/* grab a skb */

                skb = dev_alloc_skb (pkt_size + 2);

                if (skb) {

			.

			.

/************************ note note *********************************/		

			netif_receive_skb (skb);

/**********************  end note **********************************/

			.

			.

                } else {  /* OOM */

			/*seems very driver specific ... common is just pass

			whatever is on the ring already. */

                }


		/* move to the next skb on the ring */

		entry = (++tp->cur_rx) % RX_RING_SIZE;

		received++ ;


        }


	/* store current ring pointer state */

        tp->cur_rx = cur_rx;


        /* Refill the Rx ring buffers if they are needed */

	refill_rx_ring(dev);

	

	/* no packets on ring; but new ones can arrive since we last 

	   checked  */

	status = read_interrupt_status_reg();

	if (rx status is not set) {

                        /* If something arrives in this narrow window,

			an interrupt will be generated */

                        goto done;

	}

	/* done! at least thats what it looks like ;->


	if new packets came in after our last check on status bits

	they'll be caught by the while check and we go back and clear them 

	since we havent exceeded our quota */

    } while (rx_status_is_set); 


done:


/************************ note note *********************************/		

        dev->quota -= received;

        *budget -= received;


        /* If RX ring is not full we are out of memory. */

        if (tp->rx_buffers[tp->dirty_rx % RX_RING_SIZE].skb == NULL)

                goto oom;


	/* we are happy/done, no more packets on ring; put us back

	to where we can start processing interrupts again */

        netif_rx_complete(dev);

	enable_rx_and_rxnobuf_ints();


       /* The last op happens after poll completion. Which means the following:

        * 1. it can race with disabling irqs in irq handler (which are done to 

	* schedule polls)

        * 2. it can race with dis/enabling irqs in other poll threads

        * 3. if an irq raised after the begining of the outer  beginning 

        * loop(marked in the code above), it will be immediately

        * triggered here.

        *

        * Summarizing: the logic may results in some redundant irqs both

        * due to races in masking and due to too late acking of already

        * processed irqs. The good news: no events are ever lost.

        */


        return 0;   /* done */


not_done:

        if (tp->cur_rx - tp->dirty_rx > RX_RING_SIZE/2 ||

            tp->rx_buffers[tp->dirty_rx % RX_RING_SIZE].skb == NULL)

                refill_rx_ring(dev);


        if (!received) {

                printk("received==0\n");

                received = 1;

        }

        dev->quota -= received;

        *budget -= received;

        return 1;  /* not_done */


oom:

        /* Start timer, stop polling, but do not enable rx interrupts. */

	start_poll_timer(dev);

        return 0;  /* we'll take it from here so tell core "done"*/


/************************ End note note *********************************/		

}

-------------------------------------------------------------------

-----------------------------------------------------------

Poll 타이머 코드는 아래와 같다. 

a) 


        if (tp->cur_rx - tp->dirty_rx > RX_RING_SIZE/2 ||

            tp->rx_buffers[tp->dirty_rx % RX_RING_SIZE].skb == NULL) 

                refill_rx_ring(dev);


        /* If RX ring is not full we are still out of memory.

	   Restart the timer again. Else we re-add ourselves 

           to the master poll list.

         */


        if (tp->rx_buffers[tp->dirty_rx % RX_RING_SIZE].skb == NULL)

                restart_timer();


	else netif_rx_schedule(dev);  /* we are back on the poll list */