Subversion Repositories shark

Rev

Go to most recent revision | Details | Last modification | View Log | RSS feed

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