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.
45 Hayato Fujiwara : Add m32r support.
46 Paul Gortmaker : use skb_padto() instead of stack scratch area
49 The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
53 static const char version
[] =
54 "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
56 #include <linux/module.h>
57 #include <linux/kernel.h>
58 #include <linux/jiffies.h>
60 #include <linux/types.h>
61 #include <linux/string.h>
62 #include <linux/bitops.h>
63 #include <asm/system.h>
64 #include <asm/uaccess.h>
67 #include <linux/delay.h>
68 #include <linux/errno.h>
69 #include <linux/fcntl.h>
71 #include <linux/interrupt.h>
72 #include <linux/init.h>
73 #include <linux/crc32.h>
75 #include <linux/netdevice.h>
76 #include <linux/etherdevice.h>
83 /* These are the operational function interfaces to board-specific
85 void reset_8390(struct net_device *dev)
86 Resets the board associated with DEV, including a hardware reset of
87 the 8390. This is only called when there is a transmit timeout, and
88 it is always followed by 8390_init().
89 void block_output(struct net_device *dev, int count, const unsigned char *buf,
91 Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The
92 "page" value uses the 8390's 256-byte pages.
93 void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page)
94 Read the 4 byte, page aligned 8390 header. *If* there is a
95 subsequent read, it will be of the rest of the packet.
96 void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
97 Read COUNT bytes from the packet buffer into the skb data area. Start
98 reading from RING_OFFSET, the address as the 8390 sees it. This will always
99 follow the read of the 8390 header.
101 #define ei_reset_8390 (ei_local->reset_8390)
102 #define ei_block_output (ei_local->block_output)
103 #define ei_block_input (ei_local->block_input)
104 #define ei_get_8390_hdr (ei_local->get_8390_hdr)
106 /* use 0 for production, 1 for verification, >2 for debug */
111 /* Index to functions. */
112 static void ei_tx_intr(struct net_device
*dev
);
113 static void ei_tx_err(struct net_device
*dev
);
114 static void ei_tx_timeout(struct net_device
*dev
);
115 static void ei_receive(struct net_device
*dev
);
116 static void ei_rx_overrun(struct net_device
*dev
);
118 /* Routines generic to NS8390-based boards. */
119 static void NS8390_trigger_send(struct net_device
*dev
, unsigned int length
,
121 static void set_multicast_list(struct net_device
*dev
);
122 static void do_set_multicast_list(struct net_device
*dev
);
125 * SMP and the 8390 setup.
127 * The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
128 * a page register that controls bank and packet buffer access. We guard
129 * this with ei_local->page_lock. Nobody should assume or set the page other
130 * than zero when the lock is not held. Lock holders must restore page 0
131 * before unlocking. Even pure readers must take the lock to protect in
134 * To make life difficult the chip can also be very slow. We therefore can't
135 * just use spinlocks. For the longer lockups we disable the irq the device
136 * sits on and hold the lock. We must hold the lock because there is a dual
137 * processor case other than interrupts (get stats/set multicast list in
138 * parallel with each other and transmit).
140 * Note: in theory we can just disable the irq on the card _but_ there is
141 * a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
142 * enter lock, take the queued irq. So we waddle instead of flying.
144 * Finally by special arrangement for the purpose of being generally
145 * annoying the transmit function is called bh atomic. That places
146 * restrictions on the user context callers as disable_irq won't save
153 * ei_open - Open/initialize the board.
154 * @dev: network device to initialize
156 * This routine goes all-out, setting everything
157 * up anew at each open, even though many of these registers should only
158 * need to be set once at boot.
160 int ei_open(struct net_device
*dev
)
163 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
165 /* The card I/O part of the driver (e.g. 3c503) can hook a Tx timeout
166 wrapper that does e.g. media check & then calls ei_tx_timeout. */
167 if (dev
->tx_timeout
== NULL
)
168 dev
->tx_timeout
= ei_tx_timeout
;
169 if (dev
->watchdog_timeo
<= 0)
170 dev
->watchdog_timeo
= TX_TIMEOUT
;
173 * Grab the page lock so we own the register set, then call
177 spin_lock_irqsave(&ei_local
->page_lock
, flags
);
179 /* Set the flag before we drop the lock, That way the IRQ arrives
180 after its set and we get no silly warnings */
181 netif_start_queue(dev
);
182 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
183 ei_local
->irqlock
= 0;
188 * ei_close - shut down network device
189 * @dev: network device to close
191 * Opposite of ei_open(). Only used when "ifconfig <devname> down" is done.
193 int ei_close(struct net_device
*dev
)
195 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
199 * Hold the page lock during close
202 spin_lock_irqsave(&ei_local
->page_lock
, flags
);
204 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
205 netif_stop_queue(dev
);
210 * ei_tx_timeout - handle transmit time out condition
211 * @dev: network device which has apparently fallen asleep
213 * Called by kernel when device never acknowledges a transmit has
214 * completed (or failed) - i.e. never posted a Tx related interrupt.
217 void ei_tx_timeout(struct net_device
*dev
)
219 long e8390_base
= dev
->base_addr
;
220 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
221 int txsr
, isr
, tickssofar
= jiffies
- dev
->trans_start
;
224 #if defined(CONFIG_M32R) && defined(CONFIG_SMP)
227 local_irq_save(flags
);
228 icucr
= inl(M32R_ICU_CR1_PORTL
);
229 icucr
|= M32R_ICUCR_ISMOD11
;
230 outl(icucr
, M32R_ICU_CR1_PORTL
);
231 local_irq_restore(flags
);
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_lockdep(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_lockdep(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
*) netdev_priv(dev
);
276 int send_length
= skb
->len
, output_page
;
279 char *data
= skb
->data
;
281 if (skb
->len
< ETH_ZLEN
) {
282 memset(buf
, 0, ETH_ZLEN
); /* more efficient than doing just the needed bits */
283 memcpy(buf
, data
, skb
->len
);
284 send_length
= ETH_ZLEN
;
288 /* Mask interrupts from the ethercard.
289 SMP: We have to grab the lock here otherwise the IRQ handler
290 on another CPU can flip window and race the IRQ mask set. We end
291 up trashing the mcast filter not disabling irqs if we don't lock */
293 spin_lock_irqsave(&ei_local
->page_lock
, flags
);
294 outb_p(0x00, e8390_base
+ EN0_IMR
);
295 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
299 * Slow phase with lock held.
302 disable_irq_nosync_lockdep_irqsave(dev
->irq
, &flags
);
304 spin_lock(&ei_local
->page_lock
);
306 ei_local
->irqlock
= 1;
309 * We have two Tx slots available for use. Find the first free
310 * slot, and then perform some sanity checks. With two Tx bufs,
311 * you get very close to transmitting back-to-back packets. With
312 * only one Tx buf, the transmitter sits idle while you reload the
313 * card, leaving a substantial gap between each transmitted packet.
316 if (ei_local
->tx1
== 0)
318 output_page
= ei_local
->tx_start_page
;
319 ei_local
->tx1
= send_length
;
320 if (ei_debug
&& ei_local
->tx2
> 0)
321 printk(KERN_DEBUG
"%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
322 dev
->name
, ei_local
->tx2
, ei_local
->lasttx
, ei_local
->txing
);
324 else if (ei_local
->tx2
== 0)
326 output_page
= ei_local
->tx_start_page
+ TX_PAGES
/2;
327 ei_local
->tx2
= send_length
;
328 if (ei_debug
&& ei_local
->tx1
> 0)
329 printk(KERN_DEBUG
"%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
330 dev
->name
, ei_local
->tx1
, ei_local
->lasttx
, ei_local
->txing
);
333 { /* We should never get here. */
335 printk(KERN_DEBUG
"%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
336 dev
->name
, ei_local
->tx1
, ei_local
->tx2
, ei_local
->lasttx
);
337 ei_local
->irqlock
= 0;
338 netif_stop_queue(dev
);
339 outb_p(ENISR_ALL
, e8390_base
+ EN0_IMR
);
340 spin_unlock(&ei_local
->page_lock
);
341 enable_irq_lockdep_irqrestore(dev
->irq
, &flags
);
342 ei_local
->stat
.tx_errors
++;
347 * Okay, now upload the packet and trigger a send if the transmitter
348 * isn't already sending. If it is busy, the interrupt handler will
349 * trigger the send later, upon receiving a Tx done interrupt.
352 ei_block_output(dev
, send_length
, data
, output_page
);
354 if (! ei_local
->txing
)
357 NS8390_trigger_send(dev
, send_length
, output_page
);
358 dev
->trans_start
= jiffies
;
359 if (output_page
== ei_local
->tx_start_page
)
362 ei_local
->lasttx
= -1;
367 ei_local
->lasttx
= -2;
370 else ei_local
->txqueue
++;
372 if (ei_local
->tx1
&& ei_local
->tx2
)
373 netif_stop_queue(dev
);
375 netif_start_queue(dev
);
377 /* Turn 8390 interrupts back on. */
378 ei_local
->irqlock
= 0;
379 outb_p(ENISR_ALL
, e8390_base
+ EN0_IMR
);
381 spin_unlock(&ei_local
->page_lock
);
382 enable_irq_lockdep_irqrestore(dev
->irq
, &flags
);
385 ei_local
->stat
.tx_bytes
+= send_length
;
391 * ei_interrupt - handle the interrupts from an 8390
392 * @irq: interrupt number
393 * @dev_id: a pointer to the net_device
395 * Handle the ether interface interrupts. We pull packets from
396 * the 8390 via the card specific functions and fire them at the networking
397 * stack. We also handle transmit completions and wake the transmit path if
398 * necessary. We also update the counters and do other housekeeping as
402 irqreturn_t
ei_interrupt(int irq
, void *dev_id
)
404 struct net_device
*dev
= dev_id
;
406 int interrupts
, nr_serviced
= 0;
407 struct ei_device
*ei_local
;
409 e8390_base
= dev
->base_addr
;
410 ei_local
= netdev_priv(dev
);
413 * Protect the irq test too.
416 spin_lock(&ei_local
->page_lock
);
418 if (ei_local
->irqlock
)
420 #if 1 /* This might just be an interrupt for a PCI device sharing this line */
421 /* The "irqlock" check is only for testing. */
422 printk(ei_local
->irqlock
423 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
424 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
425 dev
->name
, inb_p(e8390_base
+ EN0_ISR
),
426 inb_p(e8390_base
+ EN0_IMR
));
428 spin_unlock(&ei_local
->page_lock
);
432 /* Change to page 0 and read the intr status reg. */
433 outb_p(E8390_NODMA
+E8390_PAGE0
, e8390_base
+ E8390_CMD
);
435 printk(KERN_DEBUG
"%s: interrupt(isr=%#2.2x).\n", dev
->name
,
436 inb_p(e8390_base
+ EN0_ISR
));
438 /* !!Assumption!! -- we stay in page 0. Don't break this. */
439 while ((interrupts
= inb_p(e8390_base
+ EN0_ISR
)) != 0
440 && ++nr_serviced
< MAX_SERVICE
)
442 if (!netif_running(dev
)) {
443 printk(KERN_WARNING
"%s: interrupt from stopped card\n", dev
->name
);
444 /* rmk - acknowledge the interrupts */
445 outb_p(interrupts
, e8390_base
+ EN0_ISR
);
449 if (interrupts
& ENISR_OVER
)
451 else if (interrupts
& (ENISR_RX
+ENISR_RX_ERR
))
453 /* Got a good (?) packet. */
456 /* Push the next to-transmit packet through. */
457 if (interrupts
& ENISR_TX
)
459 else if (interrupts
& ENISR_TX_ERR
)
462 if (interrupts
& ENISR_COUNTERS
)
464 ei_local
->stat
.rx_frame_errors
+= inb_p(e8390_base
+ EN0_COUNTER0
);
465 ei_local
->stat
.rx_crc_errors
+= inb_p(e8390_base
+ EN0_COUNTER1
);
466 ei_local
->stat
.rx_missed_errors
+= inb_p(e8390_base
+ EN0_COUNTER2
);
467 outb_p(ENISR_COUNTERS
, e8390_base
+ EN0_ISR
); /* Ack intr. */
470 /* Ignore any RDC interrupts that make it back to here. */
471 if (interrupts
& ENISR_RDC
)
473 outb_p(ENISR_RDC
, e8390_base
+ EN0_ISR
);
476 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_START
, e8390_base
+ E8390_CMD
);
479 if (interrupts
&& ei_debug
)
481 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_START
, e8390_base
+ E8390_CMD
);
482 if (nr_serviced
>= MAX_SERVICE
)
484 /* 0xFF is valid for a card removal */
486 printk(KERN_WARNING
"%s: Too much work at interrupt, status %#2.2x\n",
487 dev
->name
, interrupts
);
488 outb_p(ENISR_ALL
, e8390_base
+ EN0_ISR
); /* Ack. most intrs. */
490 printk(KERN_WARNING
"%s: unknown interrupt %#2x\n", dev
->name
, interrupts
);
491 outb_p(0xff, e8390_base
+ EN0_ISR
); /* Ack. all intrs. */
494 spin_unlock(&ei_local
->page_lock
);
495 return IRQ_RETVAL(nr_serviced
> 0);
498 #ifdef CONFIG_NET_POLL_CONTROLLER
499 void ei_poll(struct net_device
*dev
)
501 disable_irq_lockdep(dev
->irq
);
502 ei_interrupt(dev
->irq
, dev
);
503 enable_irq_lockdep(dev
->irq
);
508 * ei_tx_err - handle transmitter error
509 * @dev: network device which threw the exception
511 * A transmitter error has happened. Most likely excess collisions (which
512 * is a fairly normal condition). If the error is one where the Tx will
513 * have been aborted, we try and send another one right away, instead of
514 * letting the failed packet sit and collect dust in the Tx buffer. This
515 * is a much better solution as it avoids kernel based Tx timeouts, and
516 * an unnecessary card reset.
518 * Called with lock held.
521 static void ei_tx_err(struct net_device
*dev
)
523 long e8390_base
= dev
->base_addr
;
524 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
525 unsigned char txsr
= inb_p(e8390_base
+EN0_TSR
);
526 unsigned char tx_was_aborted
= txsr
& (ENTSR_ABT
+ENTSR_FU
);
528 #ifdef VERBOSE_ERROR_DUMP
529 printk(KERN_DEBUG
"%s: transmitter error (%#2x): ", dev
->name
, txsr
);
530 if (txsr
& ENTSR_ABT
)
531 printk("excess-collisions ");
533 printk("non-deferral ");
534 if (txsr
& ENTSR_CRS
)
535 printk("lost-carrier ");
537 printk("FIFO-underrun ");
538 if (txsr
& ENTSR_CDH
)
539 printk("lost-heartbeat ");
543 outb_p(ENISR_TX_ERR
, e8390_base
+ EN0_ISR
); /* Ack intr. */
549 ei_local
->stat
.tx_errors
++;
550 if (txsr
& ENTSR_CRS
) ei_local
->stat
.tx_carrier_errors
++;
551 if (txsr
& ENTSR_CDH
) ei_local
->stat
.tx_heartbeat_errors
++;
552 if (txsr
& ENTSR_OWC
) ei_local
->stat
.tx_window_errors
++;
557 * ei_tx_intr - transmit interrupt handler
558 * @dev: network device for which tx intr is handled
560 * We have finished a transmit: check for errors and then trigger the next
561 * packet to be sent. Called with lock held.
564 static void ei_tx_intr(struct net_device
*dev
)
566 long e8390_base
= dev
->base_addr
;
567 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
568 int status
= inb(e8390_base
+ EN0_TSR
);
570 outb_p(ENISR_TX
, e8390_base
+ EN0_ISR
); /* Ack intr. */
573 * There are two Tx buffers, see which one finished, and trigger
574 * the send of another one if it exists.
578 if (ei_local
->tx1
< 0)
580 if (ei_local
->lasttx
!= 1 && ei_local
->lasttx
!= -1)
581 printk(KERN_ERR
"%s: bogus last_tx_buffer %d, tx1=%d.\n",
582 ei_local
->name
, ei_local
->lasttx
, ei_local
->tx1
);
584 if (ei_local
->tx2
> 0)
587 NS8390_trigger_send(dev
, ei_local
->tx2
, ei_local
->tx_start_page
+ 6);
588 dev
->trans_start
= jiffies
;
590 ei_local
->lasttx
= 2;
592 else ei_local
->lasttx
= 20, ei_local
->txing
= 0;
594 else if (ei_local
->tx2
< 0)
596 if (ei_local
->lasttx
!= 2 && ei_local
->lasttx
!= -2)
597 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
598 ei_local
->name
, ei_local
->lasttx
, ei_local
->tx2
);
600 if (ei_local
->tx1
> 0)
603 NS8390_trigger_send(dev
, ei_local
->tx1
, ei_local
->tx_start_page
);
604 dev
->trans_start
= jiffies
;
606 ei_local
->lasttx
= 1;
609 ei_local
->lasttx
= 10, ei_local
->txing
= 0;
611 // else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
612 // dev->name, ei_local->lasttx);
614 /* Minimize Tx latency: update the statistics after we restart TXing. */
615 if (status
& ENTSR_COL
)
616 ei_local
->stat
.collisions
++;
617 if (status
& ENTSR_PTX
)
618 ei_local
->stat
.tx_packets
++;
621 ei_local
->stat
.tx_errors
++;
622 if (status
& ENTSR_ABT
)
624 ei_local
->stat
.tx_aborted_errors
++;
625 ei_local
->stat
.collisions
+= 16;
627 if (status
& ENTSR_CRS
)
628 ei_local
->stat
.tx_carrier_errors
++;
629 if (status
& ENTSR_FU
)
630 ei_local
->stat
.tx_fifo_errors
++;
631 if (status
& ENTSR_CDH
)
632 ei_local
->stat
.tx_heartbeat_errors
++;
633 if (status
& ENTSR_OWC
)
634 ei_local
->stat
.tx_window_errors
++;
636 netif_wake_queue(dev
);
640 * ei_receive - receive some packets
641 * @dev: network device with which receive will be run
643 * We have a good packet(s), get it/them out of the buffers.
644 * Called with lock held.
647 static void ei_receive(struct net_device
*dev
)
649 long e8390_base
= dev
->base_addr
;
650 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
651 unsigned char rxing_page
, this_frame
, next_frame
;
652 unsigned short current_offset
;
653 int rx_pkt_count
= 0;
654 struct e8390_pkt_hdr rx_frame
;
655 int num_rx_pages
= ei_local
->stop_page
-ei_local
->rx_start_page
;
657 while (++rx_pkt_count
< 10)
659 int pkt_len
, pkt_stat
;
661 /* Get the rx page (incoming packet pointer). */
662 outb_p(E8390_NODMA
+E8390_PAGE1
, e8390_base
+ E8390_CMD
);
663 rxing_page
= inb_p(e8390_base
+ EN1_CURPAG
);
664 outb_p(E8390_NODMA
+E8390_PAGE0
, e8390_base
+ E8390_CMD
);
666 /* Remove one frame from the ring. Boundary is always a page behind. */
667 this_frame
= inb_p(e8390_base
+ EN0_BOUNDARY
) + 1;
668 if (this_frame
>= ei_local
->stop_page
)
669 this_frame
= ei_local
->rx_start_page
;
671 /* Someday we'll omit the previous, iff we never get this message.
672 (There is at least one clone claimed to have a problem.)
674 Keep quiet if it looks like a card removal. One problem here
675 is that some clones crash in roughly the same way.
677 if (ei_debug
> 0 && this_frame
!= ei_local
->current_page
&& (this_frame
!=0x0 || rxing_page
!=0xFF))
678 printk(KERN_ERR
"%s: mismatched read page pointers %2x vs %2x.\n",
679 dev
->name
, this_frame
, ei_local
->current_page
);
681 if (this_frame
== rxing_page
) /* Read all the frames? */
682 break; /* Done for now */
684 current_offset
= this_frame
<< 8;
685 ei_get_8390_hdr(dev
, &rx_frame
, this_frame
);
687 pkt_len
= rx_frame
.count
- sizeof(struct e8390_pkt_hdr
);
688 pkt_stat
= rx_frame
.status
;
690 next_frame
= this_frame
+ 1 + ((pkt_len
+4)>>8);
692 /* Check for bogosity warned by 3c503 book: the status byte is never
693 written. This happened a lot during testing! This code should be
694 cleaned up someday. */
695 if (rx_frame
.next
!= next_frame
696 && rx_frame
.next
!= next_frame
+ 1
697 && rx_frame
.next
!= next_frame
- num_rx_pages
698 && rx_frame
.next
!= next_frame
+ 1 - num_rx_pages
) {
699 ei_local
->current_page
= rxing_page
;
700 outb(ei_local
->current_page
-1, e8390_base
+EN0_BOUNDARY
);
701 ei_local
->stat
.rx_errors
++;
705 if (pkt_len
< 60 || pkt_len
> 1518)
708 printk(KERN_DEBUG
"%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
709 dev
->name
, rx_frame
.count
, rx_frame
.status
,
711 ei_local
->stat
.rx_errors
++;
712 ei_local
->stat
.rx_length_errors
++;
714 else if ((pkt_stat
& 0x0F) == ENRSR_RXOK
)
718 skb
= dev_alloc_skb(pkt_len
+2);
722 printk(KERN_DEBUG
"%s: Couldn't allocate a sk_buff of size %d.\n",
724 ei_local
->stat
.rx_dropped
++;
729 skb_reserve(skb
,2); /* IP headers on 16 byte boundaries */
731 skb_put(skb
, pkt_len
); /* Make room */
732 ei_block_input(dev
, pkt_len
, skb
, current_offset
+ sizeof(rx_frame
));
733 skb
->protocol
=eth_type_trans(skb
,dev
);
735 dev
->last_rx
= jiffies
;
736 ei_local
->stat
.rx_packets
++;
737 ei_local
->stat
.rx_bytes
+= pkt_len
;
738 if (pkt_stat
& ENRSR_PHY
)
739 ei_local
->stat
.multicast
++;
745 printk(KERN_DEBUG
"%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
746 dev
->name
, rx_frame
.status
, rx_frame
.next
,
748 ei_local
->stat
.rx_errors
++;
749 /* NB: The NIC counts CRC, frame and missed errors. */
750 if (pkt_stat
& ENRSR_FO
)
751 ei_local
->stat
.rx_fifo_errors
++;
753 next_frame
= rx_frame
.next
;
755 /* This _should_ never happen: it's here for avoiding bad clones. */
756 if (next_frame
>= ei_local
->stop_page
) {
757 printk("%s: next frame inconsistency, %#2x\n", dev
->name
,
759 next_frame
= ei_local
->rx_start_page
;
761 ei_local
->current_page
= next_frame
;
762 outb_p(next_frame
-1, e8390_base
+EN0_BOUNDARY
);
765 /* We used to also ack ENISR_OVER here, but that would sometimes mask
766 a real overrun, leaving the 8390 in a stopped state with rec'vr off. */
767 outb_p(ENISR_RX
+ENISR_RX_ERR
, e8390_base
+EN0_ISR
);
772 * ei_rx_overrun - handle receiver overrun
773 * @dev: network device which threw exception
775 * We have a receiver overrun: we have to kick the 8390 to get it started
776 * again. Problem is that you have to kick it exactly as NS prescribes in
777 * the updated datasheets, or "the NIC may act in an unpredictable manner."
778 * This includes causing "the NIC to defer indefinitely when it is stopped
779 * on a busy network." Ugh.
780 * Called with lock held. Don't call this with the interrupts off or your
781 * computer will hate you - it takes 10ms or so.
784 static void ei_rx_overrun(struct net_device
*dev
)
786 long e8390_base
= dev
->base_addr
;
787 unsigned char was_txing
, must_resend
= 0;
788 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
791 * Record whether a Tx was in progress and then issue the
794 was_txing
= inb_p(e8390_base
+E8390_CMD
) & E8390_TRANS
;
795 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_STOP
, e8390_base
+E8390_CMD
);
798 printk(KERN_DEBUG
"%s: Receiver overrun.\n", dev
->name
);
799 ei_local
->stat
.rx_over_errors
++;
802 * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
803 * Early datasheets said to poll the reset bit, but now they say that
804 * it "is not a reliable indicator and subsequently should be ignored."
805 * We wait at least 10ms.
811 * Reset RBCR[01] back to zero as per magic incantation.
813 outb_p(0x00, e8390_base
+EN0_RCNTLO
);
814 outb_p(0x00, e8390_base
+EN0_RCNTHI
);
817 * See if any Tx was interrupted or not. According to NS, this
818 * step is vital, and skipping it will cause no end of havoc.
823 unsigned char tx_completed
= inb_p(e8390_base
+EN0_ISR
) & (ENISR_TX
+ENISR_TX_ERR
);
829 * Have to enter loopback mode and then restart the NIC before
830 * you are allowed to slurp packets up off the ring.
832 outb_p(E8390_TXOFF
, e8390_base
+ EN0_TXCR
);
833 outb_p(E8390_NODMA
+ E8390_PAGE0
+ E8390_START
, e8390_base
+ E8390_CMD
);
836 * Clear the Rx ring of all the debris, and ack the interrupt.
839 outb_p(ENISR_OVER
, e8390_base
+EN0_ISR
);
842 * Leave loopback mode, and resend any packet that got stopped.
844 outb_p(E8390_TXCONFIG
, e8390_base
+ EN0_TXCR
);
846 outb_p(E8390_NODMA
+ E8390_PAGE0
+ E8390_START
+ E8390_TRANS
, e8390_base
+ E8390_CMD
);
850 * Collect the stats. This is called unlocked and from several contexts.
853 static struct net_device_stats
*get_stats(struct net_device
*dev
)
855 long ioaddr
= dev
->base_addr
;
856 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
859 /* If the card is stopped, just return the present stats. */
860 if (!netif_running(dev
))
861 return &ei_local
->stat
;
863 spin_lock_irqsave(&ei_local
->page_lock
,flags
);
864 /* Read the counter registers, assuming we are in page 0. */
865 ei_local
->stat
.rx_frame_errors
+= inb_p(ioaddr
+ EN0_COUNTER0
);
866 ei_local
->stat
.rx_crc_errors
+= inb_p(ioaddr
+ EN0_COUNTER1
);
867 ei_local
->stat
.rx_missed_errors
+= inb_p(ioaddr
+ EN0_COUNTER2
);
868 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
870 return &ei_local
->stat
;
874 * Form the 64 bit 8390 multicast table from the linked list of addresses
875 * associated with this dev structure.
878 static inline void make_mc_bits(u8
*bits
, struct net_device
*dev
)
880 struct dev_mc_list
*dmi
;
882 for (dmi
=dev
->mc_list
; dmi
; dmi
=dmi
->next
)
885 if (dmi
->dmi_addrlen
!= ETH_ALEN
)
887 printk(KERN_INFO
"%s: invalid multicast address length given.\n", dev
->name
);
890 crc
= ether_crc(ETH_ALEN
, dmi
->dmi_addr
);
892 * The 8390 uses the 6 most significant bits of the
893 * CRC to index the multicast table.
895 bits
[crc
>>29] |= (1<<((crc
>>26)&7));
900 * do_set_multicast_list - set/clear multicast filter
901 * @dev: net device for which multicast filter is adjusted
903 * Set or clear the multicast filter for this adaptor. May be called
904 * from a BH in 2.1.x. Must be called with lock held.
907 static void do_set_multicast_list(struct net_device
*dev
)
909 long e8390_base
= dev
->base_addr
;
911 struct ei_device
*ei_local
= (struct ei_device
*)netdev_priv(dev
);
913 if (!(dev
->flags
&(IFF_PROMISC
|IFF_ALLMULTI
)))
915 memset(ei_local
->mcfilter
, 0, 8);
917 make_mc_bits(ei_local
->mcfilter
, dev
);
920 memset(ei_local
->mcfilter
, 0xFF, 8); /* mcast set to accept-all */
923 * DP8390 manuals don't specify any magic sequence for altering
924 * the multicast regs on an already running card. To be safe, we
925 * ensure multicast mode is off prior to loading up the new hash
926 * table. If this proves to be not enough, we can always resort
927 * to stopping the NIC, loading the table and then restarting.
929 * Bug Alert! The MC regs on the SMC 83C690 (SMC Elite and SMC
930 * Elite16) appear to be write-only. The NS 8390 data sheet lists
931 * them as r/w so this is a bug. The SMC 83C790 (SMC Ultra and
932 * Ultra32 EISA) appears to have this bug fixed.
935 if (netif_running(dev
))
936 outb_p(E8390_RXCONFIG
, e8390_base
+ EN0_RXCR
);
937 outb_p(E8390_NODMA
+ E8390_PAGE1
, e8390_base
+ E8390_CMD
);
938 for(i
= 0; i
< 8; i
++)
940 outb_p(ei_local
->mcfilter
[i
], e8390_base
+ EN1_MULT_SHIFT(i
));
942 if(inb_p(e8390_base
+ EN1_MULT_SHIFT(i
))!=ei_local
->mcfilter
[i
])
943 printk(KERN_ERR
"Multicast filter read/write mismap %d\n",i
);
946 outb_p(E8390_NODMA
+ E8390_PAGE0
, e8390_base
+ E8390_CMD
);
948 if(dev
->flags
&IFF_PROMISC
)
949 outb_p(E8390_RXCONFIG
| 0x18, e8390_base
+ EN0_RXCR
);
950 else if(dev
->flags
&IFF_ALLMULTI
|| dev
->mc_list
)
951 outb_p(E8390_RXCONFIG
| 0x08, e8390_base
+ EN0_RXCR
);
953 outb_p(E8390_RXCONFIG
, e8390_base
+ EN0_RXCR
);
957 * Called without lock held. This is invoked from user context and may
958 * be parallel to just about everything else. Its also fairly quick and
959 * not called too often. Must protect against both bh and irq users
962 static void set_multicast_list(struct net_device
*dev
)
965 struct ei_device
*ei_local
= (struct ei_device
*)netdev_priv(dev
);
967 spin_lock_irqsave(&ei_local
->page_lock
, flags
);
968 do_set_multicast_list(dev
);
969 spin_unlock_irqrestore(&ei_local
->page_lock
, flags
);
973 * ethdev_setup - init rest of 8390 device struct
974 * @dev: network device structure to init
976 * Initialize the rest of the 8390 device structure. Do NOT __init
977 * this, as it is used by 8390 based modular drivers too.
980 static void ethdev_setup(struct net_device
*dev
)
982 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
986 dev
->hard_start_xmit
= &ei_start_xmit
;
987 dev
->get_stats
= get_stats
;
988 dev
->set_multicast_list
= &set_multicast_list
;
992 spin_lock_init(&ei_local
->page_lock
);
996 * alloc_ei_netdev - alloc_etherdev counterpart for 8390
997 * @size: extra bytes to allocate
999 * Allocate 8390-specific net_device.
1001 struct net_device
*__alloc_ei_netdev(int size
)
1003 return alloc_netdev(sizeof(struct ei_device
) + size
, "eth%d",
1010 /* This page of functions should be 8390 generic */
1011 /* Follow National Semi's recommendations for initializing the "NIC". */
1014 * NS8390_init - initialize 8390 hardware
1015 * @dev: network device to initialize
1016 * @startp: boolean. non-zero value to initiate chip processing
1018 * Must be called with lock held.
1021 void NS8390_init(struct net_device
*dev
, int startp
)
1023 long e8390_base
= dev
->base_addr
;
1024 struct ei_device
*ei_local
= (struct ei_device
*) netdev_priv(dev
);
1026 int endcfg
= ei_local
->word16
1027 ? (0x48 | ENDCFG_WTS
| (ei_local
->bigendian
? ENDCFG_BOS
: 0))
1030 if(sizeof(struct e8390_pkt_hdr
)!=4)
1031 panic("8390.c: header struct mispacked\n");
1032 /* Follow National Semi's recommendations for initing the DP83902. */
1033 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_STOP
, e8390_base
+E8390_CMD
); /* 0x21 */
1034 outb_p(endcfg
, e8390_base
+ EN0_DCFG
); /* 0x48 or 0x49 */
1035 /* Clear the remote byte count registers. */
1036 outb_p(0x00, e8390_base
+ EN0_RCNTLO
);
1037 outb_p(0x00, e8390_base
+ EN0_RCNTHI
);
1038 /* Set to monitor and loopback mode -- this is vital!. */
1039 outb_p(E8390_RXOFF
, e8390_base
+ EN0_RXCR
); /* 0x20 */
1040 outb_p(E8390_TXOFF
, e8390_base
+ EN0_TXCR
); /* 0x02 */
1041 /* Set the transmit page and receive ring. */
1042 outb_p(ei_local
->tx_start_page
, e8390_base
+ EN0_TPSR
);
1043 ei_local
->tx1
= ei_local
->tx2
= 0;
1044 outb_p(ei_local
->rx_start_page
, e8390_base
+ EN0_STARTPG
);
1045 outb_p(ei_local
->stop_page
-1, e8390_base
+ EN0_BOUNDARY
); /* 3c503 says 0x3f,NS0x26*/
1046 ei_local
->current_page
= ei_local
->rx_start_page
; /* assert boundary+1 */
1047 outb_p(ei_local
->stop_page
, e8390_base
+ EN0_STOPPG
);
1048 /* Clear the pending interrupts and mask. */
1049 outb_p(0xFF, e8390_base
+ EN0_ISR
);
1050 outb_p(0x00, e8390_base
+ EN0_IMR
);
1052 /* Copy the station address into the DS8390 registers. */
1054 outb_p(E8390_NODMA
+ E8390_PAGE1
+ E8390_STOP
, e8390_base
+E8390_CMD
); /* 0x61 */
1055 for(i
= 0; i
< 6; i
++)
1057 outb_p(dev
->dev_addr
[i
], e8390_base
+ EN1_PHYS_SHIFT(i
));
1058 if (ei_debug
> 1 && inb_p(e8390_base
+ EN1_PHYS_SHIFT(i
))!=dev
->dev_addr
[i
])
1059 printk(KERN_ERR
"Hw. address read/write mismap %d\n",i
);
1062 outb_p(ei_local
->rx_start_page
, e8390_base
+ EN1_CURPAG
);
1063 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_STOP
, e8390_base
+E8390_CMD
);
1065 netif_start_queue(dev
);
1066 ei_local
->tx1
= ei_local
->tx2
= 0;
1067 ei_local
->txing
= 0;
1071 outb_p(0xff, e8390_base
+ EN0_ISR
);
1072 outb_p(ENISR_ALL
, e8390_base
+ EN0_IMR
);
1073 outb_p(E8390_NODMA
+E8390_PAGE0
+E8390_START
, e8390_base
+E8390_CMD
);
1074 outb_p(E8390_TXCONFIG
, e8390_base
+ EN0_TXCR
); /* xmit on. */
1075 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1076 outb_p(E8390_RXCONFIG
, e8390_base
+ EN0_RXCR
); /* rx on, */
1077 do_set_multicast_list(dev
); /* (re)load the mcast table */
1081 /* Trigger a transmit start, assuming the length is valid.
1082 Always called with the page lock held */
1084 static void NS8390_trigger_send(struct net_device
*dev
, unsigned int length
,
1087 long e8390_base
= dev
->base_addr
;
1088 struct ei_device
*ei_local
__attribute((unused
)) = (struct ei_device
*) netdev_priv(dev
);
1090 outb_p(E8390_NODMA
+E8390_PAGE0
, e8390_base
+E8390_CMD
);
1092 if (inb_p(e8390_base
+ E8390_CMD
) & E8390_TRANS
)
1094 printk(KERN_WARNING
"%s: trigger_send() called with the transmitter busy.\n",
1098 outb_p(length
& 0xff, e8390_base
+ EN0_TCNTLO
);
1099 outb_p(length
>> 8, e8390_base
+ EN0_TCNTHI
);
1100 outb_p(start_page
, e8390_base
+ EN0_TPSR
);
1101 outb_p(E8390_NODMA
+E8390_TRANS
+E8390_START
, e8390_base
+E8390_CMD
);
1104 EXPORT_SYMBOL(ei_open
);
1105 EXPORT_SYMBOL(ei_close
);
1106 EXPORT_SYMBOL(ei_interrupt
);
1107 #ifdef CONFIG_NET_POLL_CONTROLLER
1108 EXPORT_SYMBOL(ei_poll
);
1110 EXPORT_SYMBOL(NS8390_init
);
1111 EXPORT_SYMBOL(__alloc_ei_netdev
);
1115 int init_module(void)
1120 void cleanup_module(void)
1125 MODULE_LICENSE("GPL");
This page took 0.055963 seconds and 6 git commands to generate.