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/sched.h>
57 #include <linux/types.h>
58 #include <linux/ptrace.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 #ifdef CONFIG_REDWOOD_4
105 #include "8390_redwood.h"
108 /* use 0 for production, 1 for verification, >2 for debug */
113 /* Index to functions. */
114 static void ei_tx_intr(struct net_device *dev);
115 static void ei_tx_err(struct net_device *dev);
116 static void ei_tx_timeout(struct net_device *dev);
117 static void ei_receive(struct net_device *dev);
118 static void ei_rx_overrun(struct net_device *dev);
120 /* Routines generic to NS8390-based boards. */
121 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
123 static void set_multicast_list(struct net_device *dev);
124 static void do_set_multicast_list(struct net_device *dev);
127 * SMP and the 8390 setup.
129 * The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
130 * a page register that controls bank and packet buffer access. We guard
131 * this with ei_local->page_lock. Nobody should assume or set the page other
132 * than zero when the lock is not held. Lock holders must restore page 0
133 * before unlocking. Even pure readers must take the lock to protect in
136 * To make life difficult the chip can also be very slow. We therefore can't
137 * just use spinlocks. For the longer lockups we disable the irq the device
138 * sits on and hold the lock. We must hold the lock because there is a dual
139 * processor case other than interrupts (get stats/set multicast list in
140 * parallel with each other and transmit).
142 * Note: in theory we can just disable the irq on the card _but_ there is
143 * a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
144 * enter lock, take the queued irq. So we waddle instead of flying.
146 * Finally by special arrangement for the purpose of being generally
147 * annoying the transmit function is called bh atomic. That places
148 * restrictions on the user context callers as disable_irq won't save
155 * ei_open - Open/initialize the board.
156 * @dev: network device to initialize
158 * This routine goes all-out, setting everything
159 * up anew at each open, even though many of these registers should only
160 * need to be set once at boot.
162 int ei_open(struct net_device *dev)
165 struct ei_device *ei_local = (struct ei_device *) dev->priv;
167 /* This can't happen unless somebody forgot to call ethdev_init(). */
168 if (ei_local == NULL)
170 printk(KERN_EMERG "%s: ei_open passed a non-existent device!\n", dev->name);
174 /* The card I/O part of the driver (e.g. 3c503) can hook a Tx timeout
175 wrapper that does e.g. media check & then calls ei_tx_timeout. */
176 if (dev->tx_timeout == NULL)
177 dev->tx_timeout = ei_tx_timeout;
178 if (dev->watchdog_timeo <= 0)
179 dev->watchdog_timeo = TX_TIMEOUT;
182 * Grab the page lock so we own the register set, then call
186 spin_lock_irqsave(&ei_local->page_lock, flags);
188 /* Set the flag before we drop the lock, That way the IRQ arrives
189 after its set and we get no silly warnings */
190 netif_start_queue(dev);
191 spin_unlock_irqrestore(&ei_local->page_lock, flags);
192 ei_local->irqlock = 0;
197 * ei_close - shut down network device
198 * @dev: network device to close
200 * Opposite of ei_open(). Only used when "ifconfig <devname> down" is done.
202 int ei_close(struct net_device *dev)
204 struct ei_device *ei_local = (struct ei_device *) dev->priv;
208 * Hold the page lock during close
211 spin_lock_irqsave(&ei_local->page_lock, flags);
213 spin_unlock_irqrestore(&ei_local->page_lock, flags);
214 netif_stop_queue(dev);
219 * ei_tx_timeout - handle transmit time out condition
220 * @dev: network device which has apparently fallen asleep
222 * Called by kernel when device never acknowledges a transmit has
223 * completed (or failed) - i.e. never posted a Tx related interrupt.
226 void ei_tx_timeout(struct net_device *dev)
228 long e8390_base = dev->base_addr;
229 struct ei_device *ei_local = (struct ei_device *) dev->priv;
230 int txsr, isr, tickssofar = jiffies - dev->trans_start;
233 ei_local->stat.tx_errors++;
235 spin_lock_irqsave(&ei_local->page_lock, flags);
236 txsr = inb(e8390_base+EN0_TSR);
237 isr = inb(e8390_base+EN0_ISR);
238 spin_unlock_irqrestore(&ei_local->page_lock, flags);
240 printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
241 dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
242 (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
244 if (!isr && !ei_local->stat.tx_packets)
246 /* The 8390 probably hasn't gotten on the cable yet. */
247 ei_local->interface_num ^= 1; /* Try a different xcvr. */
250 /* Ugly but a reset can be slow, yet must be protected */
252 disable_irq_nosync(dev->irq);
253 spin_lock(&ei_local->page_lock);
255 /* Try to restart the card. Perhaps the user has fixed something. */
259 spin_unlock(&ei_local->page_lock);
260 enable_irq(dev->irq);
261 netif_wake_queue(dev);
265 * ei_start_xmit - begin packet transmission
266 * @skb: packet to be sent
267 * @dev: network device to which packet is sent
269 * Sends a packet to an 8390 network device.
272 static int ei_start_xmit(struct sk_buff *skb, struct net_device *dev)
274 long e8390_base = dev->base_addr;
275 struct ei_device *ei_local = (struct ei_device *) dev->priv;
276 int length, send_length, output_page;
278 char scratch[ETH_ZLEN];
282 /* Mask interrupts from the ethercard.
283 SMP: We have to grab the lock here otherwise the IRQ handler
284 on another CPU can flip window and race the IRQ mask set. We end
285 up trashing the mcast filter not disabling irqs if we dont lock */
287 spin_lock_irqsave(&ei_local->page_lock, flags);
288 outb_p(0x00, e8390_base + EN0_IMR);
289 spin_unlock_irqrestore(&ei_local->page_lock, flags);
293 * Slow phase with lock held.
296 disable_irq_nosync(dev->irq);
298 spin_lock(&ei_local->page_lock);
300 ei_local->irqlock = 1;
302 send_length = ETH_ZLEN < length ? length : ETH_ZLEN;
307 * We have two Tx slots available for use. Find the first free
308 * slot, and then perform some sanity checks. With two Tx bufs,
309 * you get very close to transmitting back-to-back packets. With
310 * only one Tx buf, the transmitter sits idle while you reload the
311 * card, leaving a substantial gap between each transmitted packet.
314 if (ei_local->tx1 == 0)
316 output_page = ei_local->tx_start_page;
317 ei_local->tx1 = send_length;
318 if (ei_debug && ei_local->tx2 > 0)
319 printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
320 dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
322 else if (ei_local->tx2 == 0)
324 output_page = ei_local->tx_start_page + TX_1X_PAGES;
325 ei_local->tx2 = send_length;
326 if (ei_debug && ei_local->tx1 > 0)
327 printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
328 dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
331 { /* We should never get here. */
333 printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
334 dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
335 ei_local->irqlock = 0;
336 netif_stop_queue(dev);
337 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
338 spin_unlock(&ei_local->page_lock);
339 enable_irq(dev->irq);
340 ei_local->stat.tx_errors++;
345 * Okay, now upload the packet and trigger a send if the transmitter
346 * isn't already sending. If it is busy, the interrupt handler will
347 * trigger the send later, upon receiving a Tx done interrupt.
350 if(length == send_length)
351 ei_block_output(dev, length, skb->data, output_page);
354 memset(scratch, 0, ETH_ZLEN);
355 memcpy(scratch, skb->data, skb->len);
356 ei_block_output(dev, ETH_ZLEN, scratch, output_page);
359 if (! ei_local->txing)
362 NS8390_trigger_send(dev, send_length, output_page);
363 dev->trans_start = jiffies;
364 if (output_page == ei_local->tx_start_page)
367 ei_local->lasttx = -1;
372 ei_local->lasttx = -2;
375 else ei_local->txqueue++;
377 if (ei_local->tx1 && ei_local->tx2)
378 netif_stop_queue(dev);
380 netif_start_queue(dev);
382 #else /* EI_PINGPONG */
385 * Only one Tx buffer in use. You need two Tx bufs to come close to
386 * back-to-back transmits. Expect a 20 -> 25% performance hit on
387 * reasonable hardware if you only use one Tx buffer.
390 if(length == send_length)
391 ei_block_output(dev, length, skb->data, ei_local->tx_start_page);
394 memset(scratch, 0, ETH_ZLEN);
395 memcpy(scratch, skb->data, skb->len);
396 ei_block_output(dev, ETH_ZLEN, scratch, ei_local->tx_start_page);
399 NS8390_trigger_send(dev, send_length, ei_local->tx_start_page);
400 dev->trans_start = jiffies;
401 netif_stop_queue(dev);
403 #endif /* EI_PINGPONG */
405 /* Turn 8390 interrupts back on. */
406 ei_local->irqlock = 0;
407 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
409 spin_unlock(&ei_local->page_lock);
410 enable_irq(dev->irq);
413 ei_local->stat.tx_bytes += send_length;
419 * ei_interrupt - handle the interrupts from an 8390
420 * @irq: interrupt number
421 * @dev_id: a pointer to the net_device
424 * Handle the ether interface interrupts. We pull packets from
425 * the 8390 via the card specific functions and fire them at the networking
426 * stack. We also handle transmit completions and wake the transmit path if
427 * neccessary. We also update the counters and do other housekeeping as
431 void ei_interrupt(int irq, void *dev_id, struct pt_regs * regs)
433 struct net_device *dev = dev_id;
435 int interrupts, nr_serviced = 0;
436 struct ei_device *ei_local;
440 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
444 e8390_base = dev->base_addr;
445 ei_local = (struct ei_device *) dev->priv;
448 * Protect the irq test too.
451 spin_lock(&ei_local->page_lock);
453 if (ei_local->irqlock)
455 #if 1 /* This might just be an interrupt for a PCI device sharing this line */
456 /* The "irqlock" check is only for testing. */
457 printk(ei_local->irqlock
458 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
459 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
460 dev->name, inb_p(e8390_base + EN0_ISR),
461 inb_p(e8390_base + EN0_IMR));
463 spin_unlock(&ei_local->page_lock);
467 /* Change to page 0 and read the intr status reg. */
468 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
470 printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name,
471 inb_p(e8390_base + EN0_ISR));
473 /* !!Assumption!! -- we stay in page 0. Don't break this. */
474 while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
475 && ++nr_serviced < MAX_SERVICE)
477 if (!netif_running(dev)) {
478 printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name);
479 /* rmk - acknowledge the interrupts */
480 outb_p(interrupts, e8390_base + EN0_ISR);
484 if (interrupts & ENISR_OVER)
486 else if (interrupts & (ENISR_RX+ENISR_RX_ERR))
488 /* Got a good (?) packet. */
491 /* Push the next to-transmit packet through. */
492 if (interrupts & ENISR_TX)
494 else if (interrupts & ENISR_TX_ERR)
497 if (interrupts & ENISR_COUNTERS)
499 ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
500 ei_local->stat.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
501 ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
502 outb_p(ENISR_COUNTERS, e8390_base + EN0_ISR); /* Ack intr. */
505 /* Ignore any RDC interrupts that make it back to here. */
506 if (interrupts & ENISR_RDC)
508 outb_p(ENISR_RDC, e8390_base + EN0_ISR);
511 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
514 if (interrupts && ei_debug)
516 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
517 if (nr_serviced >= MAX_SERVICE)
519 /* 0xFF is valid for a card removal */
521 printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n",
522 dev->name, interrupts);
523 outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
525 printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts);
526 outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
529 spin_unlock(&ei_local->page_lock);
534 * ei_tx_err - handle transmitter error
535 * @dev: network device which threw the exception
537 * A transmitter error has happened. Most likely excess collisions (which
538 * is a fairly normal condition). If the error is one where the Tx will
539 * have been aborted, we try and send another one right away, instead of
540 * letting the failed packet sit and collect dust in the Tx buffer. This
541 * is a much better solution as it avoids kernel based Tx timeouts, and
542 * an unnecessary card reset.
544 * Called with lock held.
547 static void ei_tx_err(struct net_device *dev)
549 long e8390_base = dev->base_addr;
550 struct ei_device *ei_local = (struct ei_device *) dev->priv;
551 unsigned char txsr = inb_p(e8390_base+EN0_TSR);
552 unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
554 #ifdef VERBOSE_ERROR_DUMP
555 printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
556 if (txsr & ENTSR_ABT)
557 printk("excess-collisions ");
559 printk("non-deferral ");
560 if (txsr & ENTSR_CRS)
561 printk("lost-carrier ");
563 printk("FIFO-underrun ");
564 if (txsr & ENTSR_CDH)
565 printk("lost-heartbeat ");
569 outb_p(ENISR_TX_ERR, e8390_base + EN0_ISR); /* Ack intr. */
575 ei_local->stat.tx_errors++;
576 if (txsr & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
577 if (txsr & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
578 if (txsr & ENTSR_OWC) ei_local->stat.tx_window_errors++;
583 * ei_tx_intr - transmit interrupt handler
584 * @dev: network device for which tx intr is handled
586 * We have finished a transmit: check for errors and then trigger the next
587 * packet to be sent. Called with lock held.
590 static void ei_tx_intr(struct net_device *dev)
592 long e8390_base = dev->base_addr;
593 struct ei_device *ei_local = (struct ei_device *) dev->priv;
594 int status = inb(e8390_base + EN0_TSR);
596 outb_p(ENISR_TX, e8390_base + EN0_ISR); /* Ack intr. */
601 * There are two Tx buffers, see which one finished, and trigger
602 * the send of another one if it exists.
606 if (ei_local->tx1 < 0)
608 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
609 printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n",
610 ei_local->name, ei_local->lasttx, ei_local->tx1);
612 if (ei_local->tx2 > 0)
615 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
616 dev->trans_start = jiffies;
618 ei_local->lasttx = 2;
620 else ei_local->lasttx = 20, ei_local->txing = 0;
622 else if (ei_local->tx2 < 0)
624 if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
625 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
626 ei_local->name, ei_local->lasttx, ei_local->tx2);
628 if (ei_local->tx1 > 0)
631 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
632 dev->trans_start = jiffies;
634 ei_local->lasttx = 1;
637 ei_local->lasttx = 10, ei_local->txing = 0;
639 // else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
640 // dev->name, ei_local->lasttx);
642 #else /* EI_PINGPONG */
644 * Single Tx buffer: mark it free so another packet can be loaded.
649 /* Minimize Tx latency: update the statistics after we restart TXing. */
650 if (status & ENTSR_COL)
651 ei_local->stat.collisions++;
652 if (status & ENTSR_PTX)
653 ei_local->stat.tx_packets++;
656 ei_local->stat.tx_errors++;
657 if (status & ENTSR_ABT)
659 ei_local->stat.tx_aborted_errors++;
660 ei_local->stat.collisions += 16;
662 if (status & ENTSR_CRS)
663 ei_local->stat.tx_carrier_errors++;
664 if (status & ENTSR_FU)
665 ei_local->stat.tx_fifo_errors++;
666 if (status & ENTSR_CDH)
667 ei_local->stat.tx_heartbeat_errors++;
668 if (status & ENTSR_OWC)
669 ei_local->stat.tx_window_errors++;
671 netif_wake_queue(dev);
675 * ei_receive - receive some packets
676 * @dev: network device with which receive will be run
678 * We have a good packet(s), get it/them out of the buffers.
679 * Called with lock held.
682 static void ei_receive(struct net_device *dev)
684 long e8390_base = dev->base_addr;
685 struct ei_device *ei_local = (struct ei_device *) dev->priv;
686 unsigned char rxing_page, this_frame, next_frame;
687 unsigned short current_offset;
688 int rx_pkt_count = 0;
689 struct e8390_pkt_hdr rx_frame;
690 int num_rx_pages = ei_local->stop_page-ei_local->rx_start_page;
692 while (++rx_pkt_count < 10)
694 int pkt_len, pkt_stat;
696 /* Get the rx page (incoming packet pointer). */
697 outb_p(E8390_NODMA+E8390_PAGE1, e8390_base + E8390_CMD);
698 rxing_page = inb_p(e8390_base + EN1_CURPAG);
699 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
701 /* Remove one frame from the ring. Boundary is always a page behind. */
702 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
703 if (this_frame >= ei_local->stop_page)
704 this_frame = ei_local->rx_start_page;
706 /* Someday we'll omit the previous, iff we never get this message.
707 (There is at least one clone claimed to have a problem.)
709 Keep quiet if it looks like a card removal. One problem here
710 is that some clones crash in roughly the same way.
712 if (ei_debug > 0 && this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF))
713 printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n",
714 dev->name, this_frame, ei_local->current_page);
716 if (this_frame == rxing_page) /* Read all the frames? */
717 break; /* Done for now */
719 current_offset = this_frame << 8;
720 ei_get_8390_hdr(dev, &rx_frame, this_frame);
722 pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
723 pkt_stat = rx_frame.status;
725 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
727 /* Check for bogosity warned by 3c503 book: the status byte is never
728 written. This happened a lot during testing! This code should be
729 cleaned up someday. */
730 if (rx_frame.next != next_frame
731 && rx_frame.next != next_frame + 1
732 && rx_frame.next != next_frame - num_rx_pages
733 && rx_frame.next != next_frame + 1 - num_rx_pages) {
734 ei_local->current_page = rxing_page;
735 outb(ei_local->current_page-1, e8390_base+EN0_BOUNDARY);
736 ei_local->stat.rx_errors++;
740 if (pkt_len < 60 || pkt_len > 1518)
743 printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
744 dev->name, rx_frame.count, rx_frame.status,
746 ei_local->stat.rx_errors++;
747 ei_local->stat.rx_length_errors++;
749 #ifdef CONFIG_REDWOOD_4
750 else if ((pkt_stat & 0x1F) == ENRSR_RXOK)
752 else if ((pkt_stat & 0x0F) == ENRSR_RXOK)
757 skb = dev_alloc_skb(pkt_len+2);
761 printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n",
763 ei_local->stat.rx_dropped++;
768 skb_reserve(skb,2); /* IP headers on 16 byte boundaries */
770 skb_put(skb, pkt_len); /* Make room */
771 ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
772 skb->protocol=eth_type_trans(skb,dev);
774 dev->last_rx = jiffies;
775 ei_local->stat.rx_packets++;
776 ei_local->stat.rx_bytes += pkt_len;
777 if (pkt_stat & ENRSR_PHY)
778 ei_local->stat.multicast++;
784 printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
785 dev->name, rx_frame.status, rx_frame.next,
787 ei_local->stat.rx_errors++;
788 /* NB: The NIC counts CRC, frame and missed errors. */
789 if (pkt_stat & ENRSR_FO)
790 ei_local->stat.rx_fifo_errors++;
792 next_frame = rx_frame.next;
794 /* This _should_ never happen: it's here for avoiding bad clones. */
795 if (next_frame >= ei_local->stop_page) {
796 printk("%s: next frame inconsistency, %#2x\n", dev->name,
798 next_frame = ei_local->rx_start_page;
800 ei_local->current_page = next_frame;
801 outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
804 /* We used to also ack ENISR_OVER here, but that would sometimes mask
805 a real overrun, leaving the 8390 in a stopped state with rec'vr off. */
806 outb_p(ENISR_RX+ENISR_RX_ERR, e8390_base+EN0_ISR);
811 * ei_rx_overrun - handle receiver overrun
812 * @dev: network device which threw exception
814 * We have a receiver overrun: we have to kick the 8390 to get it started
815 * again. Problem is that you have to kick it exactly as NS prescribes in
816 * the updated datasheets, or "the NIC may act in an unpredictable manner."
817 * This includes causing "the NIC to defer indefinitely when it is stopped
818 * on a busy network." Ugh.
819 * Called with lock held. Don't call this with the interrupts off or your
820 * computer will hate you - it takes 10ms or so.
823 static void ei_rx_overrun(struct net_device *dev)
825 long e8390_base = dev->base_addr;
826 unsigned char was_txing, must_resend = 0;
827 struct ei_device *ei_local = (struct ei_device *) dev->priv;
830 * Record whether a Tx was in progress and then issue the
833 was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
834 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
837 printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name);
838 ei_local->stat.rx_over_errors++;
841 * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
842 * Early datasheets said to poll the reset bit, but now they say that
843 * it "is not a reliable indicator and subsequently should be ignored."
844 * We wait at least 10ms.
850 * Reset RBCR[01] back to zero as per magic incantation.
852 outb_p(0x00, e8390_base+EN0_RCNTLO);
853 outb_p(0x00, e8390_base+EN0_RCNTHI);
856 * See if any Tx was interrupted or not. According to NS, this
857 * step is vital, and skipping it will cause no end of havoc.
862 unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
868 * Have to enter loopback mode and then restart the NIC before
869 * you are allowed to slurp packets up off the ring.
871 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
872 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
875 * Clear the Rx ring of all the debris, and ack the interrupt.
878 outb_p(ENISR_OVER, e8390_base+EN0_ISR);
881 * Leave loopback mode, and resend any packet that got stopped.
883 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR);
885 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
889 * Collect the stats. This is called unlocked and from several contexts.
892 static struct net_device_stats *get_stats(struct net_device *dev)
894 long ioaddr = dev->base_addr;
895 struct ei_device *ei_local = (struct ei_device *) dev->priv;
898 /* If the card is stopped, just return the present stats. */
899 if (!netif_running(dev))
900 return &ei_local->stat;
902 spin_lock_irqsave(&ei_local->page_lock,flags);
903 /* Read the counter registers, assuming we are in page 0. */
904 ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
905 ei_local->stat.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
906 ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
907 spin_unlock_irqrestore(&ei_local->page_lock, flags);
909 return &ei_local->stat;
913 * Form the 64 bit 8390 multicast table from the linked list of addresses
914 * associated with this dev structure.
917 static inline void make_mc_bits(u8 *bits, struct net_device *dev)
919 struct dev_mc_list *dmi;
921 for (dmi=dev->mc_list; dmi; dmi=dmi->next)
924 if (dmi->dmi_addrlen != ETH_ALEN)
926 printk(KERN_INFO "%s: invalid multicast address length given.\n", dev->name);
929 crc = ether_crc(ETH_ALEN, dmi->dmi_addr);
931 * The 8390 uses the 6 most significant bits of the
932 * CRC to index the multicast table.
934 bits[crc>>29] |= (1<<((crc>>26)&7));
939 * do_set_multicast_list - set/clear multicast filter
940 * @dev: net device for which multicast filter is adjusted
942 * Set or clear the multicast filter for this adaptor. May be called
943 * from a BH in 2.1.x. Must be called with lock held.
946 static void do_set_multicast_list(struct net_device *dev)
948 long e8390_base = dev->base_addr;
950 struct ei_device *ei_local = (struct ei_device*)dev->priv;
952 if (!(dev->flags&(IFF_PROMISC|IFF_ALLMULTI)))
954 memset(ei_local->mcfilter, 0, 8);
956 make_mc_bits(ei_local->mcfilter, dev);
959 memset(ei_local->mcfilter, 0xFF, 8); /* mcast set to accept-all */
962 * DP8390 manuals don't specify any magic sequence for altering
963 * the multicast regs on an already running card. To be safe, we
964 * ensure multicast mode is off prior to loading up the new hash
965 * table. If this proves to be not enough, we can always resort
966 * to stopping the NIC, loading the table and then restarting.
968 * Bug Alert! The MC regs on the SMC 83C690 (SMC Elite and SMC
969 * Elite16) appear to be write-only. The NS 8390 data sheet lists
970 * them as r/w so this is a bug. The SMC 83C790 (SMC Ultra and
971 * Ultra32 EISA) appears to have this bug fixed.
974 if (netif_running(dev))
975 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
976 outb_p(E8390_NODMA + E8390_PAGE1, e8390_base + E8390_CMD);
977 for(i = 0; i < 8; i++)
979 outb_p(ei_local->mcfilter[i], e8390_base + EN1_MULT_SHIFT(i));
981 if(inb_p(e8390_base + EN1_MULT_SHIFT(i))!=ei_local->mcfilter[i])
982 printk(KERN_ERR "Multicast filter read/write mismap %d\n",i);
985 outb_p(E8390_NODMA + E8390_PAGE0, e8390_base + E8390_CMD);
987 if(dev->flags&IFF_PROMISC)
988 outb_p(E8390_RXCONFIG | 0x18, e8390_base + EN0_RXCR);
989 else if(dev->flags&IFF_ALLMULTI || dev->mc_list)
990 outb_p(E8390_RXCONFIG | 0x08, e8390_base + EN0_RXCR);
992 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
996 * Called without lock held. This is invoked from user context and may
997 * be parallel to just about everything else. Its also fairly quick and
998 * not called too often. Must protect against both bh and irq users
1001 static void set_multicast_list(struct net_device *dev)
1003 unsigned long flags;
1004 struct ei_device *ei_local = (struct ei_device*)dev->priv;
1006 spin_lock_irqsave(&ei_local->page_lock, flags);
1007 do_set_multicast_list(dev);
1008 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1012 * ethdev_init - init rest of 8390 device struct
1013 * @dev: network device structure to init
1015 * Initialize the rest of the 8390 device structure. Do NOT __init
1016 * this, as it is used by 8390 based modular drivers too.
1019 int ethdev_init(struct net_device *dev)
1024 if (dev->priv == NULL)
1026 struct ei_device *ei_local;
1028 dev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL);
1029 if (dev->priv == NULL)
1031 memset(dev->priv, 0, sizeof(struct ei_device));
1032 ei_local = (struct ei_device *)dev->priv;
1033 spin_lock_init(&ei_local->page_lock);
1036 dev->hard_start_xmit = &ei_start_xmit;
1037 dev->get_stats = get_stats;
1038 dev->set_multicast_list = &set_multicast_list;
1047 /* This page of functions should be 8390 generic */
1048 /* Follow National Semi's recommendations for initializing the "NIC". */
1051 * NS8390_init - initialize 8390 hardware
1052 * @dev: network device to initialize
1053 * @startp: boolean. non-zero value to initiate chip processing
1055 * Must be called with lock held.
1058 void NS8390_init(struct net_device *dev, int startp)
1060 long e8390_base = dev->base_addr;
1061 struct ei_device *ei_local = (struct ei_device *) dev->priv;
1063 #ifdef CONFIG_REDWOOD_4
1064 int endcfg = ei_local->word16
1065 ? (0x28 | ENDCFG_WTS )
1068 int endcfg = ei_local->word16
1069 ? (0x48 | ENDCFG_WTS | (ei_local->bigendian ? ENDCFG_BOS : 0))
1073 if(sizeof(struct e8390_pkt_hdr)!=4)
1074 panic("8390.c: header struct mispacked\n");
1075 /* Follow National Semi's recommendations for initing the DP83902. */
1076 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); /* 0x21 */
1077 outb_p(endcfg, e8390_base + EN0_DCFG); /* 0x48 or 0x49 */
1078 /* Clear the remote byte count registers. */
1079 outb_p(0x00, e8390_base + EN0_RCNTLO);
1080 outb_p(0x00, e8390_base + EN0_RCNTHI);
1081 /* Set to monitor and loopback mode -- this is vital!. */
1082 outb_p(E8390_RXOFF, e8390_base + EN0_RXCR); /* 0x20 */
1083 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
1084 /* Set the transmit page and receive ring. */
1085 outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
1086 ei_local->tx1 = ei_local->tx2 = 0;
1087 outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
1088 outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
1089 ei_local->current_page = ei_local->rx_start_page; /* assert boundary+1 */
1090 outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
1091 /* Clear the pending interrupts and mask. */
1092 outb_p(0xFF, e8390_base + EN0_ISR);
1093 outb_p(0x00, e8390_base + EN0_IMR);
1095 /* Copy the station address into the DS8390 registers. */
1097 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD); /* 0x61 */
1098 for(i = 0; i < 6; i++)
1100 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i));
1101 if(inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i])
1102 printk(KERN_ERR "Hw. address read/write mismap %d\n",i);
1105 outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
1106 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1108 netif_start_queue(dev);
1109 ei_local->tx1 = ei_local->tx2 = 0;
1110 ei_local->txing = 0;
1114 outb_p(0xff, e8390_base + EN0_ISR);
1115 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1116 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1117 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
1118 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1119 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR); /* rx on, */
1120 do_set_multicast_list(dev); /* (re)load the mcast table */
1124 /* Trigger a transmit start, assuming the length is valid.
1125 Always called with the page lock held */
1127 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
1130 long e8390_base = dev->base_addr;
1131 struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) dev->priv;
1133 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base+E8390_CMD);
1135 if (inb_p(e8390_base) & E8390_TRANS)
1137 printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n",
1141 outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
1142 outb_p(length >> 8, e8390_base + EN0_TCNTHI);
1143 outb_p(start_page, e8390_base + EN0_TPSR);
1144 outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD);
1147 EXPORT_SYMBOL(ei_open);
1148 EXPORT_SYMBOL(ei_close);
1149 EXPORT_SYMBOL(ei_interrupt);
1150 EXPORT_SYMBOL(ei_tx_timeout);
1151 EXPORT_SYMBOL(ethdev_init);
1152 EXPORT_SYMBOL(NS8390_init);
1156 int init_module(void)
1161 void cleanup_module(void)
1166 MODULE_LICENSE("GPL");
1171 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 8390.c"
1172 * version-control: t
1173 * kept-new-versions: 5