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.
46 The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
50 static const char version[] =
51 "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
53 #include <linux/module.h>
54 #include <linux/kernel.h>
55 #include <linux/jiffies.h>
57 #include <linux/types.h>
58 #include <linux/string.h>
59 #include <asm/system.h>
60 #include <asm/uaccess.h>
61 #include <asm/bitops.h>
64 #include <linux/delay.h>
65 #include <linux/errno.h>
66 #include <linux/fcntl.h>
68 #include <linux/interrupt.h>
69 #include <linux/init.h>
70 #include <linux/crc32.h>
72 #include <linux/netdevice.h>
73 #include <linux/etherdevice.h>
80 /* These are the operational function interfaces to board-specific
82 void reset_8390(struct net_device *dev)
83 Resets the board associated with DEV, including a hardware reset of
84 the 8390. This is only called when there is a transmit timeout, and
85 it is always followed by 8390_init().
86 void block_output(struct net_device *dev, int count, const unsigned char *buf,
88 Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The
89 "page" value uses the 8390's 256-byte pages.
90 void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page)
91 Read the 4 byte, page aligned 8390 header. *If* there is a
92 subsequent read, it will be of the rest of the packet.
93 void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
94 Read COUNT bytes from the packet buffer into the skb data area. Start
95 reading from RING_OFFSET, the address as the 8390 sees it. This will always
96 follow the read of the 8390 header.
98 #define ei_reset_8390 (ei_local->reset_8390)
99 #define ei_block_output (ei_local->block_output)
100 #define ei_block_input (ei_local->block_input)
101 #define ei_get_8390_hdr (ei_local->get_8390_hdr)
103 /* use 0 for production, 1 for verification, >2 for debug */
108 /* Index to functions. */
109 static void ei_tx_intr(struct net_device *dev);
110 static void ei_tx_err(struct net_device *dev);
111 static void ei_tx_timeout(struct net_device *dev);
112 static void ei_receive(struct net_device *dev);
113 static void ei_rx_overrun(struct net_device *dev);
115 /* Routines generic to NS8390-based boards. */
116 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
118 static void set_multicast_list(struct net_device *dev);
119 static void do_set_multicast_list(struct net_device *dev);
122 * SMP and the 8390 setup.
124 * The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
125 * a page register that controls bank and packet buffer access. We guard
126 * this with ei_local->page_lock. Nobody should assume or set the page other
127 * than zero when the lock is not held. Lock holders must restore page 0
128 * before unlocking. Even pure readers must take the lock to protect in
131 * To make life difficult the chip can also be very slow. We therefore can't
132 * just use spinlocks. For the longer lockups we disable the irq the device
133 * sits on and hold the lock. We must hold the lock because there is a dual
134 * processor case other than interrupts (get stats/set multicast list in
135 * parallel with each other and transmit).
137 * Note: in theory we can just disable the irq on the card _but_ there is
138 * a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
139 * enter lock, take the queued irq. So we waddle instead of flying.
141 * Finally by special arrangement for the purpose of being generally
142 * annoying the transmit function is called bh atomic. That places
143 * restrictions on the user context callers as disable_irq won't save
150 * ei_open - Open/initialize the board.
151 * @dev: network device to initialize
153 * This routine goes all-out, setting everything
154 * up anew at each open, even though many of these registers should only
155 * need to be set once at boot.
157 int ei_open(struct net_device *dev)
160 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
162 /* The card I/O part of the driver (e.g. 3c503) can hook a Tx timeout
163 wrapper that does e.g. media check & then calls ei_tx_timeout. */
164 if (dev->tx_timeout == NULL)
165 dev->tx_timeout = ei_tx_timeout;
166 if (dev->watchdog_timeo <= 0)
167 dev->watchdog_timeo = TX_TIMEOUT;
170 * Grab the page lock so we own the register set, then call
174 spin_lock_irqsave(&ei_local->page_lock, flags);
176 /* Set the flag before we drop the lock, That way the IRQ arrives
177 after its set and we get no silly warnings */
178 netif_start_queue(dev);
179 spin_unlock_irqrestore(&ei_local->page_lock, flags);
180 ei_local->irqlock = 0;
185 * ei_close - shut down network device
186 * @dev: network device to close
188 * Opposite of ei_open(). Only used when "ifconfig <devname> down" is done.
190 int ei_close(struct net_device *dev)
192 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
196 * Hold the page lock during close
199 spin_lock_irqsave(&ei_local->page_lock, flags);
201 spin_unlock_irqrestore(&ei_local->page_lock, flags);
202 netif_stop_queue(dev);
207 * ei_tx_timeout - handle transmit time out condition
208 * @dev: network device which has apparently fallen asleep
210 * Called by kernel when device never acknowledges a transmit has
211 * completed (or failed) - i.e. never posted a Tx related interrupt.
214 void ei_tx_timeout(struct net_device *dev)
216 long e8390_base = dev->base_addr;
217 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
218 int txsr, isr, tickssofar = jiffies - dev->trans_start;
221 ei_local->stat.tx_errors++;
223 spin_lock_irqsave(&ei_local->page_lock, flags);
224 txsr = inb(e8390_base+EN0_TSR);
225 isr = inb(e8390_base+EN0_ISR);
226 spin_unlock_irqrestore(&ei_local->page_lock, flags);
228 printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
229 dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
230 (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
232 if (!isr && !ei_local->stat.tx_packets)
234 /* The 8390 probably hasn't gotten on the cable yet. */
235 ei_local->interface_num ^= 1; /* Try a different xcvr. */
238 /* Ugly but a reset can be slow, yet must be protected */
240 disable_irq_nosync(dev->irq);
241 spin_lock(&ei_local->page_lock);
243 /* Try to restart the card. Perhaps the user has fixed something. */
247 spin_unlock(&ei_local->page_lock);
248 enable_irq(dev->irq);
249 netif_wake_queue(dev);
253 * ei_start_xmit - begin packet transmission
254 * @skb: packet to be sent
255 * @dev: network device to which packet is sent
257 * Sends a packet to an 8390 network device.
260 static int ei_start_xmit(struct sk_buff *skb, struct net_device *dev)
262 long e8390_base = dev->base_addr;
263 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
264 int length, send_length, output_page;
266 char scratch[ETH_ZLEN];
270 /* Mask interrupts from the ethercard.
271 SMP: We have to grab the lock here otherwise the IRQ handler
272 on another CPU can flip window and race the IRQ mask set. We end
273 up trashing the mcast filter not disabling irqs if we don't lock */
275 spin_lock_irqsave(&ei_local->page_lock, flags);
276 outb_p(0x00, e8390_base + EN0_IMR);
277 spin_unlock_irqrestore(&ei_local->page_lock, flags);
281 * Slow phase with lock held.
284 disable_irq_nosync(dev->irq);
286 spin_lock(&ei_local->page_lock);
288 ei_local->irqlock = 1;
290 send_length = ETH_ZLEN < length ? length : ETH_ZLEN;
295 * We have two Tx slots available for use. Find the first free
296 * slot, and then perform some sanity checks. With two Tx bufs,
297 * you get very close to transmitting back-to-back packets. With
298 * only one Tx buf, the transmitter sits idle while you reload the
299 * card, leaving a substantial gap between each transmitted packet.
302 if (ei_local->tx1 == 0)
304 output_page = ei_local->tx_start_page;
305 ei_local->tx1 = send_length;
306 if (ei_debug && ei_local->tx2 > 0)
307 printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
308 dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
310 else if (ei_local->tx2 == 0)
312 output_page = ei_local->tx_start_page + TX_1X_PAGES;
313 ei_local->tx2 = send_length;
314 if (ei_debug && ei_local->tx1 > 0)
315 printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
316 dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
319 { /* We should never get here. */
321 printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
322 dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
323 ei_local->irqlock = 0;
324 netif_stop_queue(dev);
325 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
326 spin_unlock(&ei_local->page_lock);
327 enable_irq(dev->irq);
328 ei_local->stat.tx_errors++;
333 * Okay, now upload the packet and trigger a send if the transmitter
334 * isn't already sending. If it is busy, the interrupt handler will
335 * trigger the send later, upon receiving a Tx done interrupt.
338 if (length == send_length)
339 ei_block_output(dev, length, skb->data, output_page);
341 memset(scratch, 0, ETH_ZLEN);
342 memcpy(scratch, skb->data, skb->len);
343 ei_block_output(dev, ETH_ZLEN, scratch, output_page);
346 if (! ei_local->txing)
349 NS8390_trigger_send(dev, send_length, output_page);
350 dev->trans_start = jiffies;
351 if (output_page == ei_local->tx_start_page)
354 ei_local->lasttx = -1;
359 ei_local->lasttx = -2;
362 else ei_local->txqueue++;
364 if (ei_local->tx1 && ei_local->tx2)
365 netif_stop_queue(dev);
367 netif_start_queue(dev);
369 #else /* EI_PINGPONG */
372 * Only one Tx buffer in use. You need two Tx bufs to come close to
373 * back-to-back transmits. Expect a 20 -> 25% performance hit on
374 * reasonable hardware if you only use one Tx buffer.
377 if (length == send_length)
378 ei_block_output(dev, length, skb->data, ei_local->tx_start_page);
380 memset(scratch, 0, ETH_ZLEN);
381 memcpy(scratch, skb->data, skb->len);
382 ei_block_output(dev, ETH_ZLEN, scratch, ei_local->tx_start_page);
385 NS8390_trigger_send(dev, send_length, ei_local->tx_start_page);
386 dev->trans_start = jiffies;
387 netif_stop_queue(dev);
389 #endif /* EI_PINGPONG */
391 /* Turn 8390 interrupts back on. */
392 ei_local->irqlock = 0;
393 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
395 spin_unlock(&ei_local->page_lock);
396 enable_irq(dev->irq);
399 ei_local->stat.tx_bytes += send_length;
405 * ei_interrupt - handle the interrupts from an 8390
406 * @irq: interrupt number
407 * @dev_id: a pointer to the net_device
410 * Handle the ether interface interrupts. We pull packets from
411 * the 8390 via the card specific functions and fire them at the networking
412 * stack. We also handle transmit completions and wake the transmit path if
413 * necessary. We also update the counters and do other housekeeping as
417 irqreturn_t ei_interrupt(int irq, void *dev_id, struct pt_regs * regs)
419 struct net_device *dev = dev_id;
421 int interrupts, nr_serviced = 0;
422 struct ei_device *ei_local;
426 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
430 e8390_base = dev->base_addr;
431 ei_local = (struct ei_device *) netdev_priv(dev);
434 * Protect the irq test too.
437 spin_lock(&ei_local->page_lock);
439 if (ei_local->irqlock)
441 #if 1 /* This might just be an interrupt for a PCI device sharing this line */
442 /* The "irqlock" check is only for testing. */
443 printk(ei_local->irqlock
444 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
445 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
446 dev->name, inb_p(e8390_base + EN0_ISR),
447 inb_p(e8390_base + EN0_IMR));
449 spin_unlock(&ei_local->page_lock);
453 /* Change to page 0 and read the intr status reg. */
454 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
456 printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name,
457 inb_p(e8390_base + EN0_ISR));
459 /* !!Assumption!! -- we stay in page 0. Don't break this. */
460 while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
461 && ++nr_serviced < MAX_SERVICE)
463 if (!netif_running(dev)) {
464 printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name);
465 /* rmk - acknowledge the interrupts */
466 outb_p(interrupts, e8390_base + EN0_ISR);
470 if (interrupts & ENISR_OVER)
472 else if (interrupts & (ENISR_RX+ENISR_RX_ERR))
474 /* Got a good (?) packet. */
477 /* Push the next to-transmit packet through. */
478 if (interrupts & ENISR_TX)
480 else if (interrupts & ENISR_TX_ERR)
483 if (interrupts & ENISR_COUNTERS)
485 ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
486 ei_local->stat.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
487 ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
488 outb_p(ENISR_COUNTERS, e8390_base + EN0_ISR); /* Ack intr. */
491 /* Ignore any RDC interrupts that make it back to here. */
492 if (interrupts & ENISR_RDC)
494 outb_p(ENISR_RDC, e8390_base + EN0_ISR);
497 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
500 if (interrupts && ei_debug)
502 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
503 if (nr_serviced >= MAX_SERVICE)
505 /* 0xFF is valid for a card removal */
507 printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n",
508 dev->name, interrupts);
509 outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
511 printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts);
512 outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
515 spin_unlock(&ei_local->page_lock);
516 return IRQ_RETVAL(nr_serviced > 0);
519 #ifdef CONFIG_NET_POLL_CONTROLLER
520 void ei_poll(struct net_device *dev)
522 disable_irq(dev->irq);
523 ei_interrupt(dev->irq, dev, NULL);
524 enable_irq(dev->irq);
529 * ei_tx_err - handle transmitter error
530 * @dev: network device which threw the exception
532 * A transmitter error has happened. Most likely excess collisions (which
533 * is a fairly normal condition). If the error is one where the Tx will
534 * have been aborted, we try and send another one right away, instead of
535 * letting the failed packet sit and collect dust in the Tx buffer. This
536 * is a much better solution as it avoids kernel based Tx timeouts, and
537 * an unnecessary card reset.
539 * Called with lock held.
542 static void ei_tx_err(struct net_device *dev)
544 long e8390_base = dev->base_addr;
545 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
546 unsigned char txsr = inb_p(e8390_base+EN0_TSR);
547 unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
549 #ifdef VERBOSE_ERROR_DUMP
550 printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
551 if (txsr & ENTSR_ABT)
552 printk("excess-collisions ");
554 printk("non-deferral ");
555 if (txsr & ENTSR_CRS)
556 printk("lost-carrier ");
558 printk("FIFO-underrun ");
559 if (txsr & ENTSR_CDH)
560 printk("lost-heartbeat ");
564 outb_p(ENISR_TX_ERR, e8390_base + EN0_ISR); /* Ack intr. */
570 ei_local->stat.tx_errors++;
571 if (txsr & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
572 if (txsr & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
573 if (txsr & ENTSR_OWC) ei_local->stat.tx_window_errors++;
578 * ei_tx_intr - transmit interrupt handler
579 * @dev: network device for which tx intr is handled
581 * We have finished a transmit: check for errors and then trigger the next
582 * packet to be sent. Called with lock held.
585 static void ei_tx_intr(struct net_device *dev)
587 long e8390_base = dev->base_addr;
588 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
589 int status = inb(e8390_base + EN0_TSR);
591 outb_p(ENISR_TX, e8390_base + EN0_ISR); /* Ack intr. */
596 * There are two Tx buffers, see which one finished, and trigger
597 * the send of another one if it exists.
601 if (ei_local->tx1 < 0)
603 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
604 printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n",
605 ei_local->name, ei_local->lasttx, ei_local->tx1);
607 if (ei_local->tx2 > 0)
610 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
611 dev->trans_start = jiffies;
613 ei_local->lasttx = 2;
615 else ei_local->lasttx = 20, ei_local->txing = 0;
617 else if (ei_local->tx2 < 0)
619 if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
620 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
621 ei_local->name, ei_local->lasttx, ei_local->tx2);
623 if (ei_local->tx1 > 0)
626 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
627 dev->trans_start = jiffies;
629 ei_local->lasttx = 1;
632 ei_local->lasttx = 10, ei_local->txing = 0;
634 // else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
635 // dev->name, ei_local->lasttx);
637 #else /* EI_PINGPONG */
639 * Single Tx buffer: mark it free so another packet can be loaded.
644 /* Minimize Tx latency: update the statistics after we restart TXing. */
645 if (status & ENTSR_COL)
646 ei_local->stat.collisions++;
647 if (status & ENTSR_PTX)
648 ei_local->stat.tx_packets++;
651 ei_local->stat.tx_errors++;
652 if (status & ENTSR_ABT)
654 ei_local->stat.tx_aborted_errors++;
655 ei_local->stat.collisions += 16;
657 if (status & ENTSR_CRS)
658 ei_local->stat.tx_carrier_errors++;
659 if (status & ENTSR_FU)
660 ei_local->stat.tx_fifo_errors++;
661 if (status & ENTSR_CDH)
662 ei_local->stat.tx_heartbeat_errors++;
663 if (status & ENTSR_OWC)
664 ei_local->stat.tx_window_errors++;
666 netif_wake_queue(dev);
670 * ei_receive - receive some packets
671 * @dev: network device with which receive will be run
673 * We have a good packet(s), get it/them out of the buffers.
674 * Called with lock held.
677 static void ei_receive(struct net_device *dev)
679 long e8390_base = dev->base_addr;
680 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
681 unsigned char rxing_page, this_frame, next_frame;
682 unsigned short current_offset;
683 int rx_pkt_count = 0;
684 struct e8390_pkt_hdr rx_frame;
685 int num_rx_pages = ei_local->stop_page-ei_local->rx_start_page;
687 while (++rx_pkt_count < 10)
689 int pkt_len, pkt_stat;
691 /* Get the rx page (incoming packet pointer). */
692 outb_p(E8390_NODMA+E8390_PAGE1, e8390_base + E8390_CMD);
693 rxing_page = inb_p(e8390_base + EN1_CURPAG);
694 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
696 /* Remove one frame from the ring. Boundary is always a page behind. */
697 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
698 if (this_frame >= ei_local->stop_page)
699 this_frame = ei_local->rx_start_page;
701 /* Someday we'll omit the previous, iff we never get this message.
702 (There is at least one clone claimed to have a problem.)
704 Keep quiet if it looks like a card removal. One problem here
705 is that some clones crash in roughly the same way.
707 if (ei_debug > 0 && this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF))
708 printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n",
709 dev->name, this_frame, ei_local->current_page);
711 if (this_frame == rxing_page) /* Read all the frames? */
712 break; /* Done for now */
714 current_offset = this_frame << 8;
715 ei_get_8390_hdr(dev, &rx_frame, this_frame);
717 pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
718 pkt_stat = rx_frame.status;
720 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
722 /* Check for bogosity warned by 3c503 book: the status byte is never
723 written. This happened a lot during testing! This code should be
724 cleaned up someday. */
725 if (rx_frame.next != next_frame
726 && rx_frame.next != next_frame + 1
727 && rx_frame.next != next_frame - num_rx_pages
728 && rx_frame.next != next_frame + 1 - num_rx_pages) {
729 ei_local->current_page = rxing_page;
730 outb(ei_local->current_page-1, e8390_base+EN0_BOUNDARY);
731 ei_local->stat.rx_errors++;
735 if (pkt_len < 60 || pkt_len > 1518)
738 printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
739 dev->name, rx_frame.count, rx_frame.status,
741 ei_local->stat.rx_errors++;
742 ei_local->stat.rx_length_errors++;
744 else if ((pkt_stat & 0x0F) == ENRSR_RXOK)
748 skb = dev_alloc_skb(pkt_len+2);
752 printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n",
754 ei_local->stat.rx_dropped++;
759 skb_reserve(skb,2); /* IP headers on 16 byte boundaries */
761 skb_put(skb, pkt_len); /* Make room */
762 ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
763 skb->protocol=eth_type_trans(skb,dev);
765 dev->last_rx = jiffies;
766 ei_local->stat.rx_packets++;
767 ei_local->stat.rx_bytes += pkt_len;
768 if (pkt_stat & ENRSR_PHY)
769 ei_local->stat.multicast++;
775 printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
776 dev->name, rx_frame.status, rx_frame.next,
778 ei_local->stat.rx_errors++;
779 /* NB: The NIC counts CRC, frame and missed errors. */
780 if (pkt_stat & ENRSR_FO)
781 ei_local->stat.rx_fifo_errors++;
783 next_frame = rx_frame.next;
785 /* This _should_ never happen: it's here for avoiding bad clones. */
786 if (next_frame >= ei_local->stop_page) {
787 printk("%s: next frame inconsistency, %#2x\n", dev->name,
789 next_frame = ei_local->rx_start_page;
791 ei_local->current_page = next_frame;
792 outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
795 /* We used to also ack ENISR_OVER here, but that would sometimes mask
796 a real overrun, leaving the 8390 in a stopped state with rec'vr off. */
797 outb_p(ENISR_RX+ENISR_RX_ERR, e8390_base+EN0_ISR);
802 * ei_rx_overrun - handle receiver overrun
803 * @dev: network device which threw exception
805 * We have a receiver overrun: we have to kick the 8390 to get it started
806 * again. Problem is that you have to kick it exactly as NS prescribes in
807 * the updated datasheets, or "the NIC may act in an unpredictable manner."
808 * This includes causing "the NIC to defer indefinitely when it is stopped
809 * on a busy network." Ugh.
810 * Called with lock held. Don't call this with the interrupts off or your
811 * computer will hate you - it takes 10ms or so.
814 static void ei_rx_overrun(struct net_device *dev)
816 long e8390_base = dev->base_addr;
817 unsigned char was_txing, must_resend = 0;
818 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
821 * Record whether a Tx was in progress and then issue the
824 was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
825 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
828 printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name);
829 ei_local->stat.rx_over_errors++;
832 * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
833 * Early datasheets said to poll the reset bit, but now they say that
834 * it "is not a reliable indicator and subsequently should be ignored."
835 * We wait at least 10ms.
841 * Reset RBCR[01] back to zero as per magic incantation.
843 outb_p(0x00, e8390_base+EN0_RCNTLO);
844 outb_p(0x00, e8390_base+EN0_RCNTHI);
847 * See if any Tx was interrupted or not. According to NS, this
848 * step is vital, and skipping it will cause no end of havoc.
853 unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
859 * Have to enter loopback mode and then restart the NIC before
860 * you are allowed to slurp packets up off the ring.
862 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
863 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
866 * Clear the Rx ring of all the debris, and ack the interrupt.
869 outb_p(ENISR_OVER, e8390_base+EN0_ISR);
872 * Leave loopback mode, and resend any packet that got stopped.
874 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR);
876 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
880 * Collect the stats. This is called unlocked and from several contexts.
883 static struct net_device_stats *get_stats(struct net_device *dev)
885 long ioaddr = dev->base_addr;
886 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
889 /* If the card is stopped, just return the present stats. */
890 if (!netif_running(dev))
891 return &ei_local->stat;
893 spin_lock_irqsave(&ei_local->page_lock,flags);
894 /* Read the counter registers, assuming we are in page 0. */
895 ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
896 ei_local->stat.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
897 ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
898 spin_unlock_irqrestore(&ei_local->page_lock, flags);
900 return &ei_local->stat;
904 * Form the 64 bit 8390 multicast table from the linked list of addresses
905 * associated with this dev structure.
908 static inline void make_mc_bits(u8 *bits, struct net_device *dev)
910 struct dev_mc_list *dmi;
912 for (dmi=dev->mc_list; dmi; dmi=dmi->next)
915 if (dmi->dmi_addrlen != ETH_ALEN)
917 printk(KERN_INFO "%s: invalid multicast address length given.\n", dev->name);
920 crc = ether_crc(ETH_ALEN, dmi->dmi_addr);
922 * The 8390 uses the 6 most significant bits of the
923 * CRC to index the multicast table.
925 bits[crc>>29] |= (1<<((crc>>26)&7));
930 * do_set_multicast_list - set/clear multicast filter
931 * @dev: net device for which multicast filter is adjusted
933 * Set or clear the multicast filter for this adaptor. May be called
934 * from a BH in 2.1.x. Must be called with lock held.
937 static void do_set_multicast_list(struct net_device *dev)
939 long e8390_base = dev->base_addr;
941 struct ei_device *ei_local = (struct ei_device*)netdev_priv(dev);
943 if (!(dev->flags&(IFF_PROMISC|IFF_ALLMULTI)))
945 memset(ei_local->mcfilter, 0, 8);
947 make_mc_bits(ei_local->mcfilter, dev);
950 memset(ei_local->mcfilter, 0xFF, 8); /* mcast set to accept-all */
953 * DP8390 manuals don't specify any magic sequence for altering
954 * the multicast regs on an already running card. To be safe, we
955 * ensure multicast mode is off prior to loading up the new hash
956 * table. If this proves to be not enough, we can always resort
957 * to stopping the NIC, loading the table and then restarting.
959 * Bug Alert! The MC regs on the SMC 83C690 (SMC Elite and SMC
960 * Elite16) appear to be write-only. The NS 8390 data sheet lists
961 * them as r/w so this is a bug. The SMC 83C790 (SMC Ultra and
962 * Ultra32 EISA) appears to have this bug fixed.
965 if (netif_running(dev))
966 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
967 outb_p(E8390_NODMA + E8390_PAGE1, e8390_base + E8390_CMD);
968 for(i = 0; i < 8; i++)
970 outb_p(ei_local->mcfilter[i], e8390_base + EN1_MULT_SHIFT(i));
972 if(inb_p(e8390_base + EN1_MULT_SHIFT(i))!=ei_local->mcfilter[i])
973 printk(KERN_ERR "Multicast filter read/write mismap %d\n",i);
976 outb_p(E8390_NODMA + E8390_PAGE0, e8390_base + E8390_CMD);
978 if(dev->flags&IFF_PROMISC)
979 outb_p(E8390_RXCONFIG | 0x18, e8390_base + EN0_RXCR);
980 else if(dev->flags&IFF_ALLMULTI || dev->mc_list)
981 outb_p(E8390_RXCONFIG | 0x08, e8390_base + EN0_RXCR);
983 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
987 * Called without lock held. This is invoked from user context and may
988 * be parallel to just about everything else. Its also fairly quick and
989 * not called too often. Must protect against both bh and irq users
992 static void set_multicast_list(struct net_device *dev)
995 struct ei_device *ei_local = (struct ei_device*)netdev_priv(dev);
997 spin_lock_irqsave(&ei_local->page_lock, flags);
998 do_set_multicast_list(dev);
999 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1003 * ethdev_setup - init rest of 8390 device struct
1004 * @dev: network device structure to init
1006 * Initialize the rest of the 8390 device structure. Do NOT __init
1007 * this, as it is used by 8390 based modular drivers too.
1010 static void ethdev_setup(struct net_device *dev)
1012 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1016 dev->hard_start_xmit = &ei_start_xmit;
1017 dev->get_stats = get_stats;
1018 dev->set_multicast_list = &set_multicast_list;
1022 spin_lock_init(&ei_local->page_lock);
1026 * alloc_ei_netdev - alloc_etherdev counterpart for 8390
1028 * Allocate 8390-specific net_device.
1030 struct net_device *__alloc_ei_netdev(int size)
1032 return alloc_netdev(sizeof(struct ei_device) + size, "eth%d",
1039 /* This page of functions should be 8390 generic */
1040 /* Follow National Semi's recommendations for initializing the "NIC". */
1043 * NS8390_init - initialize 8390 hardware
1044 * @dev: network device to initialize
1045 * @startp: boolean. non-zero value to initiate chip processing
1047 * Must be called with lock held.
1050 void NS8390_init(struct net_device *dev, int startp)
1052 long e8390_base = dev->base_addr;
1053 struct ei_device *ei_local = (struct ei_device *) netdev_priv(dev);
1055 int endcfg = ei_local->word16
1056 ? (0x48 | ENDCFG_WTS | (ei_local->bigendian ? ENDCFG_BOS : 0))
1059 if(sizeof(struct e8390_pkt_hdr)!=4)
1060 panic("8390.c: header struct mispacked\n");
1061 /* Follow National Semi's recommendations for initing the DP83902. */
1062 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); /* 0x21 */
1063 outb_p(endcfg, e8390_base + EN0_DCFG); /* 0x48 or 0x49 */
1064 /* Clear the remote byte count registers. */
1065 outb_p(0x00, e8390_base + EN0_RCNTLO);
1066 outb_p(0x00, e8390_base + EN0_RCNTHI);
1067 /* Set to monitor and loopback mode -- this is vital!. */
1068 outb_p(E8390_RXOFF, e8390_base + EN0_RXCR); /* 0x20 */
1069 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
1070 /* Set the transmit page and receive ring. */
1071 outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
1072 ei_local->tx1 = ei_local->tx2 = 0;
1073 outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
1074 outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
1075 ei_local->current_page = ei_local->rx_start_page; /* assert boundary+1 */
1076 outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
1077 /* Clear the pending interrupts and mask. */
1078 outb_p(0xFF, e8390_base + EN0_ISR);
1079 outb_p(0x00, e8390_base + EN0_IMR);
1081 /* Copy the station address into the DS8390 registers. */
1083 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD); /* 0x61 */
1084 for(i = 0; i < 6; i++)
1086 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i));
1087 if (ei_debug > 1 && inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i])
1088 printk(KERN_ERR "Hw. address read/write mismap %d\n",i);
1091 outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
1092 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1094 netif_start_queue(dev);
1095 ei_local->tx1 = ei_local->tx2 = 0;
1096 ei_local->txing = 0;
1100 outb_p(0xff, e8390_base + EN0_ISR);
1101 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1102 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1103 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
1104 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1105 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR); /* rx on, */
1106 do_set_multicast_list(dev); /* (re)load the mcast table */
1110 /* Trigger a transmit start, assuming the length is valid.
1111 Always called with the page lock held */
1113 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
1116 long e8390_base = dev->base_addr;
1117 struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) netdev_priv(dev);
1119 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base+E8390_CMD);
1121 if (inb_p(e8390_base) & E8390_TRANS)
1123 printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n",
1127 outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
1128 outb_p(length >> 8, e8390_base + EN0_TCNTHI);
1129 outb_p(start_page, e8390_base + EN0_TPSR);
1130 outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD);
1133 EXPORT_SYMBOL(ei_open);
1134 EXPORT_SYMBOL(ei_close);
1135 EXPORT_SYMBOL(ei_interrupt);
1136 #ifdef CONFIG_NET_POLL_CONTROLLER
1137 EXPORT_SYMBOL(ei_poll);
1139 EXPORT_SYMBOL(ei_tx_timeout);
1140 EXPORT_SYMBOL(NS8390_init);
1141 EXPORT_SYMBOL(__alloc_ei_netdev);
1145 int init_module(void)
1150 void cleanup_module(void)
1155 MODULE_LICENSE("GPL");