1 /* 8390.c: A general NS8390 ethernet driver core for linux. */
2 /*
3 Written 1992-94 by Donald Becker.
4
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency.
7
8 This software may be used and distributed according to the terms
9 of the GNU Public License, incorporated herein by reference.
10
11 The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O
12 Center of Excellence in Space Data and Information Sciences
13 Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
14
15 This is the chip-specific code for many 8390-based ethernet adaptors.
16 This is not a complete driver, it must be combined with board-specific
17 code such as ne.c, wd.c, 3c503.c, etc.
18
19 Seeing how at least eight drivers use this code, (not counting the
20 PCMCIA ones either) it is easy to break some card by what seems like
21 a simple innocent change. Please contact me or Donald if you think
22 you have found something that needs changing. -- PG
23
24
25 Changelog:
26
27 Paul Gortmaker : remove set_bit lock, other cleanups.
28 Paul Gortmaker : add ei_get_8390_hdr() so we can pass skb's to
29 ei_block_input() for eth_io_copy_and_sum().
30 Paul Gortmaker : exchange static int ei_pingpong for a #define,
31 also add better Tx error handling.
32 Paul Gortmaker : rewrite Rx overrun handling as per NS specs.
33 Alexey Kuznetsov : use the 8390's six bit hash multicast filter.
34 Paul Gortmaker : tweak ANK's above multicast changes a bit.
35 Paul Gortmaker : update packet statistics for v2.1.x
36 Alan Cox : support arbitary stupid port mappings on the
37 68K Macintosh. Support >16bit I/O spaces
38 Paul Gortmaker : add kmod support for auto-loading of the 8390
39 module by all drivers that require it.
40 Alan Cox : Spinlocking work, added 'BUG_83C690'
41 Paul Gortmaker : Separate out Tx timeout code from Tx path.
42
43 Sources:
44 The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
45
46 */
47
48 static const char *version =
49 "8390.c:v1.10cvs 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
50
51 #include <linux/module.h>
52 #include <linux/kernel.h>
53 #include <linux/sched.h>
54 #include <linux/fs.h>
55 #include <linux/types.h>
56 #include <linux/ptrace.h>
57 #include <linux/string.h>
58 #include <asm/system.h>
59 #include <asm/uaccess.h>
60 #include <asm/bitops.h>
61 #include <asm/io.h>
62 #include <asm/irq.h>
63 #include <linux/delay.h>
64 #include <linux/errno.h>
65 #include <linux/fcntl.h>
66 #include <linux/in.h>
67 #include <linux/interrupt.h>
68 #include <linux/init.h>
69
70 #include <linux/netdevice.h>
71 #include <linux/etherdevice.h>
72
73 #define NS8390_CORE
74 #include "8390.h"
75
76 #define BUG_83C690
77
78 /* These are the operational function interfaces to board-specific
79 routines.
80 void reset_8390(struct net_device *dev)
81 Resets the board associated with DEV, including a hardware reset of
82 the 8390. This is only called when there is a transmit timeout, and
83 it is always followed by 8390_init().
84 void block_output(struct net_device *dev, int count, const unsigned char *buf,
85 int start_page)
86 Write the COUNT bytes of BUF to the packet buffer at START_PAGE. The
87 "page" value uses the 8390's 256-byte pages.
88 void get_8390_hdr(struct net_device *dev, struct e8390_hdr *hdr, int ring_page)
89 Read the 4 byte, page aligned 8390 header. *If* there is a
90 subsequent read, it will be of the rest of the packet.
91 void block_input(struct net_device *dev, int count, struct sk_buff *skb, int ring_offset)
92 Read COUNT bytes from the packet buffer into the skb data area. Start
93 reading from RING_OFFSET, the address as the 8390 sees it. This will always
94 follow the read of the 8390 header.
95 */
96 #define ei_reset_8390 (ei_local->reset_8390)
97 #define ei_block_output (ei_local->block_output)
98 #define ei_block_input (ei_local->block_input)
99 #define ei_get_8390_hdr (ei_local->get_8390_hdr)
100
101 /* use 0 for production, 1 for verification, >2 for debug */
102 #ifndef ei_debug
103 int ei_debug = 1;
104 #endif
105
106 /* Index to functions. */
107 static void ei_tx_intr(struct net_device *dev);
108 static void ei_tx_err(struct net_device *dev);
109 static void ei_tx_timeout(struct net_device *dev);
110 static void ei_receive(struct net_device *dev);
111 static void ei_rx_overrun(struct net_device *dev);
112
113 /* Routines generic to NS8390-based boards. */
114 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
115 int start_page);
116 static void set_multicast_list(struct net_device *dev);
117 static void do_set_multicast_list(struct net_device *dev);
118
119 /*
120 * SMP and the 8390 setup.
121 *
122 * The 8390 isnt exactly designed to be multithreaded on RX/TX. There is
123 * a page register that controls bank and packet buffer access. We guard
124 * this with ei_local->page_lock. Nobody should assume or set the page other
125 * than zero when the lock is not held. Lock holders must restore page 0
126 * before unlocking. Even pure readers must take the lock to protect in
127 * page 0.
128 *
129 * To make life difficult the chip can also be very slow. We therefore can't
130 * just use spinlocks. For the longer lockups we disable the irq the device
131 * sits on and hold the lock. We must hold the lock because there is a dual
132 * processor case other than interrupts (get stats/set multicast list in
133 * parallel with each other and transmit).
134 *
135 * Note: in theory we can just disable the irq on the card _but_ there is
136 * a latency on SMP irq delivery. So we can easily go "disable irq" "sync irqs"
137 * enter lock, take the queued irq. So we waddle instead of flying.
138 *
139 * Finally by special arrangement for the purpose of being generally
140 * annoying the transmit function is called bh atomic. That places
141 * restrictions on the user context callers as disable_irq won't save
142 * them.
143 */
144
145
146
147 /**
148 * ei_open - Open/initialize the board.
149 * @dev: network device to initialize
150 *
151 * This routine goes all-out, setting everything
152 * up anew at each open, even though many of these registers should only
153 * need to be set once at boot.
154 */
155 int ei_open(struct net_device *dev)
156 {
157 unsigned long flags;
158 struct ei_device *ei_local = (struct ei_device *) dev->priv;
159
160 /* This can't happen unless somebody forgot to call ethdev_init(). */
161 if (ei_local == NULL)
162 {
163 printk(KERN_EMERG "%s: ei_open passed a non-existent device!\n", dev->name);
164 return -ENXIO;
165 }
166
167 /* The card I/O part of the driver (e.g. 3c503) can hook a Tx timeout
168 wrapper that does e.g. media check & then calls ei_tx_timeout. */
169 if (dev->tx_timeout == NULL)
170 dev->tx_timeout = ei_tx_timeout;
171 if (dev->watchdog_timeo <= 0)
172 dev->watchdog_timeo = TX_TIMEOUT;
173
174 /*
175 * Grab the page lock so we own the register set, then call
176 * the init function.
177 */
178
179 spin_lock_irqsave(&ei_local->page_lock, flags);
180 NS8390_init(dev, 1);
181 /* Set the flag before we drop the lock, That way the IRQ arrives
182 after its set and we get no silly warnings */
183 netif_start_queue(dev);
184 spin_unlock_irqrestore(&ei_local->page_lock, flags);
185 ei_local->irqlock = 0;
186 return 0;
187 }
188
189 /**
190 * ei_close - shut down network device
191 * @dev: network device to close
192 *
193 * Opposite of ei_open(). Only used when "ifconfig <devname> down" is done.
194 */
195 int ei_close(struct net_device *dev)
196 {
197 struct ei_device *ei_local = (struct ei_device *) dev->priv;
198 unsigned long flags;
199
200 /*
201 * Hold the page lock during close
202 */
203
204 spin_lock_irqsave(&ei_local->page_lock, flags);
205 NS8390_init(dev, 0);
206 spin_unlock_irqrestore(&ei_local->page_lock, flags);
207 netif_stop_queue(dev);
208 return 0;
209 }
210
211 /**
212 * ei_tx_timeout - handle transmit time out condition
213 * @dev: network device which has apparently fallen asleep
214 *
215 * Called by kernel when device never acknowledges a transmit has
216 * completed (or failed) - i.e. never posted a Tx related interrupt.
217 */
218
219 void ei_tx_timeout(struct net_device *dev)
220 {
221 long e8390_base = dev->base_addr;
222 struct ei_device *ei_local = (struct ei_device *) dev->priv;
223 int txsr, isr, tickssofar = jiffies - dev->trans_start;
224 unsigned long flags;
225
226 ei_local->stat.tx_errors++;
227
228 spin_lock_irqsave(&ei_local->page_lock, flags);
229 txsr = inb(e8390_base+EN0_TSR);
230 isr = inb(e8390_base+EN0_ISR);
231 spin_unlock_irqrestore(&ei_local->page_lock, flags);
232
233 printk(KERN_DEBUG "%s: Tx timed out, %s TSR=%#2x, ISR=%#2x, t=%d.\n",
234 dev->name, (txsr & ENTSR_ABT) ? "excess collisions." :
235 (isr) ? "lost interrupt?" : "cable problem?", txsr, isr, tickssofar);
236
237 if (!isr && !ei_local->stat.tx_packets)
238 {
239 /* The 8390 probably hasn't gotten on the cable yet. */
240 ei_local->interface_num ^= 1; /* Try a different xcvr. */
241 }
242
243 /* Ugly but a reset can be slow, yet must be protected */
244
245 disable_irq_nosync(dev->irq);
246 spin_lock(&ei_local->page_lock);
247
248 /* Try to restart the card. Perhaps the user has fixed something. */
249 ei_reset_8390(dev);
250 NS8390_init(dev, 1);
251
252 spin_unlock(&ei_local->page_lock);
253 enable_irq(dev->irq);
254 netif_wake_queue(dev);
255 }
256
257 /**
258 * ei_start_xmit - begin packet transmission
259 * @skb: packet to be sent
260 * @dev: network device to which packet is sent
261 *
262 * Sends a packet to an 8390 network device.
263 */
264
265 static int ei_start_xmit(struct sk_buff *skb, struct net_device *dev)
266 {
267 long e8390_base = dev->base_addr;
268 struct ei_device *ei_local = (struct ei_device *) dev->priv;
269 int length, send_length, output_page;
270 unsigned long flags;
271
272 length = skb->len;
273
274 /* Mask interrupts from the ethercard.
275 SMP: We have to grab the lock here otherwise the IRQ handler
276 on another CPU can flip window and race the IRQ mask set. We end
277 up trashing the mcast filter not disabling irqs if we dont lock */
278
279 spin_lock_irqsave(&ei_local->page_lock, flags);
280 outb_p(0x00, e8390_base + EN0_IMR);
281 spin_unlock_irqrestore(&ei_local->page_lock, flags);
282
283
284 /*
285 * Slow phase with lock held.
286 */
287
288 disable_irq_nosync(dev->irq);
289
290 spin_lock(&ei_local->page_lock);
291
292 ei_local->irqlock = 1;
293
294 send_length = ETH_ZLEN < length ? length : ETH_ZLEN;
295
296 #ifdef EI_PINGPONG
297
298 /*
299 * We have two Tx slots available for use. Find the first free
300 * slot, and then perform some sanity checks. With two Tx bufs,
301 * you get very close to transmitting back-to-back packets. With
302 * only one Tx buf, the transmitter sits idle while you reload the
303 * card, leaving a substantial gap between each transmitted packet.
304 */
305
306 if (ei_local->tx1 == 0)
307 {
308 output_page = ei_local->tx_start_page;
309 ei_local->tx1 = send_length;
310 if (ei_debug && ei_local->tx2 > 0)
311 printk(KERN_DEBUG "%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
312 dev->name, ei_local->tx2, ei_local->lasttx, ei_local->txing);
313 }
314 else if (ei_local->tx2 == 0)
315 {
316 output_page = ei_local->tx_start_page + TX_1X_PAGES;
317 ei_local->tx2 = send_length;
318 if (ei_debug && ei_local->tx1 > 0)
319 printk(KERN_DEBUG "%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
320 dev->name, ei_local->tx1, ei_local->lasttx, ei_local->txing);
321 }
322 else
323 { /* We should never get here. */
324 if (ei_debug)
325 printk(KERN_DEBUG "%s: No Tx buffers free! tx1=%d tx2=%d last=%d\n",
326 dev->name, ei_local->tx1, ei_local->tx2, ei_local->lasttx);
327 ei_local->irqlock = 0;
328 netif_stop_queue(dev);
329 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
330 spin_unlock(&ei_local->page_lock);
331 enable_irq(dev->irq);
332 ei_local->stat.tx_errors++;
333 return 1;
334 }
335
336 /*
337 * Okay, now upload the packet and trigger a send if the transmitter
338 * isn't already sending. If it is busy, the interrupt handler will
339 * trigger the send later, upon receiving a Tx done interrupt.
340 */
341
342 ei_block_output(dev, length, skb->data, output_page);
343 if (! ei_local->txing)
344 {
345 ei_local->txing = 1;
346 NS8390_trigger_send(dev, send_length, output_page);
347 dev->trans_start = jiffies;
348 if (output_page == ei_local->tx_start_page)
349 {
350 ei_local->tx1 = -1;
351 ei_local->lasttx = -1;
352 }
353 else
354 {
355 ei_local->tx2 = -1;
356 ei_local->lasttx = -2;
357 }
358 }
359 else ei_local->txqueue++;
360
361 if (ei_local->tx1 && ei_local->tx2)
362 netif_stop_queue(dev);
363 else
364 netif_start_queue(dev);
365
366 #else /* EI_PINGPONG */
367
368 /*
369 * Only one Tx buffer in use. You need two Tx bufs to come close to
370 * back-to-back transmits. Expect a 20 -> 25% performance hit on
371 * reasonable hardware if you only use one Tx buffer.
372 */
373
374 ei_block_output(dev, length, skb->data, ei_local->tx_start_page);
375 ei_local->txing = 1;
376 NS8390_trigger_send(dev, send_length, ei_local->tx_start_page);
377 dev->trans_start = jiffies;
378 netif_stop_queue(dev);
379
380 #endif /* EI_PINGPONG */
381
382 /* Turn 8390 interrupts back on. */
383 ei_local->irqlock = 0;
384 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
385
386 spin_unlock(&ei_local->page_lock);
387 enable_irq(dev->irq);
388
389 dev_kfree_skb (skb);
390 ei_local->stat.tx_bytes += send_length;
391
392 return 0;
393 }
394
395 /**
396 * ei_interrupt - handle the interrupts from an 8390
397 * @irq: interrupt number
398 * @dev_id: a pointer to the net_device
399 * @regs: unused
400 *
401 * Handle the ether interface interrupts. We pull packets from
402 * the 8390 via the card specific functions and fire them at the networking
403 * stack. We also handle transmit completions and wake the transmit path if
404 * neccessary. We also update the counters and do other housekeeping as
405 * needed.
406 */
407
408 void ei_interrupt(int irq, void *dev_id, struct pt_regs * regs)
409 {
410 struct net_device *dev = dev_id;
411 long e8390_base;
412 int interrupts, nr_serviced = 0;
413 struct ei_device *ei_local;
414
415 if (dev == NULL)
416 {
417 printk ("net_interrupt(): irq %d for unknown device.\n", irq);
418 return;
419 }
420
421 e8390_base = dev->base_addr;
422 ei_local = (struct ei_device *) dev->priv;
423
424 /*
425 * Protect the irq test too.
426 */
427
428 spin_lock(&ei_local->page_lock);
429
430 if (ei_local->irqlock)
431 {
432 #if 1 /* This might just be an interrupt for a PCI device sharing this line */
433 /* The "irqlock" check is only for testing. */
434 printk(ei_local->irqlock
435 ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
436 : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
437 dev->name, inb_p(e8390_base + EN0_ISR),
438 inb_p(e8390_base + EN0_IMR));
439 #endif
440 spin_unlock(&ei_local->page_lock);
441 return;
442 }
443
444 /* Change to page 0 and read the intr status reg. */
445 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
446 if (ei_debug > 3)
447 printk(KERN_DEBUG "%s: interrupt(isr=%#2.2x).\n", dev->name,
448 inb_p(e8390_base + EN0_ISR));
449
450 /* !!Assumption!! -- we stay in page 0. Don't break this. */
451 while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
452 && ++nr_serviced < MAX_SERVICE)
453 {
454 if (!netif_running(dev)) {
455 printk(KERN_WARNING "%s: interrupt from stopped card\n", dev->name);
456 interrupts = 0;
457 break;
458 }
459 if (interrupts & ENISR_OVER)
460 ei_rx_overrun(dev);
461 else if (interrupts & (ENISR_RX+ENISR_RX_ERR))
462 {
463 /* Got a good (?) packet. */
464 ei_receive(dev);
465 }
466 /* Push the next to-transmit packet through. */
467 if (interrupts & ENISR_TX)
468 ei_tx_intr(dev);
469 else if (interrupts & ENISR_TX_ERR)
470 ei_tx_err(dev);
471
472 if (interrupts & ENISR_COUNTERS)
473 {
474 ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
475 ei_local->stat.rx_crc_errors += inb_p(e8390_base + EN0_COUNTER1);
476 ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
477 outb_p(ENISR_COUNTERS, e8390_base + EN0_ISR); /* Ack intr. */
478 }
479
480 /* Ignore any RDC interrupts that make it back to here. */
481 if (interrupts & ENISR_RDC)
482 {
483 outb_p(ENISR_RDC, e8390_base + EN0_ISR);
484 }
485
486 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
487 }
488
489 if (interrupts && ei_debug)
490 {
491 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
492 if (nr_serviced >= MAX_SERVICE)
493 {
494 /* 0xFF is valid for a card removal */
495 if(interrupts!=0xFF)
496 printk(KERN_WARNING "%s: Too much work at interrupt, status %#2.2x\n",
497 dev->name, interrupts);
498 outb_p(ENISR_ALL, e8390_base + EN0_ISR); /* Ack. most intrs. */
499 } else {
500 printk(KERN_WARNING "%s: unknown interrupt %#2x\n", dev->name, interrupts);
501 outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
502 }
503 }
504 spin_unlock(&ei_local->page_lock);
505 return;
506 }
507
508 /**
509 * ei_tx_err - handle transmitter error
510 * @dev: network device which threw the exception
511 *
512 * A transmitter error has happened. Most likely excess collisions (which
513 * is a fairly normal condition). If the error is one where the Tx will
514 * have been aborted, we try and send another one right away, instead of
515 * letting the failed packet sit and collect dust in the Tx buffer. This
516 * is a much better solution as it avoids kernel based Tx timeouts, and
517 * an unnecessary card reset.
518 *
519 * Called with lock held.
520 */
521
522 static void ei_tx_err(struct net_device *dev)
523 {
524 long e8390_base = dev->base_addr;
525 struct ei_device *ei_local = (struct ei_device *) dev->priv;
526 unsigned char txsr = inb_p(e8390_base+EN0_TSR);
527 unsigned char tx_was_aborted = txsr & (ENTSR_ABT+ENTSR_FU);
528
529 #ifdef VERBOSE_ERROR_DUMP
530 printk(KERN_DEBUG "%s: transmitter error (%#2x): ", dev->name, txsr);
531 if (txsr & ENTSR_ABT)
532 printk("excess-collisions ");
533 if (txsr & ENTSR_ND)
534 printk("non-deferral ");
535 if (txsr & ENTSR_CRS)
536 printk("lost-carrier ");
537 if (txsr & ENTSR_FU)
538 printk("FIFO-underrun ");
539 if (txsr & ENTSR_CDH)
540 printk("lost-heartbeat ");
541 printk("\n");
542 #endif
543
544 outb_p(ENISR_TX_ERR, e8390_base + EN0_ISR); /* Ack intr. */
545
546 if (tx_was_aborted)
547 ei_tx_intr(dev);
548 else
549 {
550 ei_local->stat.tx_errors++;
551 if (txsr & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
552 if (txsr & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
553 if (txsr & ENTSR_OWC) ei_local->stat.tx_window_errors++;
554 }
555 }
556
557 /**
558 * ei_tx_intr - transmit interrupt handler
559 * @dev: network device for which tx intr is handled
560 *
561 * We have finished a transmit: check for errors and then trigger the next
562 * packet to be sent. Called with lock held.
563 */
564
565 static void ei_tx_intr(struct net_device *dev)
566 {
567 long e8390_base = dev->base_addr;
568 struct ei_device *ei_local = (struct ei_device *) dev->priv;
569 int status = inb(e8390_base + EN0_TSR);
570
571 outb_p(ENISR_TX, e8390_base + EN0_ISR); /* Ack intr. */
572
573 #ifdef EI_PINGPONG
574
575 /*
576 * There are two Tx buffers, see which one finished, and trigger
577 * the send of another one if it exists.
578 */
579 ei_local->txqueue--;
580
581 if (ei_local->tx1 < 0)
582 {
583 if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
584 printk(KERN_ERR "%s: bogus last_tx_buffer %d, tx1=%d.\n",
585 ei_local->name, ei_local->lasttx, ei_local->tx1);
586 ei_local->tx1 = 0;
587 if (ei_local->tx2 > 0)
588 {
589 ei_local->txing = 1;
590 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
591 dev->trans_start = jiffies;
592 ei_local->tx2 = -1,
593 ei_local->lasttx = 2;
594 }
595 else ei_local->lasttx = 20, ei_local->txing = 0;
596 }
597 else if (ei_local->tx2 < 0)
598 {
599 if (ei_local->lasttx != 2 && ei_local->lasttx != -2)
600 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
601 ei_local->name, ei_local->lasttx, ei_local->tx2);
602 ei_local->tx2 = 0;
603 if (ei_local->tx1 > 0)
604 {
605 ei_local->txing = 1;
606 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
607 dev->trans_start = jiffies;
608 ei_local->tx1 = -1;
609 ei_local->lasttx = 1;
610 }
611 else
612 ei_local->lasttx = 10, ei_local->txing = 0;
613 }
614 // else printk(KERN_WARNING "%s: unexpected TX-done interrupt, lasttx=%d.\n",
615 // dev->name, ei_local->lasttx);
616
617 #else /* EI_PINGPONG */
618 /*
619 * Single Tx buffer: mark it free so another packet can be loaded.
620 */
621 ei_local->txing = 0;
622 #endif
623
624 /* Minimize Tx latency: update the statistics after we restart TXing. */
625 if (status & ENTSR_COL)
626 ei_local->stat.collisions++;
627 if (status & ENTSR_PTX)
628 ei_local->stat.tx_packets++;
629 else
630 {
631 ei_local->stat.tx_errors++;
632 if (status & ENTSR_ABT)
633 {
634 ei_local->stat.tx_aborted_errors++;
635 ei_local->stat.collisions += 16;
636 }
637 if (status & ENTSR_CRS)
638 ei_local->stat.tx_carrier_errors++;
639 if (status & ENTSR_FU)
640 ei_local->stat.tx_fifo_errors++;
641 if (status & ENTSR_CDH)
642 ei_local->stat.tx_heartbeat_errors++;
643 if (status & ENTSR_OWC)
644 ei_local->stat.tx_window_errors++;
645 }
646 netif_wake_queue(dev);
647 }
648
649 /**
650 * ei_receive - receive some packets
651 * @dev: network device with which receive will be run
652 *
653 * We have a good packet(s), get it/them out of the buffers.
654 * Called with lock held.
655 */
656
657 static void ei_receive(struct net_device *dev)
658 {
659 long e8390_base = dev->base_addr;
660 struct ei_device *ei_local = (struct ei_device *) dev->priv;
661 unsigned char rxing_page, this_frame, next_frame;
662 unsigned short current_offset;
663 int rx_pkt_count = 0;
664 struct e8390_pkt_hdr rx_frame;
665 int num_rx_pages = ei_local->stop_page-ei_local->rx_start_page;
666
667 while (++rx_pkt_count < 10)
668 {
669 int pkt_len, pkt_stat;
670
671 /* Get the rx page (incoming packet pointer). */
672 outb_p(E8390_NODMA+E8390_PAGE1, e8390_base + E8390_CMD);
673 rxing_page = inb_p(e8390_base + EN1_CURPAG);
674 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
675
676 /* Remove one frame from the ring. Boundary is always a page behind. */
677 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
678 if (this_frame >= ei_local->stop_page)
679 this_frame = ei_local->rx_start_page;
680
681 /* Someday we'll omit the previous, iff we never get this message.
682 (There is at least one clone claimed to have a problem.)
683
684 Keep quiet if it looks like a card removal. One problem here
685 is that some clones crash in roughly the same way.
686 */
687 if (ei_debug > 0 && this_frame != ei_local->current_page && (this_frame!=0x0 || rxing_page!=0xFF))
688 printk(KERN_ERR "%s: mismatched read page pointers %2x vs %2x.\n",
689 dev->name, this_frame, ei_local->current_page);
690
691 if (this_frame == rxing_page) /* Read all the frames? */
692 break; /* Done for now */
693
694 current_offset = this_frame << 8;
695 ei_get_8390_hdr(dev, &rx_frame, this_frame);
696
697 pkt_len = rx_frame.count - sizeof(struct e8390_pkt_hdr);
698 pkt_stat = rx_frame.status;
699
700 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
701
702 /* Check for bogosity warned by 3c503 book: the status byte is never
703 written. This happened a lot during testing! This code should be
704 cleaned up someday. */
705 if (rx_frame.next != next_frame
706 && rx_frame.next != next_frame + 1
707 && rx_frame.next != next_frame - num_rx_pages
708 && rx_frame.next != next_frame + 1 - num_rx_pages) {
709 ei_local->current_page = rxing_page;
710 outb(ei_local->current_page-1, e8390_base+EN0_BOUNDARY);
711 ei_local->stat.rx_errors++;
712 continue;
713 }
714
715 if (pkt_len < 60 || pkt_len > 1518)
716 {
717 if (ei_debug)
718 printk(KERN_DEBUG "%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
719 dev->name, rx_frame.count, rx_frame.status,
720 rx_frame.next);
721 ei_local->stat.rx_errors++;
722 ei_local->stat.rx_length_errors++;
723 }
724 else if ((pkt_stat & 0x0F) == ENRSR_RXOK)
725 {
726 struct sk_buff *skb;
727
728 skb = dev_alloc_skb(pkt_len+2);
729 if (skb == NULL)
730 {
731 if (ei_debug > 1)
732 printk(KERN_DEBUG "%s: Couldn't allocate a sk_buff of size %d.\n",
733 dev->name, pkt_len);
734 ei_local->stat.rx_dropped++;
735 break;
736 }
737 else
738 {
739 skb_reserve(skb,2); /* IP headers on 16 byte boundaries */
740 skb->dev = dev;
741 skb_put(skb, pkt_len); /* Make room */
742 ei_block_input(dev, pkt_len, skb, current_offset + sizeof(rx_frame));
743 skb->protocol=eth_type_trans(skb,dev);
744 netif_rx(skb);
745 ei_local->stat.rx_packets++;
746 ei_local->stat.rx_bytes += pkt_len;
747 if (pkt_stat & ENRSR_PHY)
748 ei_local->stat.multicast++;
749 }
750 }
751 else
752 {
753 if (ei_debug)
754 printk(KERN_DEBUG "%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
755 dev->name, rx_frame.status, rx_frame.next,
756 rx_frame.count);
757 ei_local->stat.rx_errors++;
758 /* NB: The NIC counts CRC, frame and missed errors. */
759 if (pkt_stat & ENRSR_FO)
760 ei_local->stat.rx_fifo_errors++;
761 }
762 next_frame = rx_frame.next;
763
764 /* This _should_ never happen: it's here for avoiding bad clones. */
765 if (next_frame >= ei_local->stop_page) {
766 printk("%s: next frame inconsistency, %#2x\n", dev->name,
767 next_frame);
768 next_frame = ei_local->rx_start_page;
769 }
770 ei_local->current_page = next_frame;
771 outb_p(next_frame-1, e8390_base+EN0_BOUNDARY);
772 }
773
774 /* We used to also ack ENISR_OVER here, but that would sometimes mask
775 a real overrun, leaving the 8390 in a stopped state with rec'vr off. */
776 outb_p(ENISR_RX+ENISR_RX_ERR, e8390_base+EN0_ISR);
777 return;
778 }
779
780 /**
781 * ei_rx_overrun - handle receiver overrun
782 * @dev: network device which threw exception
783 *
784 * We have a receiver overrun: we have to kick the 8390 to get it started
785 * again. Problem is that you have to kick it exactly as NS prescribes in
786 * the updated datasheets, or "the NIC may act in an unpredictable manner."
787 * This includes causing "the NIC to defer indefinitely when it is stopped
788 * on a busy network." Ugh.
789 * Called with lock held. Don't call this with the interrupts off or your
790 * computer will hate you - it takes 10ms or so.
791 */
792
793 static void ei_rx_overrun(struct net_device *dev)
794 {
795 long e8390_base = dev->base_addr;
796 unsigned char was_txing, must_resend = 0;
797 struct ei_device *ei_local = (struct ei_device *) dev->priv;
798
799 /*
800 * Record whether a Tx was in progress and then issue the
801 * stop command.
802 */
803 was_txing = inb_p(e8390_base+E8390_CMD) & E8390_TRANS;
804 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
805
806 if (ei_debug > 1)
807 printk(KERN_DEBUG "%s: Receiver overrun.\n", dev->name);
808 ei_local->stat.rx_over_errors++;
809
810 /*
811 * Wait a full Tx time (1.2ms) + some guard time, NS says 1.6ms total.
812 * Early datasheets said to poll the reset bit, but now they say that
813 * it "is not a reliable indicator and subsequently should be ignored."
814 * We wait at least 10ms.
815 */
816
817 udelay(10*1000);
818
819 /*
820 * Reset RBCR[01] back to zero as per magic incantation.
821 */
822 outb_p(0x00, e8390_base+EN0_RCNTLO);
823 outb_p(0x00, e8390_base+EN0_RCNTHI);
824
825 /*
826 * See if any Tx was interrupted or not. According to NS, this
827 * step is vital, and skipping it will cause no end of havoc.
828 */
829
830 if (was_txing)
831 {
832 unsigned char tx_completed = inb_p(e8390_base+EN0_ISR) & (ENISR_TX+ENISR_TX_ERR);
833 if (!tx_completed)
834 must_resend = 1;
835 }
836
837 /*
838 * Have to enter loopback mode and then restart the NIC before
839 * you are allowed to slurp packets up off the ring.
840 */
841 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR);
842 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
843
844 /*
845 * Clear the Rx ring of all the debris, and ack the interrupt.
846 */
847 ei_receive(dev);
848 outb_p(ENISR_OVER, e8390_base+EN0_ISR);
849
850 /*
851 * Leave loopback mode, and resend any packet that got stopped.
852 */
853 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR);
854 if (must_resend)
855 outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START + E8390_TRANS, e8390_base + E8390_CMD);
856 }
857
858 /*
859 * Collect the stats. This is called unlocked and from several contexts.
860 */
861
862 static struct net_device_stats *get_stats(struct net_device *dev)
863 {
864 long ioaddr = dev->base_addr;
865 struct ei_device *ei_local = (struct ei_device *) dev->priv;
866 unsigned long flags;
867
868 /* If the card is stopped, just return the present stats. */
869 if (!netif_running(dev))
870 return &ei_local->stat;
871
872 spin_lock_irqsave(&ei_local->page_lock,flags);
873 /* Read the counter registers, assuming we are in page 0. */
874 ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
875 ei_local->stat.rx_crc_errors += inb_p(ioaddr + EN0_COUNTER1);
876 ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
877 spin_unlock_irqrestore(&ei_local->page_lock, flags);
878
879 return &ei_local->stat;
880 }
881
882 /*
883 * Update the given Autodin II CRC value with another data byte.
884 */
885
886 static inline u32 update_crc(u8 byte, u32 current_crc)
887 {
888 int bit;
889 u8 ah = 0;
890 for (bit=0; bit<8; bit++)
891 {
892 u8 carry = (current_crc>>31);
893 current_crc <<= 1;
894 ah = ((ah<<1) | carry) ^ byte;
895 if (ah&1)
896 current_crc ^= 0x04C11DB7; /* CRC polynomial */
897 ah >>= 1;
898 byte >>= 1;
899 }
900 return current_crc;
901 }
902
903 /*
904 * Form the 64 bit 8390 multicast table from the linked list of addresses
905 * associated with this dev structure.
906 */
907
908 static inline void make_mc_bits(u8 *bits, struct net_device *dev)
909 {
910 struct dev_mc_list *dmi;
911
912 for (dmi=dev->mc_list; dmi; dmi=dmi->next)
913 {
914 int i;
915 u32 crc;
916 if (dmi->dmi_addrlen != ETH_ALEN)
917 {
918 printk(KERN_INFO "%s: invalid multicast address length given.\n", dev->name);
919 continue;
920 }
921 crc = 0xffffffff; /* initial CRC value */
922 for (i=0; i<ETH_ALEN; i++)
923 crc = update_crc(dmi->dmi_addr[i], crc);
924 /*
925 * The 8390 uses the 6 most significant bits of the
926 * CRC to index the multicast table.
927 */
928 bits[crc>>29] |= (1<<((crc>>26)&7));
929 }
930 }
931
932 /**
933 * do_set_multicast_list - set/clear multicast filter
934 * @dev: net device for which multicast filter is adjusted
935 *
936 * Set or clear the multicast filter for this adaptor. May be called
937 * from a BH in 2.1.x. Must be called with lock held.
938 */
939
940 static void do_set_multicast_list(struct net_device *dev)
941 {
942 long e8390_base = dev->base_addr;
943 int i;
944 struct ei_device *ei_local = (struct ei_device*)dev->priv;
945
946 if (!(dev->flags&(IFF_PROMISC|IFF_ALLMULTI)))
947 {
948 memset(ei_local->mcfilter, 0, 8);
949 if (dev->mc_list)
950 make_mc_bits(ei_local->mcfilter, dev);
951 }
952 else
953 memset(ei_local->mcfilter, 0xFF, 8); /* mcast set to accept-all */
954
955 /*
956 * DP8390 manuals don't specify any magic sequence for altering
957 * the multicast regs on an already running card. To be safe, we
958 * ensure multicast mode is off prior to loading up the new hash
959 * table. If this proves to be not enough, we can always resort
960 * to stopping the NIC, loading the table and then restarting.
961 *
962 * Bug Alert! The MC regs on the SMC 83C690 (SMC Elite and SMC
963 * Elite16) appear to be write-only. The NS 8390 data sheet lists
964 * them as r/w so this is a bug. The SMC 83C790 (SMC Ultra and
965 * Ultra32 EISA) appears to have this bug fixed.
966 */
967
968 if (netif_running(dev))
969 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
970 outb_p(E8390_NODMA + E8390_PAGE1, e8390_base + E8390_CMD);
971 for(i = 0; i < 8; i++)
972 {
973 outb_p(ei_local->mcfilter[i], e8390_base + EN1_MULT_SHIFT(i));
974 #ifndef BUG_83C690
975 if(inb_p(e8390_base + EN1_MULT_SHIFT(i))!=ei_local->mcfilter[i])
976 printk(KERN_ERR "Multicast filter read/write mismap %d\n",i);
977 #endif
978 }
979 outb_p(E8390_NODMA + E8390_PAGE0, e8390_base + E8390_CMD);
980
981 if(dev->flags&IFF_PROMISC)
982 outb_p(E8390_RXCONFIG | 0x18, e8390_base + EN0_RXCR);
983 else if(dev->flags&IFF_ALLMULTI || dev->mc_list)
984 outb_p(E8390_RXCONFIG | 0x08, e8390_base + EN0_RXCR);
985 else
986 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR);
987 }
988
989 /*
990 * Called without lock held. This is invoked from user context and may
991 * be parallel to just about everything else. Its also fairly quick and
992 * not called too often. Must protect against both bh and irq users
993 */
994
995 static void set_multicast_list(struct net_device *dev)
996 {
997 unsigned long flags;
998 struct ei_device *ei_local = (struct ei_device*)dev->priv;
999
1000 spin_lock_irqsave(&ei_local->page_lock, flags);
1001 do_set_multicast_list(dev);
1002 spin_unlock_irqrestore(&ei_local->page_lock, flags);
1003 }
1004
1005 /**
1006 * ethdev_init - init rest of 8390 device struct
1007 * @dev: network device structure to init
1008 *
1009 * Initialize the rest of the 8390 device structure. Do NOT __init
1010 * this, as it is used by 8390 based modular drivers too.
1011 */
1012
1013 int ethdev_init(struct net_device *dev)
1014 {
1015 if (ei_debug > 1)
1016 printk(version);
1017
1018 if (dev->priv == NULL)
1019 {
1020 struct ei_device *ei_local;
1021
1022 dev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL);
1023 if (dev->priv == NULL)
1024 return -ENOMEM;
1025 memset(dev->priv, 0, sizeof(struct ei_device));
1026 ei_local = (struct ei_device *)dev->priv;
1027 spin_lock_init(&ei_local->page_lock);
1028 }
1029
1030 dev->hard_start_xmit = &ei_start_xmit;
1031 dev->get_stats = get_stats;
1032 dev->set_multicast_list = &set_multicast_list;
1033
1034 ether_setup(dev);
1035
1036 return 0;
1037 }
1038
1039
1040
1041 /* This page of functions should be 8390 generic */
1042 /* Follow National Semi's recommendations for initializing the "NIC". */
1043
1044 /**
1045 * NS8390_init - initialize 8390 hardware
1046 * @dev: network device to initialize
1047 * @startp: boolean. non-zero value to initiate chip processing
1048 *
1049 * Must be called with lock held.
1050 */
1051
1052 void NS8390_init(struct net_device *dev, int startp)
1053 {
1054 long e8390_base = dev->base_addr;
1055 struct ei_device *ei_local = (struct ei_device *) dev->priv;
1056 int i;
1057 int endcfg = ei_local->word16
1058 ? (0x48 | ENDCFG_WTS | (ei_local->bigendian ? ENDCFG_BOS : 0))
1059 : 0x48;
1060
1061 if(sizeof(struct e8390_pkt_hdr)!=4)
1062 panic("8390.c: header struct mispacked\n");
1063 /* Follow National Semi's recommendations for initing the DP83902. */
1064 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD); /* 0x21 */
1065 outb_p(endcfg, e8390_base + EN0_DCFG); /* 0x48 or 0x49 */
1066 /* Clear the remote byte count registers. */
1067 outb_p(0x00, e8390_base + EN0_RCNTLO);
1068 outb_p(0x00, e8390_base + EN0_RCNTHI);
1069 /* Set to monitor and loopback mode -- this is vital!. */
1070 outb_p(E8390_RXOFF, e8390_base + EN0_RXCR); /* 0x20 */
1071 outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
1072 /* Set the transmit page and receive ring. */
1073 outb_p(ei_local->tx_start_page, e8390_base + EN0_TPSR);
1074 ei_local->tx1 = ei_local->tx2 = 0;
1075 outb_p(ei_local->rx_start_page, e8390_base + EN0_STARTPG);
1076 outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
1077 ei_local->current_page = ei_local->rx_start_page; /* assert boundary+1 */
1078 outb_p(ei_local->stop_page, e8390_base + EN0_STOPPG);
1079 /* Clear the pending interrupts and mask. */
1080 outb_p(0xFF, e8390_base + EN0_ISR);
1081 outb_p(0x00, e8390_base + EN0_IMR);
1082
1083 /* Copy the station address into the DS8390 registers. */
1084
1085 outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base+E8390_CMD); /* 0x61 */
1086 for(i = 0; i < 6; i++)
1087 {
1088 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS_SHIFT(i));
1089 if(inb_p(e8390_base + EN1_PHYS_SHIFT(i))!=dev->dev_addr[i])
1090 printk(KERN_ERR "Hw. address read/write mismap %d\n",i);
1091 }
1092
1093 outb_p(ei_local->rx_start_page, e8390_base + EN1_CURPAG);
1094 outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
1095
1096 netif_start_queue(dev);
1097 ei_local->tx1 = ei_local->tx2 = 0;
1098 ei_local->txing = 0;
1099
1100 if (startp)
1101 {
1102 outb_p(0xff, e8390_base + EN0_ISR);
1103 outb_p(ENISR_ALL, e8390_base + EN0_IMR);
1104 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base+E8390_CMD);
1105 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
1106 /* 3c503 TechMan says rxconfig only after the NIC is started. */
1107 outb_p(E8390_RXCONFIG, e8390_base + EN0_RXCR); /* rx on, */
1108 do_set_multicast_list(dev); /* (re)load the mcast table */
1109 }
1110 }
1111
1112 /* Trigger a transmit start, assuming the length is valid.
1113 Always called with the page lock held */
1114
1115 static void NS8390_trigger_send(struct net_device *dev, unsigned int length,
1116 int start_page)
1117 {
1118 long e8390_base = dev->base_addr;
1119 struct ei_device *ei_local __attribute((unused)) = (struct ei_device *) dev->priv;
1120
1121 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base+E8390_CMD);
1122
1123 if (inb_p(e8390_base) & E8390_TRANS)
1124 {
1125 printk(KERN_WARNING "%s: trigger_send() called with the transmitter busy.\n",
1126 dev->name);
1127 return;
1128 }
1129 outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
1130 outb_p(length >> 8, e8390_base + EN0_TCNTHI);
1131 outb_p(start_page, e8390_base + EN0_TPSR);
1132 outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base+E8390_CMD);
1133 }
1134
1135 EXPORT_SYMBOL(ei_open);
1136 EXPORT_SYMBOL(ei_close);
1137 EXPORT_SYMBOL(ei_interrupt);
1138 EXPORT_SYMBOL(ei_tx_timeout);
1139 EXPORT_SYMBOL(ethdev_init);
1140 EXPORT_SYMBOL(NS8390_init);
1141
1142 #if defined(MODULE)
1143
1144 int init_module(void)
1145 {
1146 return 0;
1147 }
1148
1149 void cleanup_module(void)
1150 {
1151 }
1152
1153 #endif /* MODULE */
1154
1155 /*
1156 * Local variables:
1157 * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 8390.c"
1158 * version-control: t
1159 * kept-new-versions: 5
1160 * c-indent-level: 4
1161 * tab-width: 4
1162 * End:
1163 */
1164
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.