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