![[first]](../icons/first.png){kind=icon}
![[previous]](../icons/n_left.png){kind=icon}
![[next]](../icons/n_right.png){kind=icon}
![[last]](../icons/last.png){kind=icon}
![[top]](../icons/n_top.png){kind=icon}
![[bottom]](../icons/bottom.png){kind=icon}
![[index]](../icons/index.png){kind=icon}
![[help]](../icons/help.png){kind=icon}
*/
1 /* 3c501.c: A 3Com 3c501 ethernet driver for linux. */
2 /*
3 Written 1992,1993,1994 Donald Becker
4
5 Copyright 1993 United States Government as represented by the
6 Director, National Security Agency. This software may be used and
7 distributed according to the terms of the GNU Public License,
8 incorporated herein by reference.
9
10 This is a device driver for the 3Com Etherlink 3c501.
11 Do not purchase this card, even as a joke. It's performance is horrible,
12 and it breaks in many ways.
13
14 The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O
15 Center of Excellence in Space Data and Information Sciences
16 Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
17
18 Fixed (again!) the missing interrupt locking on TX/RX shifting.
19 Alan Cox <Alan.Cox@linux.org>
20
21 Removed calls to init_etherdev since they are no longer needed, and
22 cleaned up modularization just a bit. The driver still allows only
23 the default address for cards when loaded as a module, but that's
24 really less braindead than anyone using a 3c501 board. :)
25 19950208 (invid@msen.com)
26
27 Added traps for interrupts hitting the window as we clear and TX load
28 the board. Now getting 150K/second FTP with a 3c501 card. Still playing
29 with a TX-TX optimisation to see if we can touch 180-200K/second as seems
30 theoretically maximum.
31 19950402 Alan Cox <Alan.Cox@linux.org>
32
33 Some notes on this thing if you have to hack it. [Alan]
34
35 1] Some documentation is available from 3Com. Due to the boards age
36 standard responses when you ask for this will range from 'be serious'
37 to 'give it to a museum'. The documentation is incomplete and mostly
38 of historical interest anyway.
39
40 2] The basic system is a single buffer which can be used to receive or
41 transmit a packet. A third command mode exists when you are setting
42 things up.
43
44 3] If it's transmitting it's not receiving and vice versa. In fact the
45 time to get the board back into useful state after an operation is
46 quite large.
47
48 4] The driver works by keeping the board in receive mode waiting for a
49 packet to arrive. When one arrives it is copied out of the buffer
50 and delivered to the kernel. The card is reloaded and off we go.
51
52 5] When transmitting dev->tbusy is set and the card is reset (from
53 receive mode) [possibly losing a packet just received] to command
54 mode. A packet is loaded and transmit mode triggered. The interrupt
55 handler runs different code for transmit interrupts and can handle
56 returning to receive mode or retransmissions (yes you have to help
57 out with those too).
58
59 Problems:
60 There are a wide variety of undocumented error returns from the card
61 and you basically have to kick the board and pray if they turn up. Most
62 only occur under extreme load or if you do something the board doesn't
63 like (eg touching a register at the wrong time).
64
65 The driver is less efficient than it could be. It switches through
66 receive mode even if more transmits are queued. If this worries you buy
67 a real ethernet card.
68
69 The combination of slow receive restart and no real multicast
70 filter makes the board unusable with a kernel compiled for IP
71 multicasting in a real multicast environment. That's down to the board,
72 but even with no multicast programs running a multicast IP kernel is
73 in group 224.0.0.1 and you will therefore be listening to all multicasts.
74 One nv conference running over that ethernet and you can give up.
75
76 */
77
78 static const char *version =
79 "3c501.c: 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov).\n";
80
81 /*
82 * Braindamage remaining:
83 * The 3c501 board.
84 */
85
86 #include <linux/module.h>
87
88 #include <linux/kernel.h>
89 #include <linux/sched.h>
90 #include <linux/ptrace.h>
91 #include <linux/fcntl.h>
92 #include <linux/ioport.h>
93 #include <linux/interrupt.h>
94 #include <linux/malloc.h>
95 #include <linux/string.h>
96 #include <linux/errno.h>
97 #include <linux/config.h> /* for CONFIG_IP_MULTICAST */
98
99 #include <asm/bitops.h>
100 #include <asm/io.h>
101
102 #include <linux/netdevice.h>
103 #include <linux/etherdevice.h>
104 #include <linux/skbuff.h>
105
106 #define BLOCKOUT_2
107
108 /* A zero-terminated list of I/O addresses to be probed.
109 The 3c501 can be at many locations, but here are the popular ones. */
110 static unsigned int netcard_portlist[] =
111 { 0x280, 0x300, 0};
112
113
114 /*
115 * Index to functions.
116 */
117
118 int el1_probe(struct device *dev);
119 static int el1_probe1(struct device *dev, int ioaddr);
120 static int el_open(struct device *dev);
121 static int el_start_xmit(struct sk_buff *skb, struct device *dev);
122 static void el_interrupt(int irq, void *dev_id, struct pt_regs *regs);
123 static void el_receive(struct device *dev);
124 static void el_reset(struct device *dev);
125 static int el1_close(struct device *dev);
126 static struct enet_statistics *el1_get_stats(struct device *dev);
127 static void set_multicast_list(struct device *dev);
128
129 #define EL1_IO_EXTENT 16
130
131 #ifndef EL_DEBUG
132 #define EL_DEBUG 0 /* use 0 for production, 1 for devel., >2 for debug */
133 #endif /* Anything above 5 is wordy death! */
134 static int el_debug = EL_DEBUG;
135
136 /*
137 * Board-specific info in dev->priv.
138 */
139
140 struct net_local
141 {
142 struct enet_statistics stats;
143 int tx_pkt_start; /* The length of the current Tx packet. */
144 int collisions; /* Tx collisions this packet */
145 int loading; /* Spot buffer load collisions */
146 };
147
148
149 #define RX_STATUS (ioaddr + 0x06)
150 #define RX_CMD RX_STATUS
151 #define TX_STATUS (ioaddr + 0x07)
152 #define TX_CMD TX_STATUS
153 #define GP_LOW (ioaddr + 0x08)
154 #define GP_HIGH (ioaddr + 0x09)
155 #define RX_BUF_CLR (ioaddr + 0x0A)
156 #define RX_LOW (ioaddr + 0x0A)
157 #define RX_HIGH (ioaddr + 0x0B)
158 #define SAPROM (ioaddr + 0x0C)
159 #define AX_STATUS (ioaddr + 0x0E)
160 #define AX_CMD AX_STATUS
161 #define DATAPORT (ioaddr + 0x0F)
162 #define TX_RDY 0x08 /* In TX_STATUS */
163
164 #define EL1_DATAPTR 0x08
165 #define EL1_RXPTR 0x0A
166 #define EL1_SAPROM 0x0C
167 #define EL1_DATAPORT 0x0f
168
169 /*
170 * Writes to the ax command register.
171 */
172
173 #define AX_OFF 0x00 /* Irq off, buffer access on */
174 #define AX_SYS 0x40 /* Load the buffer */
175 #define AX_XMIT 0x44 /* Transmit a packet */
176 #define AX_RX 0x48 /* Receive a packet */
177 #define AX_LOOP 0x0C /* Loopback mode */
178 #define AX_RESET 0x80
179
180 /*
181 * Normal receive mode written to RX_STATUS. We must intr on short packets
182 * to avoid bogus rx lockups.
183 */
184
185 #define RX_NORM 0xA8 /* 0x68 == all addrs, 0xA8 only to me. */
186 #define RX_PROM 0x68 /* Senior Prom, uhmm promiscuous mode. */
187 #define RX_MULT 0xE8 /* Accept multicast packets. */
188 #define TX_NORM 0x0A /* Interrupt on everything that might hang the chip */
189
190 /*
191 * TX_STATUS register.
192 */
193
194 #define TX_COLLISION 0x02
195 #define TX_16COLLISIONS 0x04
196 #define TX_READY 0x08
197
198 #define RX_RUNT 0x08
199 #define RX_MISSED 0x01 /* Missed a packet due to 3c501 braindamage. */
200 #define RX_GOOD 0x30 /* Good packet 0x20, or simple overflow 0x10. */
201
202
203 /*
204 * The boilerplate probe code.
205 */
206
207 #ifdef HAVE_DEVLIST
208 struct netdev_entry el1_drv = {"3c501", el1_probe1, EL1_IO_EXTENT, netcard_portlist};
209 #else
210
211 int el1_probe(struct device *dev)
/* ![[next]](../icons/right.png)
![[first]](../icons/n_first.png)
![[top]](../icons/top.png)
*/
212 {
213 int i;
214 int base_addr = dev ? dev->base_addr : 0;
215
216 if (base_addr > 0x1ff) /* Check a single specified location. */
217 return el1_probe1(dev, base_addr);
218 else if (base_addr != 0) /* Don't probe at all. */
219 return ENXIO;
220
221 for (i = 0; netcard_portlist[i]; i++)
222 {
223 int ioaddr = netcard_portlist[i];
224 if (check_region(ioaddr, EL1_IO_EXTENT))
225 continue;
226 if (el1_probe1(dev, ioaddr) == 0)
227 return 0;
228 }
229
230 return ENODEV;
231 }
232 #endif
233
234 /*
235 * The actual probe.
236 */
237
238 static int el1_probe1(struct device *dev, int ioaddr)
/* ![[previous]](../icons/left.png)
*/
239 {
240 #ifndef MODULE
241
242 const char *mname; /* Vendor name */
243 unsigned char station_addr[6];
244 int autoirq = 0;
245 int i;
246
247 /*
248 * Read the station address PROM data from the special port.
249 */
250
251 for (i = 0; i < 6; i++)
252 {
253 outw(i, ioaddr + EL1_DATAPTR);
254 station_addr[i] = inb(ioaddr + EL1_SAPROM);
255 }
256 /*
257 * Check the first three octets of the S.A. for 3Com's prefix, or
258 * for the Sager NP943 prefix.
259 */
260
261 if (station_addr[0] == 0x02 && station_addr[1] == 0x60
262 && station_addr[2] == 0x8c)
263 {
264 mname = "3c501";
265 } else if (station_addr[0] == 0x00 && station_addr[1] == 0x80
266 && station_addr[2] == 0xC8)
267 {
268 mname = "NP943";
269 }
270 else
271 return ENODEV;
272
273 /*
274 * Grab the region so we can find the another board if autoIRQ fails.
275 */
276
277 request_region(ioaddr, EL1_IO_EXTENT,"3c501");
278
279 /*
280 * We auto-IRQ by shutting off the interrupt line and letting it float
281 * high.
282 */
283
284 if (dev->irq < 2)
285 {
286 autoirq_setup(2);
287 inb(RX_STATUS); /* Clear pending interrupts. */
288 inb(TX_STATUS);
289 outb(AX_LOOP + 1, AX_CMD);
290
291 outb(0x00, AX_CMD);
292
293 autoirq = autoirq_report(1);
294
295 if (autoirq == 0)
296 {
297 printk("%s probe at %#x failed to detect IRQ line.\n",
298 mname, ioaddr);
299 return EAGAIN;
300 }
301 }
302
303 outb(AX_RESET+AX_LOOP, AX_CMD); /* Loopback mode. */
304 dev->base_addr = ioaddr;
305 memcpy(dev->dev_addr, station_addr, ETH_ALEN);
306
307 if (dev->mem_start & 0xf)
308 el_debug = dev->mem_start & 0x7;
309 if (autoirq)
310 dev->irq = autoirq;
311
312 printk("%s: %s EtherLink at %#lx, using %sIRQ %d.\n", dev->name, mname, dev->base_addr,
313 autoirq ? "auto":"assigned ", dev->irq);
314
315 #ifdef CONFIG_IP_MULTICAST
316 printk("WARNING: Use of the 3c501 in a multicast kernel is NOT recommended.\n");
317 #endif
318
319 if (el_debug)
320 printk("%s", version);
321
322 /*
323 * Initialize the device structure.
324 */
325
326 dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
327 if (dev->priv == NULL)
328 return -ENOMEM;
329 memset(dev->priv, 0, sizeof(struct net_local));
330
331 /*
332 * The EL1-specific entries in the device structure.
333 */
334
335 dev->open = &el_open;
336 dev->hard_start_xmit = &el_start_xmit;
337 dev->stop = &el1_close;
338 dev->get_stats = &el1_get_stats;
339 dev->set_multicast_list = &set_multicast_list;
340
341 /*
342 * Setup the generic properties
343 */
344
345 ether_setup(dev);
346
347 #endif /* !MODULE */
348
349 return 0;
350 }
351
352 /*
353 * Open/initialize the board.
354 */
355
356 static int el_open(struct device *dev)
/* */
357 {
358 int ioaddr = dev->base_addr;
359
360 if (el_debug > 2)
361 printk("%s: Doing el_open()...", dev->name);
362
363 if (request_irq(dev->irq, &el_interrupt, 0, "3c501", NULL))
364 return -EAGAIN;
365
366 irq2dev_map[dev->irq] = dev;
367 el_reset(dev);
368
369 dev->start = 1;
370
371 outb(AX_RX, AX_CMD); /* Aux control, irq and receive enabled */
372 MOD_INC_USE_COUNT;
373 return 0;
374 }
375
376 static int el_start_xmit(struct sk_buff *skb, struct device *dev)
/* */
377 {
378 struct net_local *lp = (struct net_local *)dev->priv;
379 int ioaddr = dev->base_addr;
380 unsigned long flags;
381
382 if(dev->interrupt) /* May be unloading, don't stamp on */
383 return 1; /* the packet buffer this time */
384
385 if (dev->tbusy)
386 {
387 if (jiffies - dev->trans_start < 20)
388 {
389 if (el_debug > 2)
390 printk(" transmitter busy, deferred.\n");
391 return 1;
392 }
393 if (el_debug)
394 printk ("%s: transmit timed out, txsr %#2x axsr=%02x rxsr=%02x.\n",
395 dev->name, inb(TX_STATUS), inb(AX_STATUS), inb(RX_STATUS));
396 lp->stats.tx_errors++;
397 outb(TX_NORM, TX_CMD);
398 outb(RX_NORM, RX_CMD);
399 outb(AX_OFF, AX_CMD); /* Just trigger a false interrupt. */
400 outb(AX_RX, AX_CMD); /* Aux control, irq and receive enabled */
401 dev->tbusy = 0;
402 dev->trans_start = jiffies;
403 }
404
405 if (skb == NULL)
406 {
407 dev_tint(dev);
408 return 0;
409 }
410
411 save_flags(flags);
412
413 /*
414 * Avoid incoming interrupts between us flipping tbusy and flipping
415 * mode as the driver assumes tbusy is a faithful indicator of card
416 * state
417 */
418
419 cli();
420
421 /*
422 * Avoid timer-based retransmission conflicts.
423 */
424
425 if (set_bit(0, (void*)&dev->tbusy) != 0)
426 {
427 restore_flags(flags);
428 printk("%s: Transmitter access conflict.\n", dev->name);
429 }
430 else
431 {
432 int gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
433 unsigned char *buf = skb->data;
434
435 load_it_again_sam:
436 lp->tx_pkt_start = gp_start;
437 lp->collisions = 0;
438
439 /*
440 * Command mode with status cleared should [in theory]
441 * mean no more interrupts can be pending on the card.
442 */
443
444 #ifdef BLOCKOUT_1
445 disable_irq(dev->irq);
446 #endif
447 outb_p(AX_SYS, AX_CMD);
448 inb_p(RX_STATUS);
449 inb_p(TX_STATUS);
450
451 lp->loading=1;
452
453 /*
454 * Turn interrupts back on while we spend a pleasant afternoon
455 * loading bytes into the board
456 */
457
458 restore_flags(flags);
459 outw(0x00, RX_BUF_CLR); /* Set rx packet area to 0. */
460 outw(gp_start, GP_LOW); /* aim - packet will be loaded into buffer start */
461 outsb(DATAPORT,buf,skb->len); /* load buffer (usual thing each byte increments the pointer) */
462 outw(gp_start, GP_LOW); /* the board reuses the same register */
463 #ifndef BLOCKOUT_1
464 if(lp->loading==2) /* A receive upset our load, despite our best efforts */
465 {
466 if(el_debug>2)
467 printk("%s: burped during tx load.\n", dev->name);
468 goto load_it_again_sam; /* Sigh... */
469 }
470 #endif
471 outb(AX_XMIT, AX_CMD); /* fire ... Trigger xmit. */
472 lp->loading=0;
473 #ifdef BLOCKOUT_1
474 enable_irq(dev->irq);
475 #endif
476 dev->trans_start = jiffies;
477 }
478
479 if (el_debug > 2)
480 printk(" queued xmit.\n");
481 dev_kfree_skb (skb, FREE_WRITE);
482 return 0;
483 }
484
485
486 /*
487 * The typical workload of the driver:
488 * Handle the ether interface interrupts.
489 */
490
491 static void el_interrupt(int irq, void *dev_id, struct pt_regs *regs)
/* */
492 {
493 struct device *dev = (struct device *)(irq2dev_map[irq]);
494 struct net_local *lp;
495 int ioaddr;
496 int axsr; /* Aux. status reg. */
497
498 if (dev == NULL || dev->irq != irq)
499 {
500 printk ("3c501 driver: irq %d for unknown device.\n", irq);
501 return;
502 }
503
504 ioaddr = dev->base_addr;
505 lp = (struct net_local *)dev->priv;
506
507 /*
508 * What happened ?
509 */
510
511 axsr = inb(AX_STATUS);
512
513 /*
514 * Log it
515 */
516
517 if (el_debug > 3)
518 printk("%s: el_interrupt() aux=%#02x", dev->name, axsr);
519 if (dev->interrupt)
520 printk("%s: Reentering the interrupt driver!\n", dev->name);
521 dev->interrupt = 1;
522 #ifndef BLOCKOUT_1
523 if(lp->loading==1 && !dev->tbusy)
524 printk("%s: Inconsistent state loading while not in tx\n",
525 dev->name);
526 #endif
527 #ifdef BLOCKOUT_3
528 lp->loading=2; /* So we can spot loading interruptions */
529 #endif
530
531 if (dev->tbusy)
532 {
533
534 /*
535 * Board in transmit mode. May be loading. If we are
536 * loading we shouldn't have got this.
537 */
538
539 int txsr = inb(TX_STATUS);
540 #ifdef BLOCKOUT_2
541 if(lp->loading==1)
542 {
543 if(el_debug > 2)
544 {
545 printk("%s: Interrupt while loading [", dev->name);
546 printk(" txsr=%02x gp=%04x rp=%04x]\n", txsr, inw(GP_LOW),inw(RX_LOW));
547 }
548 lp->loading=2; /* Force a reload */
549 dev->interrupt = 0;
550 return;
551 }
552 #endif
553 if (el_debug > 6)
554 printk(" txsr=%02x gp=%04x rp=%04x", txsr, inw(GP_LOW),inw(RX_LOW));
555
556 if ((axsr & 0x80) && (txsr & TX_READY) == 0)
557 {
558 /*
559 * FIXME: is there a logic to whether to keep on trying or
560 * reset immediately ?
561 */
562 if(el_debug>1)
563 printk("%s: Unusual interrupt during Tx, txsr=%02x axsr=%02x"
564 " gp=%03x rp=%03x.\n", dev->name, txsr, axsr,
565 inw(ioaddr + EL1_DATAPTR), inw(ioaddr + EL1_RXPTR));
566 dev->tbusy = 0;
567 mark_bh(NET_BH);
568 }
569 else if (txsr & TX_16COLLISIONS)
570 {
571 /*
572 * Timed out
573 */
574 if (el_debug)
575 printk("%s: Transmit failed 16 times, ethernet jammed?\n",dev->name);
576 outb(AX_SYS, AX_CMD);
577 lp->stats.tx_aborted_errors++;
578 }
579 else if (txsr & TX_COLLISION)
580 {
581 /*
582 * Retrigger xmit.
583 */
584
585 if (el_debug > 6)
586 printk(" retransmitting after a collision.\n");
587 /*
588 * Poor little chip can't reset its own start pointer
589 */
590
591 outb(AX_SYS, AX_CMD);
592 outw(lp->tx_pkt_start, GP_LOW);
593 outb(AX_XMIT, AX_CMD);
594 lp->stats.collisions++;
595 dev->interrupt = 0;
596 return;
597 }
598 else
599 {
600 /*
601 * It worked.. we will now fall through and receive
602 */
603 lp->stats.tx_packets++;
604 if (el_debug > 6)
605 printk(" Tx succeeded %s\n",
606 (txsr & TX_RDY) ? "." : "but tx is busy!");
607 /*
608 * This is safe the interrupt is atomic WRT itself.
609 */
610
611 dev->tbusy = 0;
612 mark_bh(NET_BH); /* In case more to transmit */
613 }
614 }
615 else
616 {
617 /*
618 * In receive mode.
619 */
620
621 int rxsr = inb(RX_STATUS);
622 if (el_debug > 5)
623 printk(" rxsr=%02x txsr=%02x rp=%04x", rxsr, inb(TX_STATUS),inw(RX_LOW));
624 /*
625 * Just reading rx_status fixes most errors.
626 */
627 if (rxsr & RX_MISSED)
628 lp->stats.rx_missed_errors++;
629 else if (rxsr & RX_RUNT)
630 { /* Handled to avoid board lock-up. */
631 lp->stats.rx_length_errors++;
632 if (el_debug > 5)
633 printk(" runt.\n");
634 }
635 else if (rxsr & RX_GOOD)
636 {
637 /*
638 * Receive worked.
639 */
640 el_receive(dev);
641 }
642 else
643 {
644 /*
645 * Nothing? Something is broken!
646 */
647 if (el_debug > 2)
648 printk("%s: No packet seen, rxsr=%02x **resetting 3c501***\n",
649 dev->name, rxsr);
650 el_reset(dev);
651 }
652 if (el_debug > 3)
653 printk(".\n");
654 }
655
656 /*
657 * Move into receive mode
658 */
659
660 outb(AX_RX, AX_CMD);
661 outw(0x00, RX_BUF_CLR);
662 inb(RX_STATUS); /* Be certain that interrupts are cleared. */
663 inb(TX_STATUS);
664 dev->interrupt = 0;
665 return;
666 }
667
668
669 /*
670 * We have a good packet. Well, not really "good", just mostly not broken.
671 * We must check everything to see if it is good.
672 */
673
674 static void el_receive(struct device *dev)
/* */
675 {
676 struct net_local *lp = (struct net_local *)dev->priv;
677 int ioaddr = dev->base_addr;
678 int pkt_len;
679 struct sk_buff *skb;
680
681 pkt_len = inw(RX_LOW);
682
683 if (el_debug > 4)
684 printk(" el_receive %d.\n", pkt_len);
685
686 if ((pkt_len < 60) || (pkt_len > 1536))
687 {
688 if (el_debug)
689 printk("%s: bogus packet, length=%d\n", dev->name, pkt_len);
690 lp->stats.rx_over_errors++;
691 return;
692 }
693
694 /*
695 * Command mode so we can empty the buffer
696 */
697
698 outb(AX_SYS, AX_CMD);
699 skb = dev_alloc_skb(pkt_len+2);
700
701 /*
702 * Start of frame
703 */
704
705 outw(0x00, GP_LOW);
706 if (skb == NULL)
707 {
708 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
709 lp->stats.rx_dropped++;
710 return;
711 }
712 else
713 {
714 skb_reserve(skb,2); /* Force 16 byte alignment */
715 skb->dev = dev;
716 /*
717 * The read increments through the bytes. The interrupt
718 * handler will fix the pointer when it returns to
719 * receive mode.
720 */
721 insb(DATAPORT, skb_put(skb,pkt_len), pkt_len);
722 skb->protocol=eth_type_trans(skb,dev);
723 netif_rx(skb);
724 lp->stats.rx_packets++;
725 }
726 return;
727 }
728
729 static void el_reset(struct device *dev)
/* */
730 {
731 int ioaddr = dev->base_addr;
732
733 if (el_debug> 2)
734 printk("3c501 reset...");
735 outb(AX_RESET, AX_CMD); /* Reset the chip */
736 outb(AX_LOOP, AX_CMD); /* Aux control, irq and loopback enabled */
737 {
738 int i;
739 for (i = 0; i < 6; i++) /* Set the station address. */
740 outb(dev->dev_addr[i], ioaddr + i);
741 }
742
743 outw(0, RX_BUF_CLR); /* Set rx packet area to 0. */
744 cli(); /* Avoid glitch on writes to CMD regs */
745 outb(TX_NORM, TX_CMD); /* tx irq on done, collision */
746 outb(RX_NORM, RX_CMD); /* Set Rx commands. */
747 inb(RX_STATUS); /* Clear status. */
748 inb(TX_STATUS);
749 dev->interrupt = 0;
750 dev->tbusy = 0;
751 sti();
752 }
753
754 static int el1_close(struct device *dev)
/* */
755 {
756 int ioaddr = dev->base_addr;
757
758 if (el_debug > 2)
759 printk("%s: Shutting down ethercard at %#x.\n", dev->name, ioaddr);
760
761 dev->tbusy = 1;
762 dev->start = 0;
763
764 /*
765 * Free and disable the IRQ.
766 */
767
768 free_irq(dev->irq, NULL);
769 outb(AX_RESET, AX_CMD); /* Reset the chip */
770 irq2dev_map[dev->irq] = 0;
771
772 MOD_DEC_USE_COUNT;
773 return 0;
774 }
775
776 static struct enet_statistics *el1_get_stats(struct device *dev)
/* */
777 {
778 struct net_local *lp = (struct net_local *)dev->priv;
779 return &lp->stats;
780 }
781
782 /*
783 * Set or clear the multicast filter for this adaptor.
784 * best-effort filtering.
785 */
786
787 static void set_multicast_list(struct device *dev)
/* */
788 {
789 int ioaddr = dev->base_addr;
790
791 if(dev->flags&IFF_PROMISC)
792 {
793 outb(RX_PROM, RX_CMD);
794 inb(RX_STATUS);
795 }
796 else if (dev->mc_list || dev->flags&IFF_ALLMULTI)
797 {
798 outb(RX_MULT, RX_CMD); /* Multicast or all multicast is the same */
799 inb(RX_STATUS); /* Clear status. */
800 }
801 else
802 {
803 outb(RX_NORM, RX_CMD);
804 inb(RX_STATUS);
805 }
806 }
807
808 #ifdef MODULE
809
810 static char devicename[9] = { 0, };
811
812 static struct device dev_3c501 =
813 {
814 devicename, /* device name is inserted by linux/drivers/net/net_init.c */
815 0, 0, 0, 0,
816 0x280, 5,
817 0, 0, 0, NULL, el1_probe
818 };
819
820 static int io=0x280;
821 static int irq=5;
822
823 int init_module(void)
/* */
824 {
825 dev_3c501.irq=irq;
826 dev_3c501.base_addr=io;
827 if (register_netdev(&dev_3c501) != 0)
828 return -EIO;
829 return 0;
830 }
831
832 void cleanup_module(void)
/* ![[last]](../icons/n_last.png)
*/
833 {
834 /*
835 * No need to check MOD_IN_USE, as sys_delete_module() checks.
836 */
837
838 unregister_netdev(&dev_3c501);
839
840 /*
841 * Free up the private structure, or leak memory :-)
842 */
843
844 kfree(dev_3c501.priv);
845 dev_3c501.priv = NULL; /* gets re-allocated by el1_probe1 */
846
847 /*
848 * If we don't do this, we can't re-insmod it later.
849 */
850 release_region(dev_3c501.base_addr, EL1_IO_EXTENT);
851 }
852
853 #endif /* MODULE */
854
855 /*
856 * Local variables:
857 * compile-command: "gcc -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer -m486 -c -o 3c501.o 3c501.c"
858 * kept-new-versions: 5
859 * End:
860 */
![[bottom]](../icons/n_bottom.png){kind=icon}
*/