blob: d1d714faa6ce04a939ddd1e210ca4136e79ca199 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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
45static 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
65static unsigned int lance_portlist[] __initdata = { 0x300, 0x320, 0x340, 0x360, 0};
66static int lance_probe1(struct net_device *dev, int ioaddr, int irq, int options);
67static int __init do_lance_probe(struct net_device *dev);
68
69
70static 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
90static int lance_debug = LANCE_DEBUG;
91#else
92static int lance_debug = 1;
93#endif
94
95/*
96 Theory of Operation
97
98I. Board Compatibility
99
100This device driver is designed for the AMD 79C960, the "PCnet-ISA
101single-chip ethernet controller for ISA". This chip is used in a wide
102variety of boards from vendors such as Allied Telesis, HP, Kingston,
103and Boca. This driver is also intended to work with older AMD 7990
104designs, such as the NE1500 and NE2100, and newer 79C961. For convenience,
105I use the name LANCE to refer to all of the AMD chips, even though it properly
106refers only to the original 7990.
107
108II. Board-specific settings
109
110The driver is designed to work the boards that use the faster
111bus-master mode, rather than in shared memory mode. (Only older designs
112have on-board buffer memory needed to support the slower shared memory mode.)
113
114Most ISA boards have jumpered settings for the I/O base, IRQ line, and DMA
115channel. This driver probes the likely base addresses:
116{0x300, 0x320, 0x340, 0x360}.
117After the board is found it generates a DMA-timeout interrupt and uses
118autoIRQ to find the IRQ line. The DMA channel can be set with the low bits
119of the otherwise-unused dev->mem_start value (aka PARAM1). If unset it is
120probed for by enabling each free DMA channel in turn and checking if
121initialization succeeds.
122
123The HP-J2405A board is an exception: with this board it is easy to read the
124EEPROM-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
127III. Driver operation
128
129IIIa. Ring buffers
130The LANCE uses ring buffers of Tx and Rx descriptors. Each entry describes
131the base and length of the data buffer, along with status bits. The length
132of these buffers is set by LANCE_LOG_{RX,TX}_BUFFERS, which is log_2() of
133the buffer length (rather than being directly the buffer length) for
134implementation ease. The current values are 2 (Tx) and 4 (Rx), which leads to
135ring sizes of 4 (Tx) and 16 (Rx). Increasing the number of ring entries
136needlessly uses extra space and reduces the chance that an upper layer will
137be able to reorder queued Tx packets based on priority. Decreasing the number
138of entries makes it more difficult to achieve back-to-back packet transmission
139and increases the chance that Rx ring will overflow. (Consider the worst case
140of receiving back-to-back minimum-sized packets.)
141
142The LANCE has the capability to "chain" both Rx and Tx buffers, but this driver
143statically allocates full-sized (slightly oversized -- PKT_BUF_SZ) buffers to
144avoid the administrative overhead. For the Rx side this avoids dynamically
145allocating full-sized buffers "just in case", at the expense of a
146memory-to-memory data copy for each packet received. For most systems this
147is a good tradeoff: the Rx buffer will always be in low memory, the copy
148is inexpensive, and it primes the cache for later packet processing. For Tx
149the buffers are only used when needed as low-memory bounce buffers.
150
151IIIB. 16M memory limitations.
152For the ISA bus master mode all structures used directly by the LANCE,
153the initialization block, Rx and Tx rings, and data buffers, must be
154accessible from the ISA bus, i.e. in the lower 16M of real memory.
155This is a problem for current Linux kernels on >16M machines. The network
156devices are initialized after memory initialization, and the kernel doles out
157memory from the top of memory downward. The current solution is to have a
158special network initialization routine that's called before memory
159initialization; this will eventually be generalized for all network devices.
160As mentioned before, low-memory "bounce-buffers" are used when needed.
161
162IIIC. Synchronization
163The driver runs as two independent, single-threaded flows of control. One
164is the send-packet routine, which enforces single-threaded use by the
165dev->tbusy flag. The other thread is the interrupt handler, which is single
166threaded by the hardware and other software.
167
168The send packet thread has partial control over the Tx ring and 'dev->tbusy'
169flag. It sets the tbusy flag whenever it's queuing a Tx packet. If the next
170queue slot is empty, it clears the tbusy flag when finished otherwise it sets
171the 'lp->tx_full' flag.
172
173The interrupt handler has exclusive control over the Rx ring and records stats
174from the Tx ring. (The Tx-done interrupt can't be selectively turned off, so
175we can't avoid the interrupt overhead by having the Tx routine reap the Tx
176stats.) After reaping the stats, it marks the queue entry as empty by setting
177the 'base' to zero. Iff the 'lp->tx_full' flag is set, it clears both the
178tx_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. */
212struct 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
218struct 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. */
225struct 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
234struct 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. */
264static 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
293enum {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. */
298static unsigned char lance_need_isa_bounce_buffers = 1;
299
300static int lance_open(struct net_device *dev);
Al Viro9e249742005-10-21 03:22:29 -0400301static void lance_init_ring(struct net_device *dev, gfp_t mode);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700302static int lance_start_xmit(struct sk_buff *skb, struct net_device *dev);
303static int lance_rx(struct net_device *dev);
304static irqreturn_t lance_interrupt(int irq, void *dev_id, struct pt_regs *regs);
305static int lance_close(struct net_device *dev);
306static struct net_device_stats *lance_get_stats(struct net_device *dev);
307static void set_multicast_list(struct net_device *dev);
308static void lance_tx_timeout (struct net_device *dev);
309
310
311
Linus Torvalds1da177e2005-04-16 15:20:36 -0700312#ifdef MODULE
313#define MAX_CARDS 8 /* Max number of interfaces (cards) per module */
314
315static struct net_device *dev_lance[MAX_CARDS];
316static int io[MAX_CARDS];
317static int dma[MAX_CARDS];
318static int irq[MAX_CARDS];
319
320module_param_array(io, int, NULL, 0);
321module_param_array(dma, int, NULL, 0);
322module_param_array(irq, int, NULL, 0);
323module_param(lance_debug, int, 0);
324MODULE_PARM_DESC(io, "LANCE/PCnet I/O base address(es),required");
325MODULE_PARM_DESC(dma, "LANCE/PCnet ISA DMA channel (ignored for some devices)");
326MODULE_PARM_DESC(irq, "LANCE/PCnet IRQ number (ignored for some devices)");
327MODULE_PARM_DESC(lance_debug, "LANCE/PCnet debug level (0-7)");
328
329int 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) {
b1fc5502005-05-12 20:11:55 -0400348 dev_lance[found++] = dev;
349 continue;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700350 }
351 free_netdev(dev);
352 break;
353 }
354 if (found != 0)
355 return 0;
356 return -ENXIO;
357}
358
Denis Vlasenko64916f12006-01-05 22:45:47 -0800359static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700370void 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 */
384MODULE_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 */
391static 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
434struct 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700448 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449out:
450 free_netdev(dev);
451 return ERR_PTR(err);
452}
453#endif
454
455static 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
b1fc5502005-05-12 20:11:55 -0400719 err = register_netdev(dev);
720 if (err)
721 goto out_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700722 return 0;
723out_dma:
724 if (dev->dma != 4)
725 free_dma(dev->dma);
726out_tx:
727 kfree(lp->tx_bounce_buffs);
728out_rx:
729 kfree((void*)lp->rx_buffs);
730out_lp:
731 kfree(lp);
732 return err;
733}
734
735
736static int
737lance_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
824static void
825lance_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. */
848static void
Al Viro9e249742005-10-21 03:22:29 -0400849lance_init_ring(struct net_device *dev, gfp_t gfp)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700850{
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;
David S. Miller689be432005-06-28 15:25:31 -0700865 rx_buff = skb->data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700866 } 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
890static void
891lance_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
905static 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
939static 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
1005out:
1006 spin_unlock_irqrestore(&lp->devlock, flags);
1007 return 0;
1008}
1009
1010/* The LANCE interrupt handler. */
1011static irqreturn_t
1012lance_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
1135static int
1136lance_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
1214static int
1215lance_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
1249static 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
1272static 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