Subversion Repositories shark

Rev

Details | Last modification | View Log | RSS feed

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