Merge with /pub/scm/linux/kernel/git/torvalds/linux-2.6.git
[linux-2.6] / drivers / net / lance.c
1 /* lance.c: An AMD LANCE/PCnet ethernet driver for Linux. */
2 /*
3         Written/copyright 1993-1998 by Donald Becker.
4
5         Copyright 1993 United States Government as represented by the
6         Director, National Security Agency.
7         This software may be used and distributed according to the terms
8         of the GNU General Public License, incorporated herein by reference.
9
10         This driver is for the Allied Telesis AT1500 and HP J2405A, and should work
11         with most other LANCE-based bus-master (NE2100/NE2500) ethercards.
12
13         The author may be reached as becker@scyld.com, or C/O
14         Scyld Computing Corporation
15         410 Severn Ave., Suite 210
16         Annapolis MD 21403
17
18         Andrey V. Savochkin:
19         - alignment problem with 1.3.* kernel and some minor changes.
20         Thomas Bogendoerfer (tsbogend@bigbug.franken.de):
21         - added support for Linux/Alpha, but removed most of it, because
22         it worked only for the PCI chip. 
23       - added hook for the 32bit lance driver
24       - added PCnetPCI II (79C970A) to chip table
25         Paul Gortmaker (gpg109@rsphy1.anu.edu.au):
26         - hopefully fix above so Linux/Alpha can use ISA cards too.
27     8/20/96 Fixed 7990 autoIRQ failure and reversed unneeded alignment -djb
28     v1.12 10/27/97 Module support -djb
29     v1.14  2/3/98 Module support modified, made PCI support optional -djb
30     v1.15 5/27/99 Fixed bug in the cleanup_module(). dev->priv was freed
31                   before unregister_netdev() which caused NULL pointer
32                   reference later in the chain (in rtnetlink_fill_ifinfo())
33                   -- Mika Kuoppala <miku@iki.fi>
34     
35     Forward ported v1.14 to 2.1.129, merged the PCI and misc changes from
36     the 2.1 version of the old driver - Alan Cox
37
38     Get rid of check_region, check kmalloc return in lance_probe1
39     Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 11/01/2001
40
41         Reworked detection, added support for Racal InterLan EtherBlaster cards
42         Vesselin Kostadinov <vesok at yahoo dot com > - 22/4/2004
43 */
44
45 static const char version[] = "lance.c:v1.15ac 1999/11/13 dplatt@3do.com, becker@cesdis.gsfc.nasa.gov\n";
46
47 #include <linux/module.h>
48 #include <linux/kernel.h>
49 #include <linux/string.h>
50 #include <linux/delay.h>
51 #include <linux/errno.h>
52 #include <linux/ioport.h>
53 #include <linux/slab.h>
54 #include <linux/interrupt.h>
55 #include <linux/pci.h>
56 #include <linux/init.h>
57 #include <linux/netdevice.h>
58 #include <linux/etherdevice.h>
59 #include <linux/skbuff.h>
60 #include <linux/bitops.h>
61
62 #include <asm/io.h>
63 #include <asm/dma.h>
64
65 static unsigned int lance_portlist[] __initdata = { 0x300, 0x320, 0x340, 0x360, 0};
66 static int lance_probe1(struct net_device *dev, int ioaddr, int irq, int options);
67 static int __init do_lance_probe(struct net_device *dev);
68
69
70 static struct card {
71         char id_offset14;
72         char id_offset15;
73 } cards[] = {
74         {       //"normal"
75                 .id_offset14 = 0x57,
76                 .id_offset15 = 0x57,
77         },
78         {       //NI6510EB
79                 .id_offset14 = 0x52,
80                 .id_offset15 = 0x44,
81         },
82         {       //Racal InterLan EtherBlaster
83                 .id_offset14 = 0x52,
84                 .id_offset15 = 0x49,
85         },
86 };
87 #define NUM_CARDS 3
88
89 #ifdef LANCE_DEBUG
90 static int lance_debug = LANCE_DEBUG;
91 #else
92 static int lance_debug = 1;
93 #endif
94
95 /*
96                                 Theory of Operation
97
98 I. Board Compatibility
99
100 This device driver is designed for the AMD 79C960, the "PCnet-ISA
101 single-chip ethernet controller for ISA".  This chip is used in a wide
102 variety of boards from vendors such as Allied Telesis, HP, Kingston,
103 and Boca.  This driver is also intended to work with older AMD 7990
104 designs, such as the NE1500 and NE2100, and newer 79C961.  For convenience,
105 I use the name LANCE to refer to all of the AMD chips, even though it properly
106 refers only to the original 7990.
107
108 II. Board-specific settings
109
110 The driver is designed to work the boards that use the faster
111 bus-master mode, rather than in shared memory mode.      (Only older designs
112 have on-board buffer memory needed to support the slower shared memory mode.)
113
114 Most ISA boards have jumpered settings for the I/O base, IRQ line, and DMA
115 channel.  This driver probes the likely base addresses:
116 {0x300, 0x320, 0x340, 0x360}.
117 After the board is found it generates a DMA-timeout interrupt and uses
118 autoIRQ to find the IRQ line.  The DMA channel can be set with the low bits
119 of the otherwise-unused dev->mem_start value (aka PARAM1).  If unset it is
120 probed for by enabling each free DMA channel in turn and checking if
121 initialization succeeds.
122
123 The HP-J2405A board is an exception: with this board it is easy to read the
124 EEPROM-set values for the base, IRQ, and DMA.  (Of course you must already
125 _know_ the base address -- that field is for writing the EEPROM.)
126
127 III. Driver operation
128
129 IIIa. Ring buffers
130 The LANCE uses ring buffers of Tx and Rx descriptors.  Each entry describes
131 the base and length of the data buffer, along with status bits.  The length
132 of these buffers is set by LANCE_LOG_{RX,TX}_BUFFERS, which is log_2() of
133 the buffer length (rather than being directly the buffer length) for
134 implementation ease.  The current values are 2 (Tx) and 4 (Rx), which leads to
135 ring sizes of 4 (Tx) and 16 (Rx).  Increasing the number of ring entries
136 needlessly uses extra space and reduces the chance that an upper layer will
137 be able to reorder queued Tx packets based on priority.  Decreasing the number
138 of entries makes it more difficult to achieve back-to-back packet transmission
139 and increases the chance that Rx ring will overflow.  (Consider the worst case
140 of receiving back-to-back minimum-sized packets.)
141
142 The LANCE has the capability to "chain" both Rx and Tx buffers, but this driver
143 statically allocates full-sized (slightly oversized -- PKT_BUF_SZ) buffers to
144 avoid the administrative overhead. For the Rx side this avoids dynamically
145 allocating full-sized buffers "just in case", at the expense of a
146 memory-to-memory data copy for each packet received.  For most systems this
147 is a good tradeoff: the Rx buffer will always be in low memory, the copy
148 is inexpensive, and it primes the cache for later packet processing.  For Tx
149 the buffers are only used when needed as low-memory bounce buffers.
150
151 IIIB. 16M memory limitations.
152 For the ISA bus master mode all structures used directly by the LANCE,
153 the initialization block, Rx and Tx rings, and data buffers, must be
154 accessible from the ISA bus, i.e. in the lower 16M of real memory.
155 This is a problem for current Linux kernels on >16M machines. The network
156 devices are initialized after memory initialization, and the kernel doles out
157 memory from the top of memory downward.  The current solution is to have a
158 special network initialization routine that's called before memory
159 initialization; this will eventually be generalized for all network devices.
160 As mentioned before, low-memory "bounce-buffers" are used when needed.
161
162 IIIC. Synchronization
163 The driver runs as two independent, single-threaded flows of control.  One
164 is the send-packet routine, which enforces single-threaded use by the
165 dev->tbusy flag.  The other thread is the interrupt handler, which is single
166 threaded by the hardware and other software.
167
168 The send packet thread has partial control over the Tx ring and 'dev->tbusy'
169 flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
170 queue slot is empty, it clears the tbusy flag when finished otherwise it sets
171 the 'lp->tx_full' flag.
172
173 The interrupt handler has exclusive control over the Rx ring and records stats
174 from the Tx ring. (The Tx-done interrupt can't be selectively turned off, so
175 we can't avoid the interrupt overhead by having the Tx routine reap the Tx
176 stats.)  After reaping the stats, it marks the queue entry as empty by setting
177 the 'base' to zero. Iff the 'lp->tx_full' flag is set, it clears both the
178 tx_full and tbusy flags.
179
180 */
181
182 /* Set the number of Tx and Rx buffers, using Log_2(# buffers).
183    Reasonable default values are 16 Tx buffers, and 16 Rx buffers.
184    That translates to 4 and 4 (16 == 2^^4).
185    This is a compile-time option for efficiency.
186    */
187 #ifndef LANCE_LOG_TX_BUFFERS
188 #define LANCE_LOG_TX_BUFFERS 4
189 #define LANCE_LOG_RX_BUFFERS 4
190 #endif
191
192 #define TX_RING_SIZE                    (1 << (LANCE_LOG_TX_BUFFERS))
193 #define TX_RING_MOD_MASK                (TX_RING_SIZE - 1)
194 #define TX_RING_LEN_BITS                ((LANCE_LOG_TX_BUFFERS) << 29)
195
196 #define RX_RING_SIZE                    (1 << (LANCE_LOG_RX_BUFFERS))
197 #define RX_RING_MOD_MASK                (RX_RING_SIZE - 1)
198 #define RX_RING_LEN_BITS                ((LANCE_LOG_RX_BUFFERS) << 29)
199
200 #define PKT_BUF_SZ              1544
201
202 /* Offsets from base I/O address. */
203 #define LANCE_DATA 0x10
204 #define LANCE_ADDR 0x12
205 #define LANCE_RESET 0x14
206 #define LANCE_BUS_IF 0x16
207 #define LANCE_TOTAL_SIZE 0x18
208
209 #define TX_TIMEOUT      20
210
211 /* The LANCE Rx and Tx ring descriptors. */
212 struct lance_rx_head {
213         s32 base;
214         s16 buf_length;                 /* This length is 2s complement (negative)! */
215         s16 msg_length;                 /* This length is "normal". */
216 };
217
218 struct lance_tx_head {
219         s32 base;
220         s16 length;                             /* Length is 2s complement (negative)! */
221         s16 misc;
222 };
223
224 /* The LANCE initialization block, described in databook. */
225 struct lance_init_block {
226         u16 mode;               /* Pre-set mode (reg. 15) */
227         u8  phys_addr[6]; /* Physical ethernet address */
228         u32 filter[2];                  /* Multicast filter (unused). */
229         /* Receive and transmit ring base, along with extra bits. */
230         u32  rx_ring;                   /* Tx and Rx ring base pointers */
231         u32  tx_ring;
232 };
233
234 struct lance_private {
235         /* The Tx and Rx ring entries must be aligned on 8-byte boundaries. */
236         struct lance_rx_head rx_ring[RX_RING_SIZE];
237         struct lance_tx_head tx_ring[TX_RING_SIZE];
238         struct lance_init_block init_block;
239         const char *name;
240         /* The saved address of a sent-in-place packet/buffer, for skfree(). */
241         struct sk_buff* tx_skbuff[TX_RING_SIZE];
242         /* The addresses of receive-in-place skbuffs. */
243         struct sk_buff* rx_skbuff[RX_RING_SIZE];
244         unsigned long rx_buffs;         /* Address of Rx and Tx buffers. */
245         /* Tx low-memory "bounce buffer" address. */
246         char (*tx_bounce_buffs)[PKT_BUF_SZ];
247         int cur_rx, cur_tx;                     /* The next free ring entry */
248         int dirty_rx, dirty_tx;         /* The ring entries to be free()ed. */
249         int dma;
250         struct net_device_stats stats;
251         unsigned char chip_version;     /* See lance_chip_type. */
252         spinlock_t devlock;
253 };
254
255 #define LANCE_MUST_PAD          0x00000001
256 #define LANCE_ENABLE_AUTOSELECT 0x00000002
257 #define LANCE_MUST_REINIT_RING  0x00000004
258 #define LANCE_MUST_UNRESET      0x00000008
259 #define LANCE_HAS_MISSED_FRAME  0x00000010
260
261 /* A mapping from the chip ID number to the part number and features.
262    These are from the datasheets -- in real life the '970 version
263    reportedly has the same ID as the '965. */
264 static struct lance_chip_type {
265         int id_number;
266         const char *name;
267         int flags;
268 } chip_table[] = {
269         {0x0000, "LANCE 7990",                          /* Ancient lance chip.  */
270                 LANCE_MUST_PAD + LANCE_MUST_UNRESET},
271         {0x0003, "PCnet/ISA 79C960",            /* 79C960 PCnet/ISA.  */
272                 LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
273                         LANCE_HAS_MISSED_FRAME},
274         {0x2260, "PCnet/ISA+ 79C961",           /* 79C961 PCnet/ISA+, Plug-n-Play.  */
275                 LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
276                         LANCE_HAS_MISSED_FRAME},
277         {0x2420, "PCnet/PCI 79C970",            /* 79C970 or 79C974 PCnet-SCSI, PCI. */
278                 LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
279                         LANCE_HAS_MISSED_FRAME},
280         /* Bug: the PCnet/PCI actually uses the PCnet/VLB ID number, so just call
281                 it the PCnet32. */
282         {0x2430, "PCnet32",                                     /* 79C965 PCnet for VL bus. */
283                 LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
284                         LANCE_HAS_MISSED_FRAME},
285         {0x2621, "PCnet/PCI-II 79C970A",        /* 79C970A PCInetPCI II. */
286                 LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
287                         LANCE_HAS_MISSED_FRAME},
288         {0x0,    "PCnet (unknown)",
289                 LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
290                         LANCE_HAS_MISSED_FRAME},
291 };
292
293 enum {OLD_LANCE = 0, PCNET_ISA=1, PCNET_ISAP=2, PCNET_PCI=3, PCNET_VLB=4, PCNET_PCI_II=5, LANCE_UNKNOWN=6};
294
295
296 /* Non-zero if lance_probe1() needs to allocate low-memory bounce buffers.
297    Assume yes until we know the memory size. */
298 static unsigned char lance_need_isa_bounce_buffers = 1;
299
300 static int lance_open(struct net_device *dev);
301 static void lance_init_ring(struct net_device *dev, gfp_t mode);
302 static int lance_start_xmit(struct sk_buff *skb, struct net_device *dev);
303 static int lance_rx(struct net_device *dev);
304 static irqreturn_t lance_interrupt(int irq, void *dev_id, struct pt_regs *regs);
305 static int lance_close(struct net_device *dev);
306 static struct net_device_stats *lance_get_stats(struct net_device *dev);
307 static void set_multicast_list(struct net_device *dev);
308 static void lance_tx_timeout (struct net_device *dev);
309
310 \f
311
312 #ifdef MODULE
313 #define MAX_CARDS               8       /* Max number of interfaces (cards) per module */
314
315 static struct net_device *dev_lance[MAX_CARDS];
316 static int io[MAX_CARDS];
317 static int dma[MAX_CARDS];
318 static int irq[MAX_CARDS];
319
320 module_param_array(io, int, NULL, 0);
321 module_param_array(dma, int, NULL, 0);
322 module_param_array(irq, int, NULL, 0);
323 module_param(lance_debug, int, 0);
324 MODULE_PARM_DESC(io, "LANCE/PCnet I/O base address(es),required");
325 MODULE_PARM_DESC(dma, "LANCE/PCnet ISA DMA channel (ignored for some devices)");
326 MODULE_PARM_DESC(irq, "LANCE/PCnet IRQ number (ignored for some devices)");
327 MODULE_PARM_DESC(lance_debug, "LANCE/PCnet debug level (0-7)");
328
329 int init_module(void)
330 {
331         struct net_device *dev;
332         int this_dev, found = 0;
333
334         for (this_dev = 0; this_dev < MAX_CARDS; this_dev++) {
335                 if (io[this_dev] == 0)  {
336                         if (this_dev != 0) /* only complain once */
337                                 break;
338                         printk(KERN_NOTICE "lance.c: Module autoprobing not allowed. Append \"io=0xNNN\" value(s).\n");
339                         return -EPERM;
340                 }
341                 dev = alloc_etherdev(0);
342                 if (!dev)
343                         break;
344                 dev->irq = irq[this_dev];
345                 dev->base_addr = io[this_dev];
346                 dev->dma = dma[this_dev];
347                 if (do_lance_probe(dev) == 0) {
348                         dev_lance[found++] = dev;
349                         continue;
350                 }
351                 free_netdev(dev);
352                 break;
353         }
354         if (found != 0)
355                 return 0;
356         return -ENXIO;
357 }
358
359 static void cleanup_card(struct net_device *dev)
360 {
361         struct lance_private *lp = dev->priv;
362         if (dev->dma != 4)
363                 free_dma(dev->dma);
364         release_region(dev->base_addr, LANCE_TOTAL_SIZE);
365         kfree(lp->tx_bounce_buffs);
366         kfree((void*)lp->rx_buffs);
367         kfree(lp);
368 }
369
370 void cleanup_module(void)
371 {
372         int this_dev;
373
374         for (this_dev = 0; this_dev < MAX_CARDS; this_dev++) {
375                 struct net_device *dev = dev_lance[this_dev];
376                 if (dev) {
377                         unregister_netdev(dev); 
378                         cleanup_card(dev);
379                         free_netdev(dev);
380                 }
381         }
382 }
383 #endif /* MODULE */
384 MODULE_LICENSE("GPL");
385
386
387 /* Starting in v2.1.*, the LANCE/PCnet probe is now similar to the other
388    board probes now that kmalloc() can allocate ISA DMA-able regions.
389    This also allows the LANCE driver to be used as a module.
390    */
391 static int __init do_lance_probe(struct net_device *dev)
392 {
393         int *port, result;
394
395         if (high_memory <= phys_to_virt(16*1024*1024))
396                 lance_need_isa_bounce_buffers = 0;
397
398         for (port = lance_portlist; *port; port++) {
399                 int ioaddr = *port;
400                 struct resource *r = request_region(ioaddr, LANCE_TOTAL_SIZE,
401                                                         "lance-probe");
402
403                 if (r) {
404                         /* Detect the card with minimal I/O reads */
405                         char offset14 = inb(ioaddr + 14);
406                         int card;
407                         for (card = 0; card < NUM_CARDS; ++card)
408                                 if (cards[card].id_offset14 == offset14)
409                                         break;
410                         if (card < NUM_CARDS) {/*yes, the first byte matches*/
411                                 char offset15 = inb(ioaddr + 15);
412                                 for (card = 0; card < NUM_CARDS; ++card)
413                                         if ((cards[card].id_offset14 == offset14) &&
414                                                 (cards[card].id_offset15 == offset15))
415                                                 break;
416                         }
417                         if (card < NUM_CARDS) { /*Signature OK*/
418                                 result = lance_probe1(dev, ioaddr, 0, 0);
419                                 if (!result) {
420                                         struct lance_private *lp = dev->priv;
421                                         int ver = lp->chip_version;
422
423                                         r->name = chip_table[ver].name;
424                                         return 0;
425                                 }
426                         }
427                         release_region(ioaddr, LANCE_TOTAL_SIZE);
428                 }
429         }
430         return -ENODEV;
431 }
432
433 #ifndef MODULE
434 struct net_device * __init lance_probe(int unit)
435 {
436         struct net_device *dev = alloc_etherdev(0);
437         int err;
438
439         if (!dev)
440                 return ERR_PTR(-ENODEV);
441
442         sprintf(dev->name, "eth%d", unit);
443         netdev_boot_setup_check(dev);
444
445         err = do_lance_probe(dev);
446         if (err)
447                 goto out;
448         return dev;
449 out:
450         free_netdev(dev);
451         return ERR_PTR(err);
452 }
453 #endif
454
455 static int __init lance_probe1(struct net_device *dev, int ioaddr, int irq, int options)
456 {
457         struct lance_private *lp;
458         long dma_channels;                      /* Mark spuriously-busy DMA channels */
459         int i, reset_val, lance_version;
460         const char *chipname;
461         /* Flags for specific chips or boards. */
462         unsigned char hpJ2405A = 0;             /* HP ISA adaptor */
463         int hp_builtin = 0;                     /* HP on-board ethernet. */
464         static int did_version;                 /* Already printed version info. */
465         unsigned long flags;
466         int err = -ENOMEM;
467
468         /* First we look for special cases.
469            Check for HP's on-board ethernet by looking for 'HP' in the BIOS.
470            There are two HP versions, check the BIOS for the configuration port.
471            This method provided by L. Julliard, Laurent_Julliard@grenoble.hp.com.
472            */
473         if (isa_readw(0x000f0102) == 0x5048)  {
474                 static const short ioaddr_table[] = { 0x300, 0x320, 0x340, 0x360};
475                 int hp_port = (isa_readl(0x000f00f1) & 1)  ? 0x499 : 0x99;
476                 /* We can have boards other than the built-in!  Verify this is on-board. */
477                 if ((inb(hp_port) & 0xc0) == 0x80
478                         && ioaddr_table[inb(hp_port) & 3] == ioaddr)
479                         hp_builtin = hp_port;
480         }
481         /* We also recognize the HP Vectra on-board here, but check below. */
482         hpJ2405A = (inb(ioaddr) == 0x08 && inb(ioaddr+1) == 0x00
483                                 && inb(ioaddr+2) == 0x09);
484
485         /* Reset the LANCE.      */
486         reset_val = inw(ioaddr+LANCE_RESET); /* Reset the LANCE */
487
488         /* The Un-Reset needed is only needed for the real NE2100, and will
489            confuse the HP board. */
490         if (!hpJ2405A)
491                 outw(reset_val, ioaddr+LANCE_RESET);
492
493         outw(0x0000, ioaddr+LANCE_ADDR); /* Switch to window 0 */
494         if (inw(ioaddr+LANCE_DATA) != 0x0004)
495                 return -ENODEV;
496
497         /* Get the version of the chip. */
498         outw(88, ioaddr+LANCE_ADDR);
499         if (inw(ioaddr+LANCE_ADDR) != 88) {
500                 lance_version = 0;
501         } else {                        /* Good, it's a newer chip. */
502                 int chip_version = inw(ioaddr+LANCE_DATA);
503                 outw(89, ioaddr+LANCE_ADDR);
504                 chip_version |= inw(ioaddr+LANCE_DATA) << 16;
505                 if (lance_debug > 2)
506                         printk("  LANCE chip version is %#x.\n", chip_version);
507                 if ((chip_version & 0xfff) != 0x003)
508                         return -ENODEV;
509                 chip_version = (chip_version >> 12) & 0xffff;
510                 for (lance_version = 1; chip_table[lance_version].id_number; lance_version++) {
511                         if (chip_table[lance_version].id_number == chip_version)
512                                 break;
513                 }
514         }
515
516         /* We can't allocate dev->priv from alloc_etherdev() because it must
517            a ISA DMA-able region. */
518         SET_MODULE_OWNER(dev);
519         chipname = chip_table[lance_version].name;
520         printk("%s: %s at %#3x,", dev->name, chipname, ioaddr);
521
522         /* There is a 16 byte station address PROM at the base address.
523            The first six bytes are the station address. */
524         for (i = 0; i < 6; i++)
525                 printk(" %2.2x", dev->dev_addr[i] = inb(ioaddr + i));
526
527         dev->base_addr = ioaddr;
528         /* Make certain the data structures used by the LANCE are aligned and DMAble. */
529                 
530         lp = kmalloc(sizeof(*lp), GFP_DMA | GFP_KERNEL);
531         if(lp==NULL)
532                 return -ENODEV;
533         if (lance_debug > 6) printk(" (#0x%05lx)", (unsigned long)lp);
534         memset(lp, 0, sizeof(*lp));
535         dev->priv = lp;
536         lp->name = chipname;
537         lp->rx_buffs = (unsigned long)kmalloc(PKT_BUF_SZ*RX_RING_SIZE,
538                                                   GFP_DMA | GFP_KERNEL);
539         if (!lp->rx_buffs)
540                 goto out_lp;
541         if (lance_need_isa_bounce_buffers) {
542                 lp->tx_bounce_buffs = kmalloc(PKT_BUF_SZ*TX_RING_SIZE,
543                                                   GFP_DMA | GFP_KERNEL);
544                 if (!lp->tx_bounce_buffs)
545                         goto out_rx;
546         } else
547                 lp->tx_bounce_buffs = NULL;
548
549         lp->chip_version = lance_version;
550         spin_lock_init(&lp->devlock);
551
552         lp->init_block.mode = 0x0003;           /* Disable Rx and Tx. */
553         for (i = 0; i < 6; i++)
554                 lp->init_block.phys_addr[i] = dev->dev_addr[i];
555         lp->init_block.filter[0] = 0x00000000;
556         lp->init_block.filter[1] = 0x00000000;
557         lp->init_block.rx_ring = ((u32)isa_virt_to_bus(lp->rx_ring) & 0xffffff) | RX_RING_LEN_BITS;
558         lp->init_block.tx_ring = ((u32)isa_virt_to_bus(lp->tx_ring) & 0xffffff) | TX_RING_LEN_BITS;
559
560         outw(0x0001, ioaddr+LANCE_ADDR);
561         inw(ioaddr+LANCE_ADDR);
562         outw((short) (u32) isa_virt_to_bus(&lp->init_block), ioaddr+LANCE_DATA);
563         outw(0x0002, ioaddr+LANCE_ADDR);
564         inw(ioaddr+LANCE_ADDR);
565         outw(((u32)isa_virt_to_bus(&lp->init_block)) >> 16, ioaddr+LANCE_DATA);
566         outw(0x0000, ioaddr+LANCE_ADDR);
567         inw(ioaddr+LANCE_ADDR);
568
569         if (irq) {                                      /* Set iff PCI card. */
570                 dev->dma = 4;                   /* Native bus-master, no DMA channel needed. */
571                 dev->irq = irq;
572         } else if (hp_builtin) {
573                 static const char dma_tbl[4] = {3, 5, 6, 0};
574                 static const char irq_tbl[4] = {3, 4, 5, 9};
575                 unsigned char port_val = inb(hp_builtin);
576                 dev->dma = dma_tbl[(port_val >> 4) & 3];
577                 dev->irq = irq_tbl[(port_val >> 2) & 3];
578                 printk(" HP Vectra IRQ %d DMA %d.\n", dev->irq, dev->dma);
579         } else if (hpJ2405A) {
580                 static const char dma_tbl[4] = {3, 5, 6, 7};
581                 static const char irq_tbl[8] = {3, 4, 5, 9, 10, 11, 12, 15};
582                 short reset_val = inw(ioaddr+LANCE_RESET);
583                 dev->dma = dma_tbl[(reset_val >> 2) & 3];
584                 dev->irq = irq_tbl[(reset_val >> 4) & 7];
585                 printk(" HP J2405A IRQ %d DMA %d.\n", dev->irq, dev->dma);
586         } else if (lance_version == PCNET_ISAP) {               /* The plug-n-play version. */
587                 short bus_info;
588                 outw(8, ioaddr+LANCE_ADDR);
589                 bus_info = inw(ioaddr+LANCE_BUS_IF);
590                 dev->dma = bus_info & 0x07;
591                 dev->irq = (bus_info >> 4) & 0x0F;
592         } else {
593                 /* The DMA channel may be passed in PARAM1. */
594                 if (dev->mem_start & 0x07)
595                         dev->dma = dev->mem_start & 0x07;
596         }
597
598         if (dev->dma == 0) {
599                 /* Read the DMA channel status register, so that we can avoid
600                    stuck DMA channels in the DMA detection below. */
601                 dma_channels = ((inb(DMA1_STAT_REG) >> 4) & 0x0f) |
602                         (inb(DMA2_STAT_REG) & 0xf0);
603         }
604         err = -ENODEV;
605         if (dev->irq >= 2)
606                 printk(" assigned IRQ %d", dev->irq);
607         else if (lance_version != 0)  { /* 7990 boards need DMA detection first. */
608                 unsigned long irq_mask;
609
610                 /* To auto-IRQ we enable the initialization-done and DMA error
611                    interrupts. For ISA boards we get a DMA error, but VLB and PCI
612                    boards will work. */
613                 irq_mask = probe_irq_on();
614
615                 /* Trigger an initialization just for the interrupt. */
616                 outw(0x0041, ioaddr+LANCE_DATA);
617
618                 mdelay(20);
619                 dev->irq = probe_irq_off(irq_mask);
620                 if (dev->irq)
621                         printk(", probed IRQ %d", dev->irq);
622                 else {
623                         printk(", failed to detect IRQ line.\n");
624                         goto out_tx;
625                 }
626
627                 /* Check for the initialization done bit, 0x0100, which means
628                    that we don't need a DMA channel. */
629                 if (inw(ioaddr+LANCE_DATA) & 0x0100)
630                         dev->dma = 4;
631         }
632
633         if (dev->dma == 4) {
634                 printk(", no DMA needed.\n");
635         } else if (dev->dma) {
636                 if (request_dma(dev->dma, chipname)) {
637                         printk("DMA %d allocation failed.\n", dev->dma);
638                         goto out_tx;
639                 } else
640                         printk(", assigned DMA %d.\n", dev->dma);
641         } else {                        /* OK, we have to auto-DMA. */
642                 for (i = 0; i < 4; i++) {
643                         static const char dmas[] = { 5, 6, 7, 3 };
644                         int dma = dmas[i];
645                         int boguscnt;
646
647                         /* Don't enable a permanently busy DMA channel, or the machine
648                            will hang. */
649                         if (test_bit(dma, &dma_channels))
650                                 continue;
651                         outw(0x7f04, ioaddr+LANCE_DATA); /* Clear the memory error bits. */
652                         if (request_dma(dma, chipname))
653                                 continue;
654                                 
655                         flags=claim_dma_lock();
656                         set_dma_mode(dma, DMA_MODE_CASCADE);
657                         enable_dma(dma);
658                         release_dma_lock(flags);
659
660                         /* Trigger an initialization. */
661                         outw(0x0001, ioaddr+LANCE_DATA);
662                         for (boguscnt = 100; boguscnt > 0; --boguscnt)
663                                 if (inw(ioaddr+LANCE_DATA) & 0x0900)
664                                         break;
665                         if (inw(ioaddr+LANCE_DATA) & 0x0100) {
666                                 dev->dma = dma;
667                                 printk(", DMA %d.\n", dev->dma);
668                                 break;
669                         } else {
670                                 flags=claim_dma_lock();
671                                 disable_dma(dma);
672                                 release_dma_lock(flags);
673                                 free_dma(dma);
674                         }
675                 }
676                 if (i == 4) {                   /* Failure: bail. */
677                         printk("DMA detection failed.\n");
678                         goto out_tx;
679                 }
680         }
681
682         if (lance_version == 0 && dev->irq == 0) {
683                 /* We may auto-IRQ now that we have a DMA channel. */
684                 /* Trigger an initialization just for the interrupt. */
685                 unsigned long irq_mask;
686
687                 irq_mask = probe_irq_on();
688                 outw(0x0041, ioaddr+LANCE_DATA);
689
690                 mdelay(40);
691                 dev->irq = probe_irq_off(irq_mask);
692                 if (dev->irq == 0) {
693                         printk("  Failed to detect the 7990 IRQ line.\n");
694                         goto out_dma;
695                 }
696                 printk("  Auto-IRQ detected IRQ%d.\n", dev->irq);
697         }
698
699         if (chip_table[lp->chip_version].flags & LANCE_ENABLE_AUTOSELECT) {
700                 /* Turn on auto-select of media (10baseT or BNC) so that the user
701                    can watch the LEDs even if the board isn't opened. */
702                 outw(0x0002, ioaddr+LANCE_ADDR);
703                 /* Don't touch 10base2 power bit. */
704                 outw(inw(ioaddr+LANCE_BUS_IF) | 0x0002, ioaddr+LANCE_BUS_IF);
705         }
706
707         if (lance_debug > 0  &&  did_version++ == 0)
708                 printk(version);
709
710         /* The LANCE-specific entries in the device structure. */
711         dev->open = lance_open;
712         dev->hard_start_xmit = lance_start_xmit;
713         dev->stop = lance_close;
714         dev->get_stats = lance_get_stats;
715         dev->set_multicast_list = set_multicast_list;
716         dev->tx_timeout = lance_tx_timeout;
717         dev->watchdog_timeo = TX_TIMEOUT;
718
719         err = register_netdev(dev);
720         if (err)
721                 goto out_dma;
722         return 0;
723 out_dma:
724         if (dev->dma != 4)
725                 free_dma(dev->dma);
726 out_tx:
727         kfree(lp->tx_bounce_buffs);
728 out_rx:
729         kfree((void*)lp->rx_buffs);
730 out_lp:
731         kfree(lp);
732         return err;
733 }
734
735 \f
736 static int
737 lance_open(struct net_device *dev)
738 {
739         struct lance_private *lp = dev->priv;
740         int ioaddr = dev->base_addr;
741         int i;
742
743         if (dev->irq == 0 ||
744                 request_irq(dev->irq, &lance_interrupt, 0, lp->name, dev)) {
745                 return -EAGAIN;
746         }
747
748         /* We used to allocate DMA here, but that was silly.
749            DMA lines can't be shared!  We now permanently allocate them. */
750
751         /* Reset the LANCE */
752         inw(ioaddr+LANCE_RESET);
753
754         /* The DMA controller is used as a no-operation slave, "cascade mode". */
755         if (dev->dma != 4) {
756                 unsigned long flags=claim_dma_lock();
757                 enable_dma(dev->dma);
758                 set_dma_mode(dev->dma, DMA_MODE_CASCADE);
759                 release_dma_lock(flags);
760         }
761
762         /* Un-Reset the LANCE, needed only for the NE2100. */
763         if (chip_table[lp->chip_version].flags & LANCE_MUST_UNRESET)
764                 outw(0, ioaddr+LANCE_RESET);
765
766         if (chip_table[lp->chip_version].flags & LANCE_ENABLE_AUTOSELECT) {
767                 /* This is 79C960-specific: Turn on auto-select of media (AUI, BNC). */
768                 outw(0x0002, ioaddr+LANCE_ADDR);
769                 /* Only touch autoselect bit. */
770                 outw(inw(ioaddr+LANCE_BUS_IF) | 0x0002, ioaddr+LANCE_BUS_IF);
771         }
772
773         if (lance_debug > 1)
774                 printk("%s: lance_open() irq %d dma %d tx/rx rings %#x/%#x init %#x.\n",
775                            dev->name, dev->irq, dev->dma,
776                            (u32) isa_virt_to_bus(lp->tx_ring),
777                            (u32) isa_virt_to_bus(lp->rx_ring),
778                            (u32) isa_virt_to_bus(&lp->init_block));
779
780         lance_init_ring(dev, GFP_KERNEL);
781         /* Re-initialize the LANCE, and start it when done. */
782         outw(0x0001, ioaddr+LANCE_ADDR);
783         outw((short) (u32) isa_virt_to_bus(&lp->init_block), ioaddr+LANCE_DATA);
784         outw(0x0002, ioaddr+LANCE_ADDR);
785         outw(((u32)isa_virt_to_bus(&lp->init_block)) >> 16, ioaddr+LANCE_DATA);
786
787         outw(0x0004, ioaddr+LANCE_ADDR);
788         outw(0x0915, ioaddr+LANCE_DATA);
789
790         outw(0x0000, ioaddr+LANCE_ADDR);
791         outw(0x0001, ioaddr+LANCE_DATA);
792
793         netif_start_queue (dev);
794
795         i = 0;
796         while (i++ < 100)
797                 if (inw(ioaddr+LANCE_DATA) & 0x0100)
798                         break;
799         /* 
800          * We used to clear the InitDone bit, 0x0100, here but Mark Stockton
801          * reports that doing so triggers a bug in the '974.
802          */
803         outw(0x0042, ioaddr+LANCE_DATA);
804
805         if (lance_debug > 2)
806                 printk("%s: LANCE open after %d ticks, init block %#x csr0 %4.4x.\n",
807                            dev->name, i, (u32) isa_virt_to_bus(&lp->init_block), inw(ioaddr+LANCE_DATA));
808
809         return 0;                                       /* Always succeed */
810 }
811
812 /* The LANCE has been halted for one reason or another (busmaster memory
813    arbitration error, Tx FIFO underflow, driver stopped it to reconfigure,
814    etc.).  Modern LANCE variants always reload their ring-buffer
815    configuration when restarted, so we must reinitialize our ring
816    context before restarting.  As part of this reinitialization,
817    find all packets still on the Tx ring and pretend that they had been
818    sent (in effect, drop the packets on the floor) - the higher-level
819    protocols will time out and retransmit.  It'd be better to shuffle
820    these skbs to a temp list and then actually re-Tx them after
821    restarting the chip, but I'm too lazy to do so right now.  dplatt@3do.com
822 */
823
824 static void 
825 lance_purge_ring(struct net_device *dev)
826 {
827         struct lance_private *lp = dev->priv;
828         int i;
829
830         /* Free all the skbuffs in the Rx and Tx queues. */
831         for (i = 0; i < RX_RING_SIZE; i++) {
832                 struct sk_buff *skb = lp->rx_skbuff[i];
833                 lp->rx_skbuff[i] = NULL;
834                 lp->rx_ring[i].base = 0;                /* Not owned by LANCE chip. */
835                 if (skb)
836                         dev_kfree_skb_any(skb);
837         }
838         for (i = 0; i < TX_RING_SIZE; i++) {
839                 if (lp->tx_skbuff[i]) {
840                         dev_kfree_skb_any(lp->tx_skbuff[i]);
841                         lp->tx_skbuff[i] = NULL;
842                 }
843         }
844 }
845
846
847 /* Initialize the LANCE Rx and Tx rings. */
848 static void
849 lance_init_ring(struct net_device *dev, gfp_t gfp)
850 {
851         struct lance_private *lp = dev->priv;
852         int i;
853
854         lp->cur_rx = lp->cur_tx = 0;
855         lp->dirty_rx = lp->dirty_tx = 0;
856
857         for (i = 0; i < RX_RING_SIZE; i++) {
858                 struct sk_buff *skb;
859                 void *rx_buff;
860
861                 skb = alloc_skb(PKT_BUF_SZ, GFP_DMA | gfp);
862                 lp->rx_skbuff[i] = skb;
863                 if (skb) {
864                         skb->dev = dev;
865                         rx_buff = skb->data;
866                 } else
867                         rx_buff = kmalloc(PKT_BUF_SZ, GFP_DMA | gfp);
868                 if (rx_buff == NULL)
869                         lp->rx_ring[i].base = 0;
870                 else
871                         lp->rx_ring[i].base = (u32)isa_virt_to_bus(rx_buff) | 0x80000000;
872                 lp->rx_ring[i].buf_length = -PKT_BUF_SZ;
873         }
874         /* The Tx buffer address is filled in as needed, but we do need to clear
875            the upper ownership bit. */
876         for (i = 0; i < TX_RING_SIZE; i++) {
877                 lp->tx_skbuff[i] = NULL;
878                 lp->tx_ring[i].base = 0;
879         }
880
881         lp->init_block.mode = 0x0000;
882         for (i = 0; i < 6; i++)
883                 lp->init_block.phys_addr[i] = dev->dev_addr[i];
884         lp->init_block.filter[0] = 0x00000000;
885         lp->init_block.filter[1] = 0x00000000;
886         lp->init_block.rx_ring = ((u32)isa_virt_to_bus(lp->rx_ring) & 0xffffff) | RX_RING_LEN_BITS;
887         lp->init_block.tx_ring = ((u32)isa_virt_to_bus(lp->tx_ring) & 0xffffff) | TX_RING_LEN_BITS;
888 }
889
890 static void
891 lance_restart(struct net_device *dev, unsigned int csr0_bits, int must_reinit)
892 {
893         struct lance_private *lp = dev->priv;
894
895         if (must_reinit ||
896                 (chip_table[lp->chip_version].flags & LANCE_MUST_REINIT_RING)) {
897                 lance_purge_ring(dev);
898                 lance_init_ring(dev, GFP_ATOMIC);
899         }
900         outw(0x0000,    dev->base_addr + LANCE_ADDR);
901         outw(csr0_bits, dev->base_addr + LANCE_DATA);
902 }
903
904
905 static void lance_tx_timeout (struct net_device *dev)
906 {
907         struct lance_private *lp = (struct lance_private *) dev->priv;
908         int ioaddr = dev->base_addr;
909
910         outw (0, ioaddr + LANCE_ADDR);
911         printk ("%s: transmit timed out, status %4.4x, resetting.\n",
912                 dev->name, inw (ioaddr + LANCE_DATA));
913         outw (0x0004, ioaddr + LANCE_DATA);
914         lp->stats.tx_errors++;
915 #ifndef final_version
916         if (lance_debug > 3) {
917                 int i;
918                 printk (" Ring data dump: dirty_tx %d cur_tx %d%s cur_rx %d.",
919                   lp->dirty_tx, lp->cur_tx, netif_queue_stopped(dev) ? " (full)" : "",
920                         lp->cur_rx);
921                 for (i = 0; i < RX_RING_SIZE; i++)
922                         printk ("%s %08x %04x %04x", i & 0x3 ? "" : "\n ",
923                          lp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
924                                 lp->rx_ring[i].msg_length);
925                 for (i = 0; i < TX_RING_SIZE; i++)
926                         printk ("%s %08x %04x %04x", i & 0x3 ? "" : "\n ",
927                              lp->tx_ring[i].base, -lp->tx_ring[i].length,
928                                 lp->tx_ring[i].misc);
929                 printk ("\n");
930         }
931 #endif
932         lance_restart (dev, 0x0043, 1);
933
934         dev->trans_start = jiffies;
935         netif_wake_queue (dev);
936 }
937
938
939 static int lance_start_xmit(struct sk_buff *skb, struct net_device *dev)
940 {
941         struct lance_private *lp = dev->priv;
942         int ioaddr = dev->base_addr;
943         int entry;
944         unsigned long flags;
945
946         spin_lock_irqsave(&lp->devlock, flags);
947
948         if (lance_debug > 3) {
949                 outw(0x0000, ioaddr+LANCE_ADDR);
950                 printk("%s: lance_start_xmit() called, csr0 %4.4x.\n", dev->name,
951                            inw(ioaddr+LANCE_DATA));
952                 outw(0x0000, ioaddr+LANCE_DATA);
953         }
954
955         /* Fill in a Tx ring entry */
956
957         /* Mask to ring buffer boundary. */
958         entry = lp->cur_tx & TX_RING_MOD_MASK;
959
960         /* Caution: the write order is important here, set the base address
961            with the "ownership" bits last. */
962
963         /* The old LANCE chips doesn't automatically pad buffers to min. size. */
964         if (chip_table[lp->chip_version].flags & LANCE_MUST_PAD) {
965                 if (skb->len < ETH_ZLEN) {
966                         skb = skb_padto(skb, ETH_ZLEN);
967                         if (skb == NULL)
968                                 goto out;
969                         lp->tx_ring[entry].length = -ETH_ZLEN;
970                 }
971                 else 
972                         lp->tx_ring[entry].length = -skb->len;
973         } else
974                 lp->tx_ring[entry].length = -skb->len;
975
976         lp->tx_ring[entry].misc = 0x0000;
977
978         lp->stats.tx_bytes += skb->len;
979
980         /* If any part of this buffer is >16M we must copy it to a low-memory
981            buffer. */
982         if ((u32)isa_virt_to_bus(skb->data) + skb->len > 0x01000000) {
983                 if (lance_debug > 5)
984                         printk("%s: bouncing a high-memory packet (%#x).\n",
985                                    dev->name, (u32)isa_virt_to_bus(skb->data));
986                 memcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
987                 lp->tx_ring[entry].base =
988                         ((u32)isa_virt_to_bus((lp->tx_bounce_buffs + entry)) & 0xffffff) | 0x83000000;
989                 dev_kfree_skb(skb);
990         } else {
991                 lp->tx_skbuff[entry] = skb;
992                 lp->tx_ring[entry].base = ((u32)isa_virt_to_bus(skb->data) & 0xffffff) | 0x83000000;
993         }
994         lp->cur_tx++;
995
996         /* Trigger an immediate send poll. */
997         outw(0x0000, ioaddr+LANCE_ADDR);
998         outw(0x0048, ioaddr+LANCE_DATA);
999
1000         dev->trans_start = jiffies;
1001
1002         if ((lp->cur_tx - lp->dirty_tx) >= TX_RING_SIZE)
1003                 netif_stop_queue(dev);
1004
1005 out:
1006         spin_unlock_irqrestore(&lp->devlock, flags);
1007         return 0;
1008 }
1009
1010 /* The LANCE interrupt handler. */
1011 static irqreturn_t
1012 lance_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1013 {
1014         struct net_device *dev = dev_id;
1015         struct lance_private *lp;
1016         int csr0, ioaddr, boguscnt=10;
1017         int must_restart;
1018
1019         if (dev == NULL) {
1020                 printk ("lance_interrupt(): irq %d for unknown device.\n", irq);
1021                 return IRQ_NONE;
1022         }
1023
1024         ioaddr = dev->base_addr;
1025         lp = dev->priv;
1026         
1027         spin_lock (&lp->devlock);
1028
1029         outw(0x00, dev->base_addr + LANCE_ADDR);
1030         while ((csr0 = inw(dev->base_addr + LANCE_DATA)) & 0x8600
1031                    && --boguscnt >= 0) {
1032                 /* Acknowledge all of the current interrupt sources ASAP. */
1033                 outw(csr0 & ~0x004f, dev->base_addr + LANCE_DATA);
1034
1035                 must_restart = 0;
1036
1037                 if (lance_debug > 5)
1038                         printk("%s: interrupt  csr0=%#2.2x new csr=%#2.2x.\n",
1039                                    dev->name, csr0, inw(dev->base_addr + LANCE_DATA));
1040
1041                 if (csr0 & 0x0400)                      /* Rx interrupt */
1042                         lance_rx(dev);
1043
1044                 if (csr0 & 0x0200) {            /* Tx-done interrupt */
1045                         int dirty_tx = lp->dirty_tx;
1046
1047                         while (dirty_tx < lp->cur_tx) {
1048                                 int entry = dirty_tx & TX_RING_MOD_MASK;
1049                                 int status = lp->tx_ring[entry].base;
1050                         
1051                                 if (status < 0)
1052                                         break;                  /* It still hasn't been Txed */
1053
1054                                 lp->tx_ring[entry].base = 0;
1055
1056                                 if (status & 0x40000000) {
1057                                         /* There was an major error, log it. */
1058                                         int err_status = lp->tx_ring[entry].misc;
1059                                         lp->stats.tx_errors++;
1060                                         if (err_status & 0x0400) lp->stats.tx_aborted_errors++;
1061                                         if (err_status & 0x0800) lp->stats.tx_carrier_errors++;
1062                                         if (err_status & 0x1000) lp->stats.tx_window_errors++;
1063                                         if (err_status & 0x4000) {
1064                                                 /* Ackk!  On FIFO errors the Tx unit is turned off! */
1065                                                 lp->stats.tx_fifo_errors++;
1066                                                 /* Remove this verbosity later! */
1067                                                 printk("%s: Tx FIFO error! Status %4.4x.\n",
1068                                                            dev->name, csr0);
1069                                                 /* Restart the chip. */
1070                                                 must_restart = 1;
1071                                         }
1072                                 } else {
1073                                         if (status & 0x18000000)
1074                                                 lp->stats.collisions++;
1075                                         lp->stats.tx_packets++;
1076                                 }
1077
1078                                 /* We must free the original skb if it's not a data-only copy
1079                                    in the bounce buffer. */
1080                                 if (lp->tx_skbuff[entry]) {
1081                                         dev_kfree_skb_irq(lp->tx_skbuff[entry]);
1082                                         lp->tx_skbuff[entry] = NULL;
1083                                 }
1084                                 dirty_tx++;
1085                         }
1086
1087 #ifndef final_version
1088                         if (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
1089                                 printk("out-of-sync dirty pointer, %d vs. %d, full=%s.\n",
1090                                            dirty_tx, lp->cur_tx,
1091                                            netif_queue_stopped(dev) ? "yes" : "no");
1092                                 dirty_tx += TX_RING_SIZE;
1093                         }
1094 #endif
1095
1096                         /* if the ring is no longer full, accept more packets */
1097                         if (netif_queue_stopped(dev) &&
1098                             dirty_tx > lp->cur_tx - TX_RING_SIZE + 2)
1099                                 netif_wake_queue (dev);
1100
1101                         lp->dirty_tx = dirty_tx;
1102                 }
1103
1104                 /* Log misc errors. */
1105                 if (csr0 & 0x4000) lp->stats.tx_errors++; /* Tx babble. */
1106                 if (csr0 & 0x1000) lp->stats.rx_errors++; /* Missed a Rx frame. */
1107                 if (csr0 & 0x0800) {
1108                         printk("%s: Bus master arbitration failure, status %4.4x.\n",
1109                                    dev->name, csr0);
1110                         /* Restart the chip. */
1111                         must_restart = 1;
1112                 }
1113
1114                 if (must_restart) {
1115                         /* stop the chip to clear the error condition, then restart */
1116                         outw(0x0000, dev->base_addr + LANCE_ADDR);
1117                         outw(0x0004, dev->base_addr + LANCE_DATA);
1118                         lance_restart(dev, 0x0002, 0);
1119                 }
1120         }
1121
1122         /* Clear any other interrupt, and set interrupt enable. */
1123         outw(0x0000, dev->base_addr + LANCE_ADDR);
1124         outw(0x7940, dev->base_addr + LANCE_DATA);
1125
1126         if (lance_debug > 4)
1127                 printk("%s: exiting interrupt, csr%d=%#4.4x.\n",
1128                            dev->name, inw(ioaddr + LANCE_ADDR),
1129                            inw(dev->base_addr + LANCE_DATA));
1130
1131         spin_unlock (&lp->devlock);
1132         return IRQ_HANDLED;
1133 }
1134
1135 static int
1136 lance_rx(struct net_device *dev)
1137 {
1138         struct lance_private *lp = dev->priv;
1139         int entry = lp->cur_rx & RX_RING_MOD_MASK;
1140         int i;
1141                 
1142         /* If we own the next entry, it's a new packet. Send it up. */
1143         while (lp->rx_ring[entry].base >= 0) {
1144                 int status = lp->rx_ring[entry].base >> 24;
1145
1146                 if (status != 0x03) {                   /* There was an error. */
1147                         /* There is a tricky error noted by John Murphy,
1148                            <murf@perftech.com> to Russ Nelson: Even with full-sized
1149                            buffers it's possible for a jabber packet to use two
1150                            buffers, with only the last correctly noting the error. */
1151                         if (status & 0x01)      /* Only count a general error at the */
1152                                 lp->stats.rx_errors++; /* end of a packet.*/
1153                         if (status & 0x20) lp->stats.rx_frame_errors++;
1154                         if (status & 0x10) lp->stats.rx_over_errors++;
1155                         if (status & 0x08) lp->stats.rx_crc_errors++;
1156                         if (status & 0x04) lp->stats.rx_fifo_errors++;
1157                         lp->rx_ring[entry].base &= 0x03ffffff;
1158                 }
1159                 else 
1160                 {
1161                         /* Malloc up new buffer, compatible with net3. */
1162                         short pkt_len = (lp->rx_ring[entry].msg_length & 0xfff)-4;
1163                         struct sk_buff *skb;
1164                         
1165                         if(pkt_len<60)
1166                         {
1167                                 printk("%s: Runt packet!\n",dev->name);
1168                                 lp->stats.rx_errors++;
1169                         }
1170                         else
1171                         {
1172                                 skb = dev_alloc_skb(pkt_len+2);
1173                                 if (skb == NULL) 
1174                                 {
1175                                         printk("%s: Memory squeeze, deferring packet.\n", dev->name);
1176                                         for (i=0; i < RX_RING_SIZE; i++)
1177                                                 if (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
1178                                                         break;
1179
1180                                         if (i > RX_RING_SIZE -2) 
1181                                         {
1182                                                 lp->stats.rx_dropped++;
1183                                                 lp->rx_ring[entry].base |= 0x80000000;
1184                                                 lp->cur_rx++;
1185                                         }
1186                                         break;
1187                                 }
1188                                 skb->dev = dev;
1189                                 skb_reserve(skb,2);     /* 16 byte align */
1190                                 skb_put(skb,pkt_len);   /* Make room */
1191                                 eth_copy_and_sum(skb,
1192                                         (unsigned char *)isa_bus_to_virt((lp->rx_ring[entry].base & 0x00ffffff)),
1193                                         pkt_len,0);
1194                                 skb->protocol=eth_type_trans(skb,dev);
1195                                 netif_rx(skb);
1196                                 dev->last_rx = jiffies;
1197                                 lp->stats.rx_packets++;
1198                                 lp->stats.rx_bytes+=pkt_len;
1199                         }
1200                 }
1201                 /* The docs say that the buffer length isn't touched, but Andrew Boyd
1202                    of QNX reports that some revs of the 79C965 clear it. */
1203                 lp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
1204                 lp->rx_ring[entry].base |= 0x80000000;
1205                 entry = (++lp->cur_rx) & RX_RING_MOD_MASK;
1206         }
1207
1208         /* We should check that at least two ring entries are free.      If not,
1209            we should free one and mark stats->rx_dropped++. */
1210
1211         return 0;
1212 }
1213
1214 static int
1215 lance_close(struct net_device *dev)
1216 {
1217         int ioaddr = dev->base_addr;
1218         struct lance_private *lp = dev->priv;
1219
1220         netif_stop_queue (dev);
1221
1222         if (chip_table[lp->chip_version].flags & LANCE_HAS_MISSED_FRAME) {
1223                 outw(112, ioaddr+LANCE_ADDR);
1224                 lp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
1225         }
1226         outw(0, ioaddr+LANCE_ADDR);
1227
1228         if (lance_debug > 1)
1229                 printk("%s: Shutting down ethercard, status was %2.2x.\n",
1230                            dev->name, inw(ioaddr+LANCE_DATA));
1231
1232         /* We stop the LANCE here -- it occasionally polls
1233            memory if we don't. */
1234         outw(0x0004, ioaddr+LANCE_DATA);
1235
1236         if (dev->dma != 4)
1237         {
1238                 unsigned long flags=claim_dma_lock();
1239                 disable_dma(dev->dma);
1240                 release_dma_lock(flags);
1241         }
1242         free_irq(dev->irq, dev);
1243
1244         lance_purge_ring(dev);
1245
1246         return 0;
1247 }
1248
1249 static struct net_device_stats *lance_get_stats(struct net_device *dev)
1250 {
1251         struct lance_private *lp = dev->priv;
1252
1253         if (chip_table[lp->chip_version].flags & LANCE_HAS_MISSED_FRAME) {
1254                 short ioaddr = dev->base_addr;
1255                 short saved_addr;
1256                 unsigned long flags;
1257
1258                 spin_lock_irqsave(&lp->devlock, flags);
1259                 saved_addr = inw(ioaddr+LANCE_ADDR);
1260                 outw(112, ioaddr+LANCE_ADDR);
1261                 lp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
1262                 outw(saved_addr, ioaddr+LANCE_ADDR);
1263                 spin_unlock_irqrestore(&lp->devlock, flags);
1264         }
1265
1266         return &lp->stats;
1267 }
1268
1269 /* Set or clear the multicast filter for this adaptor.
1270  */
1271
1272 static void set_multicast_list(struct net_device *dev)
1273 {
1274         short ioaddr = dev->base_addr;
1275
1276         outw(0, ioaddr+LANCE_ADDR);
1277         outw(0x0004, ioaddr+LANCE_DATA); /* Temporarily stop the lance.  */
1278
1279         if (dev->flags&IFF_PROMISC) {
1280                 /* Log any net taps. */
1281                 printk("%s: Promiscuous mode enabled.\n", dev->name);
1282                 outw(15, ioaddr+LANCE_ADDR);
1283                 outw(0x8000, ioaddr+LANCE_DATA); /* Set promiscuous mode */
1284         } else {
1285                 short multicast_table[4];
1286                 int i;
1287                 int num_addrs=dev->mc_count;
1288                 if(dev->flags&IFF_ALLMULTI)
1289                         num_addrs=1;
1290                 /* FIXIT: We don't use the multicast table, but rely on upper-layer filtering. */
1291                 memset(multicast_table, (num_addrs == 0) ? 0 : -1, sizeof(multicast_table));
1292                 for (i = 0; i < 4; i++) {
1293                         outw(8 + i, ioaddr+LANCE_ADDR);
1294                         outw(multicast_table[i], ioaddr+LANCE_DATA);
1295                 }
1296                 outw(15, ioaddr+LANCE_ADDR);
1297                 outw(0x0000, ioaddr+LANCE_DATA); /* Unset promiscuous mode */
1298         }
1299
1300         lance_restart(dev, 0x0142, 0); /*  Resume normal operation */
1301
1302 }
1303