1 /* 8390.c: A general NS8390 ethernet driver core for linux. */
3 Written 1992-94 by Donald Becker.
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency.
8 This software may be used and distributed according to the terms
9 of the GNU General Public License, incorporated herein by reference.
11 The author may be reached as becker@scyld.com, or C/O
12 Scyld Computing Corporation
13 410 Severn Ave., Suite 210
17 This is the chip-specific code for many 8390-based ethernet adaptors.
18 This is not a complete driver, it must be combined with board-specific
19 code such as ne.c, wd.c, 3c503.c, etc.
21 Seeing how at least eight drivers use this code, (not counting the
22 PCMCIA ones either) it is easy to break some card by what seems like
23 a simple innocent change. Please contact me or Donald if you think
24 you have found something that needs changing. -- PG
29 Paul Gortmaker : remove set_bit lock, other cleanups.
30 Paul Gortmaker : add ei_get_8390_hdr() so we can pass skb's to
31 ei_block_input() for eth_io_copy_and_sum().
32 Paul Gortmaker : exchange static int ei_pingpong for a #define,
33 also add better Tx error handling.
34 Paul Gortmaker : rewrite Rx overrun handling as per NS specs.
35 Alexey Kuznetsov : use the 8390's six bit hash multicast filter.
36 Paul Gortmaker : tweak ANK's above multicast changes a bit.
37 Paul Gortmaker : update packet statistics for v2.1.x
38 Alan Cox : support arbitary stupid port mappings on the
39 68K Macintosh. Support >16bit I/O spaces
40 Paul Gortmaker : add kmod support for auto-loading of the 8390
41 module by all drivers that require it.
42 Alan Cox : Spinlocking work, added 'BUG_83C690'
43 Paul Gortmaker : Separate out Tx timeout code from Tx path.
44 Paul Gortmaker : Remove old unused single Tx buffer code.
47 The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
51 static const char version[] =
52 "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
54 #include <linux/module.h>
55 #include <linux/kernel.h>
56 #include <linux/jiffies.h>
58 #include <linux/types.h>
59 #include <linux/string.h>
60 #include <asm/system.h>
61 #include <asm/uaccess.h>
62 #include <asm/bitops.h>
65 #include <linux/delay.h>
66 #include <linux/errno.h>
67 #include <linux/fcntl.h>
69 #include <linux/interrupt.h>
70 #include <linux/init.h>
71 #include <linux/crc32.h>
73 #include <linux/netdevice.h>
74 #include <linux/etherdevice.h>
81 /* These are the operational function interfaces to board-specific
83 void reset_8390(struct net_device *dev)
84 Resets the board associated with DEV, including a hardware reset of
85 the 8390. This is only called when there is a transmit timeout, and
86 it is always followed by 8390_init().
87 void block_output(struct net_device *dev, int count, const unsigned char *buf,
89 Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The
90 "page" value uses the 8390's 256-byte pages.
91 void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page)
92 Read the 4 byte, page aligned 8390 header. *If* there is a
93 subsequent read, it will be of the rest of the packet.
94 void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
95 Read COUNT bytes from the packet buffer into the skb data area. Start
96 reading from RING_OFFSET, the address as the 8390 sees it. This will always
97 follow the read of the 8390 header.
99 #define ei_reset_8390 (ei_local->reset_8390)
100 #define ei_block_output (ei_local->block_output)
101 #define ei_block_input (ei_local->block_input)
102 #define ei_get_8390_hdr (ei_local->get_8390_hdr)
104 /* use 0 for production, 1 for verification, >2 for debug */
109 /* Index to functions. */
110 static void ei_tx_intr(struct net_device *dev);
111 static void ei_tx_err(struct net_device *dev);
112 static void ei_tx_timeout(struct net_device *dev);
113 static void ei_receive(struct net_device *dev);
114 static void ei_rx_overrun(struct net_device *dev);
116 /* Routines generic to NS8390-based boards. */
117 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
119 static void set_multicast_list(struct net_device *dev);
120 static void do_set_multicast_list(struct net_device *dev);
123 * SMP and the 8390 setup.
125 * The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
126 * a page register that controls bank and packet buffer access. We guard
127 * this with ei_local->page_lock. Nobody should assume or set the page other
128 * than zero when the lock is not held. Lock holders must restore page 0
129 * before unlocking. Even pure readers must take the lock to protect in
132 * To make life difficult the chip can also be very slow. We therefore can't
133 * just use spinlocks. For the longer lockups we disable the irq the device
134 * sits on and hold the lock. We must hold the lock because there is a dual
135 * processor case other than interrupts (get stats/set multicast list in
136 * parallel with each other and transmit).
138 * Note: in theory we can just disable the irq on the card _but_ there is
139 * a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
140 * enter lock, take the queued irq. So we waddle instead of flying.
142 * Finally by special arrangement for the purpose of being generally
143 * annoying the transmit function is called bh atomic. That places
144 * restrictions on the user context callers as disable_irq won't save
151 * ei_open - Open/initialize the board.
152 * @dev: network device to initialize
154 * This routine goes all-out, setting everything
155 * up anew at each open, even though many of these registers should only
156 * need to be set once at boot.
158 int ei_open(struct net_device *dev)
161 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
163 /* The card I/O part of the driver (e.g. 3c503) can hook a Tx timeout
164 wrapper that does e.g. media check & then calls ei_tx_timeout. */
165 if (dev->tx_timeout == NULL)
166 dev->tx_timeout = ei_tx_timeout;
167 if (dev->watchdog_timeo <= 0)
168 dev->watchdog_timeo = TX_TIMEOUT;
171 * Grab the page lock so we own the register set, then call
175 spin_lock_irqsave(&ei_local->page_lock, flags);
177 /* Set the flag before we drop the lock, That way the IRQ arrives
178 after its set and we get no silly warnings */
179 netif_start_queue(dev);
180 spin_unlock_irqrestore(&ei_local->page_lock, flags);
181 ei_local->irqlock = 0;
186 * ei_close - shut down network device
187 * @dev: network device to close
189 * Opposite of ei_open(). Only used when "ifconfig <devname> down" is done.
191 int ei_close(struct net_device *dev)
193 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
197 * Hold the page lock during close
200 spin_lock_irqsave(&ei_local->page_lock, flags);
202 spin_unlock_irqrestore(&ei_local->page_lock, flags);
203 netif_stop_queue(dev);
208 * ei_tx_timeout - handle transmit time out condition
209 * @dev: network device which has apparently fallen asleep
211 * Called by kernel when device never acknowledges a transmit has
212 * completed (or failed) - i.e. never posted a Tx related interrupt.
215 void ei_tx_timeout(struct net_device *dev)
217 long e8390_base = dev->base_addr;
218 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
219 int txsr, isr, tickssofar = jiffies - dev->trans_start;
222 ei_local->stat.tx_errors++;
224 spin_lock_irqsave(&ei_local->page_lock, flags);
225 txsr = inb(e8390_base+EN0_TSR);
226 isr = inb(e8390_base+EN0_ISR);
227 spin_unlock_irqrestore(&ei_local->page_lock, flags);
229 printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
230 dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
231 (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
233 if (!isr && !ei_local->stat.tx_packets)
235 /* The 8390 probably hasn't gotten on the cable yet. */
236 ei_local->interface_num ^= 1; /* Try a different xcvr. */
239 /* Ugly but a reset can be slow, yet must be protected */
241 disable_irq_nosync(dev->irq);
242 spin_lock(&ei_local->page_lock);
244 /* Try to restart the card. Perhaps the user has fixed something. */
248 spin_unlock(&ei_local->page_lock);
249 enable_irq(dev->irq);
250 netif_wake_queue(dev);
254 * ei_start_xmit - begin packet transmission
255 * @skb: packet to be sent
256 * @dev: network device to which packet is sent
258 * Sends a packet to an 8390 network device.
261 static int ei_start_xmit(struct sk_buff *skb, struct net_device *dev)
263 long e8390_base = dev->base_addr;
264 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
265 int length, send_length, output_page;
267 char scratch[ETH_ZLEN];
271 /* Mask interrupts from the ethercard.
272 SMP: We have to grab the lock here otherwise the IRQ handler
273 on another CPU can flip window and race the IRQ mask set. We end
274 up trashing the mcast filter not disabling irqs if we don't lock */
276 spin_lock_irqsave(&ei_local->page_lock, flags);
277 outb_p(0x00, e8390_base + EN0_IMR);
278 spin_unlock_irqrestore(&ei_local->page_lock, flags);
282 * Slow phase with lock held.
285 disable_irq_nosync(dev->irq);
287 spin_lock(&ei_local->page_lock);
289 ei_local->irqlock = 1;
291 send_length = ETH_ZLEN < length ? length : ETH_ZLEN;
294 * We have two Tx slots available for use. Find the first free
295 * slot, and then perform some sanity checks. With two Tx bufs,
296 * you get very close to transmitting back-to-back packets. With
297 * only one Tx buf, the transmitter sits idle while you reload the
298 * card, leaving a substantial gap between each transmitted packet.
301 if (ei_local->tx1 == 0)
303 output_page = ei_local->tx_start_page;
304 ei_local->tx1 = send_length;
305 if (ei_debug && ei_local->tx2 > 0)
306 printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
307 dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
309 else if (ei_local->tx2 == 0)
311 output_page = ei_local->tx_start_page + TX_PAGES/2;
312 ei_local->tx2 = send_length;
313 if (ei_debug && ei_local->tx1 > 0)
314 printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
315 dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
318 { /* We should never get here. */
320 printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
321 dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
322 ei_local->irqlock = 0;
323 netif_stop_queue(dev);
324 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
325 spin_unlock(&ei_local->page_lock);
326 enable_irq(dev->irq);
327 ei_local->stat.tx_errors++;
332 * Okay, now upload the packet and trigger a send if the transmitter
333 * isn't already sending. If it is busy, the interrupt handler will
334 * trigger the send later, upon receiving a Tx done interrupt.
337 if (length == send_length)
338 ei_block_output(dev, length, skb->data, output_page);
340 memset(scratch, 0, ETH_ZLEN);
341 memcpy(scratch, skb->data, skb->len);
342 ei_block_output(dev, ETH_ZLEN, scratch, output_page);
345 if (! ei_local->txing)
348 NS8390_trigger_send(dev, send_length, output_page);
349 dev->trans_start = jiffies;
350 if (output_page == ei_local->tx_start_page)
353 ei_local->lasttx = -1;
358 ei_local->lasttx = -2;
361 else ei_local->txqueue++;
363 if (ei_local->tx1 && ei_local->tx2)
364 netif_stop_queue(dev);
366 netif_start_queue(dev);
368 /* Turn 8390 interrupts back on. */
369 ei_local->irqlock = 0;
370 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
372 spin_unlock(&ei_local->page_lock);
373 enable_irq(dev->irq);
376 ei_local->stat.tx_bytes += send_length;
382 * ei_interrupt - handle the interrupts from an 8390
383 * @irq: interrupt number
384 * @dev_id: a pointer to the net_device
387 * Handle the ether interface interrupts. We pull packets from
388 * the 8390 via the card specific functions and fire them at the networking
389 * stack. We also handle transmit completions and wake the transmit path if
390 * necessary. We also update the counters and do other housekeeping as
394 irqreturn_t ei_interrupt(int irq, void *dev_id, struct pt_regs * regs)
396 struct net_device *dev = dev_id;
398 int interrupts, nr_serviced = 0;
399 struct ei_device *ei_local;
403 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
407 e8390_base = dev->base_addr;
408 ei_local = (struct ei_device *) netdev_priv(dev);
411 * Protect the irq test too.
414 spin_lock(&ei_local->page_lock);
416 if (ei_local->irqlock)
418 #if 1 /* This might just be an interrupt for a PCI device sharing this line */
419 /* The "irqlock" check is only for testing. */
420 printk(ei_local->irqlock
421 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
422 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
423 dev->name, inb_p(e8390_base + EN0_ISR),
424 inb_p(e8390_base + EN0_IMR));
426 spin_unlock(&ei_local->page_lock);
430 /* Change to page 0 and read the intr status reg. */
431 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
433 printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name,
434 inb_p(e8390_base + EN0_ISR));
436 /* !!Assumption!! -- we stay in page 0. Don't break this. */
437 while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
438 && ++nr_serviced < MAX_SERVICE)
440 if (!netif_running(dev)) {
441 printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name);
442 /* rmk - acknowledge the interrupts */
443 outb_p(interrupts, e8390_base + EN0_ISR);
447 if (interrupts & ENISR_OVER)
449 else if (interrupts & (ENISR_RX+ENISR_RX_ERR))
451 /* Got a good (?) packet. */
454 /* Push the next to-transmit packet through. */
455 if (interrupts & ENISR_TX)
457 else if (interrupts & ENISR_TX_ERR)
460 if (interrupts & ENISR_COUNTERS)
462 ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
463 ei_local->stat.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
464 ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
465 outb_p(ENISR_COUNTERS, e8390_base + EN0_ISR); /* Ack intr. */
468 /* Ignore any RDC interrupts that make it back to here. */
469 if (interrupts & ENISR_RDC)
471 outb_p(ENISR_RDC, e8390_base + EN0_ISR);
474 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
477 if (interrupts && ei_debug)
479 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
480 if (nr_serviced >= MAX_SERVICE)
482 /* 0xFF is valid for a card removal */
484 printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n",
485 dev->name, interrupts);
486 outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
488 printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts);
489 outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
492 spin_unlock(&ei_local->page_lock);
493 return IRQ_RETVAL(nr_serviced > 0);
496 #ifdef CONFIG_NET_POLL_CONTROLLER
497 void ei_poll(struct net_device *dev)
499 disable_irq(dev->irq);
500 ei_interrupt(dev->irq, dev, NULL);
501 enable_irq(dev->irq);
506 * ei_tx_err - handle transmitter error
507 * @dev: network device which threw the exception
509 * A transmitter error has happened. Most likely excess collisions (which
510 * is a fairly normal condition). If the error is one where the Tx will
511 * have been aborted, we try and send another one right away, instead of
512 * letting the failed packet sit and collect dust in the Tx buffer. This
513 * is a much better solution as it avoids kernel based Tx timeouts, and
514 * an unnecessary card reset.
516 * Called with lock held.
519 static void ei_tx_err(struct net_device *dev)
521 long e8390_base = dev->base_addr;
522 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
523 unsigned char txsr = inb_p(e8390_base+EN0_TSR);
524 unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
526 #ifdef VERBOSE_ERROR_DUMP
527 printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
528 if (txsr & ENTSR_ABT)
529 printk("excess-collisions ");
531 printk("non-deferral ");
532 if (txsr & ENTSR_CRS)
533 printk("lost-carrier ");
535 printk("FIFO-underrun ");
536 if (txsr & ENTSR_CDH)
537 printk("lost-heartbeat ");
541 outb_p(ENISR_TX_ERR, e8390_base + EN0_ISR); /* Ack intr. */
547 ei_local->stat.tx_errors++;
548 if (txsr & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
549 if (txsr & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
550 if (txsr & ENTSR_OWC) ei_local->stat.tx_window_errors++;
555 * ei_tx_intr - transmit interrupt handler
556 * @dev: network device for which tx intr is handled
558 * We have finished a transmit: check for errors and then trigger the next
559 * packet to be sent. Called with lock held.
562 static void ei_tx_intr(struct net_device *dev)
564 long e8390_base = dev->base_addr;
565 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
566 int status = inb(e8390_base + EN0_TSR);
568 outb_p(ENISR_TX, e8390_base + EN0_ISR); /* Ack intr. */
571 * There are two Tx buffers, see which one finished, and trigger
572 * the send of another one if it exists.
576 if (ei_local->tx1 < 0)
578 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
579 printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n",
580 ei_local->name, ei_local->lasttx, ei_local->tx1);
582 if (ei_local->tx2 > 0)
585 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
586 dev->trans_start = jiffies;
588 ei_local->lasttx = 2;
590 else ei_local->lasttx = 20, ei_local->txing = 0;
592 else if (ei_local->tx2 < 0)
594 if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
595 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
596 ei_local->name, ei_local->lasttx, ei_local->tx2);
598 if (ei_local->tx1 > 0)
601 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
602 dev->trans_start = jiffies;
604 ei_local->lasttx = 1;
607 ei_local->lasttx = 10, ei_local->txing = 0;
609 // else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
610 // dev->name, ei_local->lasttx);
612 /* Minimize Tx latency: update the statistics after we restart TXing. */
613 if (status & ENTSR_COL)
614 ei_local->stat.collisions++;
615 if (status & ENTSR_PTX)
616 ei_local->stat.tx_packets++;
619 ei_local->stat.tx_errors++;
620 if (status & ENTSR_ABT)
622 ei_local->stat.tx_aborted_errors++;
623 ei_local->stat.collisions += 16;
625 if (status & ENTSR_CRS)
626 ei_local->stat.tx_carrier_errors++;
627 if (status & ENTSR_FU)
628 ei_local->stat.tx_fifo_errors++;
629 if (status & ENTSR_CDH)
630 ei_local->stat.tx_heartbeat_errors++;
631 if (status & ENTSR_OWC)
632 ei_local->stat.tx_window_errors++;
634 netif_wake_queue(dev);
638 * ei_receive - receive some packets
639 * @dev: network device with which receive will be run
641 * We have a good packet(s), get it/them out of the buffers.
642 * Called with lock held.
645 static void ei_receive(struct net_device *dev)
647 long e8390_base = dev->base_addr;
648 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
649 unsigned char rxing_page, this_frame, next_frame;
650 unsigned short current_offset;
651 int rx_pkt_count = 0;
652 struct e8390_pkt_hdr rx_frame;
653 int num_rx_pages = ei_local->stop_page-ei_local->rx_start_page;
655 while (++rx_pkt_count < 10)
657 int pkt_len, pkt_stat;
659 /* Get the rx page (incoming packet pointer). */
660 outb_p(E8390_NODMA+E8390_PAGE1, e8390_base + E8390_CMD);
661 rxing_page = inb_p(e8390_base + EN1_CURPAG);
662 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
664 /* Remove one frame from the ring. Boundary is always a page behind. */
665 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
666 if (this_frame >= ei_local->stop_page)
667 this_frame = ei_local->rx_start_page;
669 /* Someday we'll omit the previous, iff we never get this message.
670 (There is at least one clone claimed to have a problem.)
672 Keep quiet if it looks like a card removal. One problem here
673 is that some clones crash in roughly the same way.
675 if (ei_debug > 0 && this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF))
676 printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n",
677 dev->name, this_frame, ei_local->current_page);
679 if (this_frame == rxing_page) /* Read all the frames? */
680 break; /* Done for now */
682 current_offset = this_frame << 8;
683 ei_get_8390_hdr(dev, &rx_frame, this_frame);
685 pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
686 pkt_stat = rx_frame.status;
688 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
690 /* Check for bogosity warned by 3c503 book: the status byte is never
691 written. This happened a lot during testing! This code should be
692 cleaned up someday. */
693 if (rx_frame.next != next_frame
694 && rx_frame.next != next_frame + 1
695 && rx_frame.next != next_frame - num_rx_pages
696 && rx_frame.next != next_frame + 1 - num_rx_pages) {
697 ei_local->current_page = rxing_page;
698 outb(ei_local->current_page-1, e8390_base+EN0_BOUNDARY);
699 ei_local->stat.rx_errors++;
703 if (pkt_len < 60 || pkt_len > 1518)
706 printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
707 dev->name, rx_frame.count, rx_frame.status,
709 ei_local->stat.rx_errors++;
710 ei_local->stat.rx_length_errors++;
712 else if ((pkt_stat & 0x0F) == ENRSR_RXOK)
716 skb = dev_alloc_skb(pkt_len+2);
720 printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n",
722 ei_local->stat.rx_dropped++;
727 skb_reserve(skb,2); /* IP headers on 16 byte boundaries */
729 skb_put(skb, pkt_len); /* Make room */
730 ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
731 skb->protocol=eth_type_trans(skb,dev);
733 dev->last_rx = jiffies;
734 ei_local->stat.rx_packets++;
735 ei_local->stat.rx_bytes += pkt_len;
736 if (pkt_stat & ENRSR_PHY)
737 ei_local->stat.multicast++;
743 printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
744 dev->name, rx_frame.status, rx_frame.next,
746 ei_local->stat.rx_errors++;
747 /* NB: The NIC counts CRC, frame and missed errors. */
748 if (pkt_stat & ENRSR_FO)
749 ei_local->stat.rx_fifo_errors++;
751 next_frame = rx_frame.next;
753 /* This _should_ never happen: it's here for avoiding bad clones. */
754 if (next_frame >= ei_local->stop_page) {
755 printk("%s: next frame inconsistency, %#2x\n", dev->name,
757 next_frame = ei_local->rx_start_page;
759 ei_local->current_page = next_frame;
760 outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
763 /* We used to also ack ENISR_OVER here, but that would sometimes mask
764 a real overrun, leaving the 8390 in a stopped state with rec'vr off. */
765 outb_p(ENISR_RX+ENISR_RX_ERR, e8390_base+EN0_ISR);
770 * ei_rx_overrun - handle receiver overrun
771 * @dev: network device which threw exception
773 * We have a receiver overrun: we have to kick the 8390 to get it started
774 * again. Problem is that you have to kick it exactly as NS prescribes in
775 * the updated datasheets, or "the NIC may act in an unpredictable manner."
776 * This includes causing "the NIC to defer indefinitely when it is stopped
777 * on a busy network." Ugh.
778 * Called with lock held. Don't call this with the interrupts off or your
779 * computer will hate you - it takes 10ms or so.
782 static void ei_rx_overrun(struct net_device *dev)
784 long e8390_base = dev->base_addr;
785 unsigned char was_txing, must_resend = 0;
786 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
789 * Record whether a Tx was in progress and then issue the
792 was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
793 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
796 printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name);
797 ei_local->stat.rx_over_errors++;
800 * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
801 * Early datasheets said to poll the reset bit, but now they say that
802 * it "is not a reliable indicator and subsequently should be ignored."
803 * We wait at least 10ms.
809 * Reset RBCR[01] back to zero as per magic incantation.
811 outb_p(0x00, e8390_base+EN0_RCNTLO);
812 outb_p(0x00, e8390_base+EN0_RCNTHI);
815 * See if any Tx was interrupted or not. According to NS, this
816 * step is vital, and skipping it will cause no end of havoc.
821 unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
827 * Have to enter loopback mode and then restart the NIC before
828 * you are allowed to slurp packets up off the ring.
830 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
831 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
834 * Clear the Rx ring of all the debris, and ack the interrupt.
837 outb_p(ENISR_OVER, e8390_base+EN0_ISR);
840 * Leave loopback mode, and resend any packet that got stopped.
842 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR);
844 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
848 * Collect the stats. This is called unlocked and from several contexts.
851 static struct net_device_stats *get_stats(struct net_device *dev)
853 long ioaddr = dev->base_addr;
854 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
857 /* If the card is stopped, just return the present stats. */
858 if (!netif_running(dev))
859 return &ei_local->stat;
861 spin_lock_irqsave(&ei_local->page_lock,flags);
862 /* Read the counter registers, assuming we are in page 0. */
863 ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
864 ei_local->stat.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
865 ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
866 spin_unlock_irqrestore(&ei_local->page_lock, flags);
868 return &ei_local->stat;
872 * Form the 64 bit 8390 multicast table from the linked list of addresses
873 * associated with this dev structure.
876 static inline void make_mc_bits(u8 *bits, struct net_device *dev)
878 struct dev_mc_list *dmi;
880 for (dmi=dev->mc_list; dmi; dmi=dmi->next)
883 if (dmi->dmi_addrlen != ETH_ALEN)
885 printk(KERN_INFO "%s: invalid multicast address length given.\n", dev->name);
888 crc = ether_crc(ETH_ALEN, dmi->dmi_addr);
890 * The 8390 uses the 6 most significant bits of the
891 * CRC to index the multicast table.
893 bits[crc>>29] |= (1<<((crc>>26)&7));
898 * do_set_multicast_list - set/clear multicast filter
899 * @dev: net device for which multicast filter is adjusted
901 * Set or clear the multicast filter for this adaptor. May be called
902 * from a BH in 2.1.x. Must be called with lock held.
905 static void do_set_multicast_list(struct net_device *dev)
907 long e8390_base = dev->base_addr;
909 struct ei_device *ei_local = (struct ei_device*)netdev_priv(dev);
911 if (!(dev->flags&(IFF_PROMISC|IFF_ALLMULTI)))
913 memset(ei_local->mcfilter, 0, 8);
915 make_mc_bits(ei_local->mcfilter, dev);
918 memset(ei_local->mcfilter, 0xFF, 8); /* mcast set to accept-all */
921 * DP8390 manuals don't specify any magic sequence for altering
922 * the multicast regs on an already running card. To be safe, we
923 * ensure multicast mode is off prior to loading up the new hash
924 * table. If this proves to be not enough, we can always resort
925 * to stopping the NIC, loading the table and then restarting.
927 * Bug Alert! The MC regs on the SMC 83C690 (SMC Elite and SMC
928 * Elite16) appear to be write-only. The NS 8390 data sheet lists
929 * them as r/w so this is a bug. The SMC 83C790 (SMC Ultra and
930 * Ultra32 EISA) appears to have this bug fixed.
933 if (netif_running(dev))
934 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
935 outb_p(E8390_NODMA + E8390_PAGE1, e8390_base + E8390_CMD);
936 for(i = 0; i < 8; i++)
938 outb_p(ei_local->mcfilter[i], e8390_base + EN1_MULT_SHIFT(i));
940 if(inb_p(e8390_base + EN1_MULT_SHIFT(i))!=ei_local->mcfilter[i])
941 printk(KERN_ERR "Multicast filter read/write mismap %d\n",i);
944 outb_p(E8390_NODMA + E8390_PAGE0, e8390_base + E8390_CMD);
946 if(dev->flags&IFF_PROMISC)
947 outb_p(E8390_RXCONFIG | 0x18, e8390_base + EN0_RXCR);
948 else if(dev->flags&IFF_ALLMULTI || dev->mc_list)
949 outb_p(E8390_RXCONFIG | 0x08, e8390_base + EN0_RXCR);
951 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
955 * Called without lock held. This is invoked from user context and may
956 * be parallel to just about everything else. Its also fairly quick and
957 * not called too often. Must protect against both bh and irq users
960 static void set_multicast_list(struct net_device *dev)
963 struct ei_device *ei_local = (struct ei_device*)netdev_priv(dev);
965 spin_lock_irqsave(&ei_local->page_lock, flags);
966 do_set_multicast_list(dev);
967 spin_unlock_irqrestore(&ei_local->page_lock, flags);
971 * ethdev_setup - init rest of 8390 device struct
972 * @dev: network device structure to init
974 * Initialize the rest of the 8390 device structure. Do NOT __init
975 * this, as it is used by 8390 based modular drivers too.
978 static void ethdev_setup(struct net_device *dev)
980 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
984 dev->hard_start_xmit = &ei_start_xmit;
985 dev->get_stats = get_stats;
986 dev->set_multicast_list = &set_multicast_list;
990 spin_lock_init(&ei_local->page_lock);
994 * alloc_ei_netdev - alloc_etherdev counterpart for 8390
996 * Allocate 8390-specific net_device.
998 struct net_device *__alloc_ei_netdev(int size)
1000 return alloc_netdev(sizeof(struct ei_device) + size, "eth%d",
1007 /* This page of functions should be 8390 generic */
1008 /* Follow National Semi's recommendations for initializing the "NIC". */
1011 * NS8390_init - initialize 8390 hardware
1012 * @dev: network device to initialize
1013 * @startp: boolean. non-zero value to initiate chip processing
1015 * Must be called with lock held.
1018 void NS8390_init(struct net_device *dev, int startp)
1020 long e8390_base = dev->base_addr;
1021 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1023 int endcfg = ei_local->word16
1024 ? (0x48 | ENDCFG_WTS | (ei_local->bigendian ? ENDCFG_BOS : 0))
1027 if(sizeof(struct e8390_pkt_hdr)!=4)
1028 panic("8390.c: header struct mispacked\n");
1029 /* Follow National Semi's recommendations for initing the DP83902. */
1030 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); /* 0x21 */
1031 outb_p(endcfg, e8390_base + EN0_DCFG); /* 0x48 or 0x49 */
1032 /* Clear the remote byte count registers. */
1033 outb_p(0x00, e8390_base + EN0_RCNTLO);
1034 outb_p(0x00, e8390_base + EN0_RCNTHI);
1035 /* Set to monitor and loopback mode -- this is vital!. */
1036 outb_p(E8390_RXOFF, e8390_base + EN0_RXCR); /* 0x20 */
1037 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
1038 /* Set the transmit page and receive ring. */
1039 outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
1040 ei_local->tx1 = ei_local->tx2 = 0;
1041 outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
1042 outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
1043 ei_local->current_page = ei_local->rx_start_page; /* assert boundary+1 */
1044 outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
1045 /* Clear the pending interrupts and mask. */
1046 outb_p(0xFF, e8390_base + EN0_ISR);
1047 outb_p(0x00, e8390_base + EN0_IMR);
1049 /* Copy the station address into the DS8390 registers. */
1051 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD); /* 0x61 */
1052 for(i = 0; i < 6; i++)
1054 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i));
1055 if (ei_debug > 1 && inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i])
1056 printk(KERN_ERR "Hw. address read/write mismap %d\n",i);
1059 outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
1060 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1062 netif_start_queue(dev);
1063 ei_local->tx1 = ei_local->tx2 = 0;
1064 ei_local->txing = 0;
1068 outb_p(0xff, e8390_base + EN0_ISR);
1069 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1070 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1071 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
1072 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1073 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR); /* rx on, */
1074 do_set_multicast_list(dev); /* (re)load the mcast table */
1078 /* Trigger a transmit start, assuming the length is valid.
1079 Always called with the page lock held */
1081 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
1084 long e8390_base = dev->base_addr;
1085 struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) netdev_priv(dev);
1087 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base+E8390_CMD);
1089 if (inb_p(e8390_base) & E8390_TRANS)
1091 printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n",
1095 outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
1096 outb_p(length >> 8, e8390_base + EN0_TCNTHI);
1097 outb_p(start_page, e8390_base + EN0_TPSR);
1098 outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD);
1101 EXPORT_SYMBOL(ei_open);
1102 EXPORT_SYMBOL(ei_close);
1103 EXPORT_SYMBOL(ei_interrupt);
1104 #ifdef CONFIG_NET_POLL_CONTROLLER
1105 EXPORT_SYMBOL(ei_poll);
1107 EXPORT_SYMBOL(ei_tx_timeout);
1108 EXPORT_SYMBOL(NS8390_init);
1109 EXPORT_SYMBOL(__alloc_ei_netdev);
1113 int init_module(void)
1118 void cleanup_module(void)
1123 MODULE_LICENSE("GPL");