1 /* ewrk3.c: A DIGITAL EtherWORKS 3 ethernet driver for Linux.
3 Written 1994 by David C. Davies.
5 Copyright 1994 Digital Equipment Corporation.
7 This software may be used and distributed according to the terms of
8 the GNU General Public License, incorporated herein by reference.
10 This driver is written for the Digital Equipment Corporation series
11 of EtherWORKS ethernet cards:
17 The driver has been tested on a relatively busy network using the DE205
18 card and benchmarked with 'ttcp': it transferred 16M of data at 975kB/s
19 (7.8Mb/s) to a DECstation 5000/200.
21 The author may be reached at davies@maniac.ultranet.com.
23 =========================================================================
24 This driver has been written substantially from scratch, although its
25 inheritance of style and stack interface from 'depca.c' and in turn from
26 Donald Becker's 'lance.c' should be obvious.
28 The DE203/4/5 boards all use a new proprietary chip in place of the
29 LANCE chip used in prior cards (DEPCA, DE100, DE200/1/2, DE210, DE422).
30 Use the depca.c driver in the standard distribution for the LANCE based
31 cards from DIGITAL; this driver will not work with them.
33 The DE203/4/5 cards have 2 main modes: shared memory and I/O only. I/O
34 only makes all the card accesses through I/O transactions and no high
35 (shared) memory is used. This mode provides a >48% performance penalty
36 and is deprecated in this driver, although allowed to provide initial
37 setup when hardstrapped.
39 The shared memory mode comes in 3 flavours: 2kB, 32kB and 64kB. There is
40 no point in using any mode other than the 2kB mode - their performances
41 are virtually identical, although the driver has been tested in the 2kB
42 and 32kB modes. I would suggest you uncomment the line:
46 to allow the driver to configure the card as a 2kB card at your current
47 base address, thus leaving more room to clutter your system box with
48 other memory hungry boards.
50 As many ISA and EISA cards can be supported under this driver as you
51 wish, limited primarily by the available IRQ lines, rather than by the
52 available I/O addresses (24 ISA, 16 EISA). I have checked different
53 configurations of multiple depca cards and ewrk3 cards and have not
54 found a problem yet (provided you have at least depca.c v0.38) ...
56 The board IRQ setting must be at an unused IRQ which is auto-probed
57 using Donald Becker's autoprobe routines. All these cards are at
60 No 16MB memory limitation should exist with this driver as DMA is not
61 used and the common memory area is in low memory on the network card (my
62 current system has 20MB and I've not had problems yet).
64 The ability to load this driver as a loadable module has been included
65 and used extensively during the driver development (to save those long
66 reboot sequences). To utilise this ability, you have to do 8 things:
68 0) have a copy of the loadable modules code installed on your system.
69 1) copy ewrk3.c from the /linux/drivers/net directory to your favourite
71 2) edit the source code near line 1898 to reflect the I/O address and
73 3) compile ewrk3.c, but include -DMODULE in the command line to ensure
74 that the correct bits are compiled (see end of source code).
75 4) if you are wanting to add a new card, goto 5. Otherwise, recompile a
76 kernel with the ewrk3 configuration turned off and reboot.
78 [Alan Cox: Changed this so you can insmod ewrk3.o irq=x io=y]
79 [Adam Kropelin: now accepts irq=x1,x2 io=y1,y2 for multiple cards]
80 6) run the net startup bits for your new eth?? interface manually
81 (usually /etc/rc.inet[12] at boot time).
84 Note that autoprobing is not allowed in loadable modules - the system is
85 already up and running and you're messing with interrupts.
87 To unload a module, turn off the associated interface
88 'ifconfig eth?? down' then 'rmmod ewrk3'.
90 Promiscuous mode has been turned off in this driver, but all the
91 multicast address bits have been turned on. This improved the send
92 performance on a busy network by about 13%.
94 Ioctl's have now been provided (primarily because I wanted to grab some
95 packet size statistics). They are patterned after 'plipconfig.c' from a
96 suggestion by Alan Cox. Using these ioctls, you can enable promiscuous
97 mode, add/delete multicast addresses, change the hardware address, get
98 packet size distribution statistics and muck around with the control and
99 status register. I'll add others if and when the need arises.
108 Version Date Description
110 0.1 26-aug-94 Initial writing. ALPHA code release.
111 0.11 31-aug-94 Fixed: 2k mode memory base calc.,
113 IRQ vector assignments during autoprobe.
114 0.12 31-aug-94 Tested working on LeMAC2 (DE20[345]-AC) card.
115 Fixed up MCA hash table algorithm.
116 0.20 4-sep-94 Added IOCTL functionality.
117 0.21 14-sep-94 Added I/O mode.
118 0.21axp 15-sep-94 Special version for ALPHA AXP Linux V1.0.
119 0.22 16-sep-94 Added more IOCTLs & tidied up.
120 0.23 21-sep-94 Added transmit cut through.
121 0.24 31-oct-94 Added uid checks in some ioctls.
122 0.30 1-nov-94 BETA code release.
123 0.31 5-dec-94 Added check/allocate region code.
124 0.32 16-jan-95 Broadcast packet fix.
125 0.33 10-Feb-95 Fix recognition bug reported by <bkm@star.rl.ac.uk>.
126 0.40 27-Dec-95 Rationalise MODULE and autoprobe code.
127 Rewrite for portability & updated.
128 ALPHA support from <jestabro@amt.tay1.dec.com>
129 Added verify_area() calls in ewrk3_ioctl() from
130 suggestion by <heiko@colossus.escape.de>.
131 Add new multicasting code.
132 0.41 20-Jan-96 Fix IRQ set up problem reported by
133 <kenneth@bbs.sas.ntu.ac.sg>.
134 0.42 22-Apr-96 Fix alloc_device() bug <jari@markkus2.fimr.fi>
135 0.43 16-Aug-96 Update alloc_device() to conform to de4x5.c
136 0.44 08-Nov-01 use library crc32 functions <Matt_Domsch@dell.com>
137 0.45 19-Jul-02 fix unaligned access on alpha <martin@bruli.net>
138 0.46 10-Oct-02 Multiple NIC support when module <akropel1@rochester.rr.com>
139 0.47 18-Oct-02 ethtool support <akropel1@rochester.rr.com>
140 0.48 18-Oct-02 cli/sti removal for 2.5 <vda@port.imtp.ilyichevsk.odessa.ua>
141 ioctl locking, signature search cleanup <akropel1@rochester.rr.com>
143 =========================================================================
146 #include <linux/module.h>
147 #include <linux/kernel.h>
148 #include <linux/string.h>
149 #include <linux/errno.h>
150 #include <linux/ioport.h>
151 #include <linux/slab.h>
152 #include <linux/interrupt.h>
153 #include <linux/delay.h>
154 #include <linux/init.h>
155 #include <linux/crc32.h>
156 #include <linux/netdevice.h>
157 #include <linux/etherdevice.h>
158 #include <linux/skbuff.h>
159 #include <linux/ethtool.h>
160 #include <linux/time.h>
161 #include <linux/types.h>
162 #include <linux/unistd.h>
163 #include <linux/ctype.h>
164 #include <linux/bitops.h>
168 #include <asm/uaccess.h>
172 #define DRV_NAME "ewrk3"
173 #define DRV_VERSION "0.48"
175 static char version[] __initdata =
176 DRV_NAME ":v" DRV_VERSION " 2002/10/18 davies@maniac.ultranet.com\n";
179 static int ewrk3_debug = EWRK3_DEBUG;
181 static int ewrk3_debug = 1;
184 #define EWRK3_NDA 0xffe0 /* No Device Address */
186 #define PROBE_LENGTH 32
187 #define ETH_PROM_SIG 0xAA5500FFUL
189 #ifndef EWRK3_SIGNATURE
190 #define EWRK3_SIGNATURE {"DE203","DE204","DE205",""}
191 #define EWRK3_STRLEN 8
194 #ifndef EWRK3_RAM_BASE_ADDRESSES
195 #define EWRK3_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0x00000}
199 ** Sets up the I/O area for the autoprobe.
201 #define EWRK3_IO_BASE 0x100 /* Start address for probe search */
202 #define EWRK3_IOP_INC 0x20 /* I/O address increment */
203 #define EWRK3_TOTAL_SIZE 0x20 /* required I/O address length */
205 #ifndef MAX_NUM_EWRK3S
206 #define MAX_NUM_EWRK3S 21
209 #ifndef EWRK3_EISA_IO_PORTS
210 #define EWRK3_EISA_IO_PORTS 0x0c00 /* I/O port base address, slot 0 */
213 #ifndef MAX_EISA_SLOTS
214 #define MAX_EISA_SLOTS 16
215 #define EISA_SLOT_INC 0x1000
218 #define QUEUE_PKT_TIMEOUT (1*HZ) /* Jiffies */
221 ** EtherWORKS 3 shared memory window sizes
224 #define SHMEM_2K 0x800
225 #define SHMEM_32K 0x8000
226 #define SHMEM_64K 0x10000
229 ** EtherWORKS 3 IRQ ENABLE/DISABLE
231 #define ENABLE_IRQs { \
232 icr |= lp->irq_mask;\
233 outb(icr, EWRK3_ICR); /* Enable the IRQs */\
236 #define DISABLE_IRQs { \
237 icr = inb(EWRK3_ICR);\
238 icr &= ~lp->irq_mask;\
239 outb(icr, EWRK3_ICR); /* Disable the IRQs */\
243 ** EtherWORKS 3 START/STOP
245 #define START_EWRK3 { \
246 csr = inb(EWRK3_CSR);\
247 csr &= ~(CSR_TXD|CSR_RXD);\
248 outb(csr, EWRK3_CSR); /* Enable the TX and/or RX */\
251 #define STOP_EWRK3 { \
252 csr = (CSR_TXD|CSR_RXD);\
253 outb(csr, EWRK3_CSR); /* Disable the TX and/or RX */\
257 ** The EtherWORKS 3 private structure
259 #define EWRK3_PKT_STAT_SZ 16
260 #define EWRK3_PKT_BIN_SZ 128 /* Should be >=100 unless you
261 increase EWRK3_PKT_STAT_SZ */
264 u32 bins[EWRK3_PKT_STAT_SZ];
268 u32 excessive_collisions;
270 u32 excessive_underruns;
273 struct ewrk3_private {
274 char adapter_name[80]; /* Name exported to /proc/ioports */
275 u_long shmem_base; /* Shared memory start address */
277 u_long shmem_length; /* Shared memory window length */
278 struct ewrk3_stats pktStats; /* Private stats counters */
279 u_char irq_mask; /* Adapter IRQ mask bits */
280 u_char mPage; /* Maximum 2kB Page number */
281 u_char lemac; /* Chip rev. level */
282 u_char hard_strapped; /* Don't allow a full open */
283 u_char txc; /* Transmit cut through */
284 void __iomem *mctbl; /* Pointer to the multicast table */
285 u_char led_mask; /* Used to reserve LED access for ethtool */
290 ** Force the EtherWORKS 3 card to be in 2kB MODE
292 #define FORCE_2K_MODE { \
293 shmem_length = SHMEM_2K;\
294 outb(((mem_start - 0x80000) >> 11), EWRK3_MBR);\
300 static int ewrk3_open(struct net_device *dev);
301 static int ewrk3_queue_pkt(struct sk_buff *skb, struct net_device *dev);
302 static irqreturn_t ewrk3_interrupt(int irq, void *dev_id);
303 static int ewrk3_close(struct net_device *dev);
304 static void set_multicast_list(struct net_device *dev);
305 static int ewrk3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
306 static const struct ethtool_ops ethtool_ops_203;
307 static const struct ethtool_ops ethtool_ops;
312 static int ewrk3_hw_init(struct net_device *dev, u_long iobase);
313 static void ewrk3_init(struct net_device *dev);
314 static int ewrk3_rx(struct net_device *dev);
315 static int ewrk3_tx(struct net_device *dev);
316 static void ewrk3_timeout(struct net_device *dev);
318 static void EthwrkSignature(char *name, char *eeprom_image);
319 static int DevicePresent(u_long iobase);
320 static void SetMulticastFilter(struct net_device *dev);
321 static int EISA_signature(char *name, s32 eisa_id);
323 static int Read_EEPROM(u_long iobase, u_char eaddr);
324 static int Write_EEPROM(short data, u_long iobase, u_char eaddr);
325 static u_char get_hw_addr(struct net_device *dev, u_char * eeprom_image, char chipType);
327 static int ewrk3_probe1(struct net_device *dev, u_long iobase, int irq);
328 static int isa_probe(struct net_device *dev, u_long iobase);
329 static int eisa_probe(struct net_device *dev, u_long iobase);
331 static u_char irq[MAX_NUM_EWRK3S+1] = {5, 0, 10, 3, 11, 9, 15, 12};
333 static char name[EWRK3_STRLEN + 1];
334 static int num_ewrks3s;
337 ** Miscellaneous defines...
339 #define INIT_EWRK3 {\
340 outb(EEPROM_INIT, EWRK3_IOPR);\
345 struct net_device * __init ewrk3_probe(int unit)
347 struct net_device *dev = alloc_etherdev(sizeof(struct ewrk3_private));
351 return ERR_PTR(-ENOMEM);
354 sprintf(dev->name, "eth%d", unit);
355 netdev_boot_setup_check(dev);
358 err = ewrk3_probe1(dev, dev->base_addr, dev->irq);
369 static int __init ewrk3_probe1(struct net_device *dev, u_long iobase, int irq)
373 dev->base_addr = iobase;
376 /* Address PROM pattern */
377 err = isa_probe(dev, iobase);
379 err = eisa_probe(dev, iobase);
384 err = register_netdev(dev);
386 release_region(dev->base_addr, EWRK3_TOTAL_SIZE);
392 ewrk3_hw_init(struct net_device *dev, u_long iobase)
394 struct ewrk3_private *lp;
396 u_long mem_start, shmem_length;
397 u_char cr, cmr, icr, nicsr, lemac, hard_strapped = 0;
398 u_char eeprom_image[EEPROM_MAX], chksum, eisa_cr = 0;
401 ** Stop the EWRK3. Enable the DBR ROM. Disable interrupts and remote boot.
402 ** This also disables the EISA_ENABLE bit in the EISA Control Register.
405 eisa_cr = inb(EISA_CR);
408 nicsr = inb(EWRK3_CSR);
410 icr = inb(EWRK3_ICR);
412 outb(icr, EWRK3_ICR); /* Disable all the IRQs */
414 if (nicsr != (CSR_TXD | CSR_RXD))
417 /* Check that the EEPROM is alive and well and not living on Pluto... */
418 for (chksum = 0, i = 0; i < EEPROM_MAX; i += 2) {
424 tmp.val = (short) Read_EEPROM(iobase, (i >> 1));
425 eeprom_image[i] = tmp.c[0];
426 eeprom_image[i + 1] = tmp.c[1];
427 chksum += eeprom_image[i] + eeprom_image[i + 1];
430 if (chksum != 0) { /* Bad EEPROM Data! */
431 printk("%s: Device has a bad on-board EEPROM.\n", dev->name);
435 EthwrkSignature(name, eeprom_image);
439 dev->base_addr = iobase;
441 if (iobase > 0x400) {
442 outb(eisa_cr, EISA_CR); /* Rewrite the EISA CR */
444 lemac = eeprom_image[EEPROM_CHIPVER];
445 cmr = inb(EWRK3_CMR);
447 if (((lemac == LeMAC) && ((cmr & CMR_NO_EEPROM) != CMR_NO_EEPROM)) ||
448 ((lemac == LeMAC2) && !(cmr & CMR_HS))) {
449 printk("%s: %s at %#4lx", dev->name, name, iobase);
451 } else if ((iobase & 0x0fff) == EWRK3_EISA_IO_PORTS) {
452 /* EISA slot address */
453 printk("%s: %s at %#4lx (EISA slot %ld)",
454 dev->name, name, iobase, ((iobase >> 12) & 0x0f));
455 } else { /* ISA port address */
456 printk("%s: %s at %#4lx", dev->name, name, iobase);
459 printk(", h/w address ");
461 DevicePresent(iobase); /* need after EWRK3_INIT */
462 status = get_hw_addr(dev, eeprom_image, lemac);
463 for (i = 0; i < ETH_ALEN - 1; i++) { /* get the ethernet addr. */
464 printk("%2.2x:", dev->dev_addr[i]);
466 printk("%2.2x,\n", dev->dev_addr[i]);
469 printk(" which has an EEPROM CRC error.\n");
473 if (lemac == LeMAC2) { /* Special LeMAC2 CMR things */
474 cmr &= ~(CMR_RA | CMR_WB | CMR_LINK | CMR_POLARITY | CMR_0WS);
475 if (eeprom_image[EEPROM_MISC0] & READ_AHEAD)
477 if (eeprom_image[EEPROM_MISC0] & WRITE_BEHIND)
479 if (eeprom_image[EEPROM_NETMAN0] & NETMAN_POL)
481 if (eeprom_image[EEPROM_NETMAN0] & NETMAN_LINK)
483 if (eeprom_image[EEPROM_MISC0] & _0WS_ENA)
486 if (eeprom_image[EEPROM_SETUP] & SETUP_DRAM)
488 outb(cmr, EWRK3_CMR);
490 cr = inb(EWRK3_CR); /* Set up the Control Register */
491 cr |= eeprom_image[EEPROM_SETUP] & SETUP_APD;
493 cr |= eeprom_image[EEPROM_SETUP] & SETUP_PS;
494 cr |= eeprom_image[EEPROM_MISC0] & FAST_BUS;
495 cr |= eeprom_image[EEPROM_MISC0] & ENA_16;
499 ** Determine the base address and window length for the EWRK3
500 ** RAM from the memory base register.
502 mem_start = inb(EWRK3_MBR);
504 if (mem_start != 0) {
505 if ((mem_start >= 0x0a) && (mem_start <= 0x0f)) {
506 mem_start *= SHMEM_64K;
507 shmem_length = SHMEM_64K;
508 } else if ((mem_start >= 0x14) && (mem_start <= 0x1f)) {
509 mem_start *= SHMEM_32K;
510 shmem_length = SHMEM_32K;
511 } else if ((mem_start >= 0x40) && (mem_start <= 0xff)) {
512 mem_start = mem_start * SHMEM_2K + 0x80000;
513 shmem_length = SHMEM_2K;
519 ** See the top of this source code for comments about
520 ** uncommenting this line.
525 printk(" is hard strapped.\n");
526 } else if (mem_start) {
527 printk(" has a %dk RAM window", (int) (shmem_length >> 10));
528 printk(" at 0x%.5lx", mem_start);
530 printk(" is in I/O only mode");
533 lp = netdev_priv(dev);
534 lp->shmem_base = mem_start;
535 lp->shmem = ioremap(mem_start, shmem_length);
538 lp->shmem_length = shmem_length;
540 lp->hard_strapped = hard_strapped;
541 lp->led_mask = CR_LED;
542 spin_lock_init(&lp->hw_lock);
546 lp->mPage <<= 1; /* 2 DRAMS on module */
548 sprintf(lp->adapter_name, "%s (%s)", name, dev->name);
550 lp->irq_mask = ICR_TNEM | ICR_TXDM | ICR_RNEM | ICR_RXDM;
552 if (!hard_strapped) {
554 ** Enable EWRK3 board interrupts for autoprobing
556 icr |= ICR_IE; /* Enable interrupts */
557 outb(icr, EWRK3_ICR);
559 /* The DMA channel may be passed in on this parameter. */
562 /* To auto-IRQ we enable the initialization-done and DMA err,
563 interrupts. For now we will always get a DMA error. */
567 unsigned long irq_mask;
570 irq_mask = probe_irq_on();
573 ** Trigger a TNE interrupt.
576 outb(1, EWRK3_TDQ); /* Write to the TX done queue */
577 outb(icr, EWRK3_ICR); /* Unmask the TXD interrupt */
579 irqnum = irq[((icr & IRQ_SEL) >> 4)];
582 dev->irq = probe_irq_off(irq_mask);
583 if ((dev->irq) && (irqnum == dev->irq)) {
584 printk(" and uses IRQ%d.\n", dev->irq);
587 printk(" and failed to detect IRQ line.\n");
588 } else if ((irqnum == 1) && (lemac == LeMAC2)) {
589 printk(" and an illegal IRQ line detected.\n");
591 printk(", but incorrect IRQ line detected.\n");
597 DISABLE_IRQs; /* Mask all interrupts */
601 printk(" and requires IRQ%d.\n", dev->irq);
605 if (ewrk3_debug > 1) {
608 /* The EWRK3-specific entries in the device structure. */
609 dev->open = ewrk3_open;
610 dev->hard_start_xmit = ewrk3_queue_pkt;
611 dev->stop = ewrk3_close;
612 dev->set_multicast_list = set_multicast_list;
613 dev->do_ioctl = ewrk3_ioctl;
614 if (lp->adapter_name[4] == '3')
615 SET_ETHTOOL_OPS(dev, ðtool_ops_203);
617 SET_ETHTOOL_OPS(dev, ðtool_ops);
618 dev->tx_timeout = ewrk3_timeout;
619 dev->watchdog_timeo = QUEUE_PKT_TIMEOUT;
627 static int ewrk3_open(struct net_device *dev)
629 struct ewrk3_private *lp = netdev_priv(dev);
630 u_long iobase = dev->base_addr;
635 ** Stop the TX and RX...
639 if (!lp->hard_strapped) {
640 if (request_irq(dev->irq, (void *) ewrk3_interrupt, 0, "ewrk3", dev)) {
641 printk("ewrk3_open(): Requested IRQ%d is busy\n", dev->irq);
646 ** Re-initialize the EWRK3...
650 if (ewrk3_debug > 1) {
651 printk("%s: ewrk3 open with irq %d\n", dev->name, dev->irq);
652 printk(" physical address: ");
653 for (i = 0; i < 5; i++) {
654 printk("%2.2x:", (u_char) dev->dev_addr[i]);
656 printk("%2.2x\n", (u_char) dev->dev_addr[i]);
657 if (lp->shmem_length == 0) {
658 printk(" no shared memory, I/O only mode\n");
660 printk(" start of shared memory: 0x%08lx\n", lp->shmem_base);
661 printk(" window length: 0x%04lx\n", lp->shmem_length);
663 printk(" # of DRAMS: %d\n", ((inb(EWRK3_CMR) & 0x02) ? 2 : 1));
664 printk(" csr: 0x%02x\n", inb(EWRK3_CSR));
665 printk(" cr: 0x%02x\n", inb(EWRK3_CR));
666 printk(" icr: 0x%02x\n", inb(EWRK3_ICR));
667 printk(" cmr: 0x%02x\n", inb(EWRK3_CMR));
668 printk(" fmqc: 0x%02x\n", inb(EWRK3_FMQC));
670 netif_start_queue(dev);
672 ** Unmask EWRK3 board interrupts
674 icr = inb(EWRK3_ICR);
679 printk(KERN_ERR "%s: ewrk3 available for hard strapped set up only.\n", dev->name);
680 printk(KERN_ERR " Run the 'ewrk3setup' utility or remove the hard straps.\n");
688 ** Initialize the EtherWORKS 3 operating conditions
690 static void ewrk3_init(struct net_device *dev)
692 struct ewrk3_private *lp = netdev_priv(dev);
694 u_long iobase = dev->base_addr;
698 ** Enable any multicasts
700 set_multicast_list(dev);
703 ** Set hardware MAC address. Address is initialized from the EEPROM
704 ** during startup but may have since been changed by the user.
706 for (i=0; i<ETH_ALEN; i++)
707 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
710 ** Clean out any remaining entries in all the queues here
712 while (inb(EWRK3_TQ));
713 while (inb(EWRK3_TDQ));
714 while (inb(EWRK3_RQ));
715 while (inb(EWRK3_FMQ));
718 ** Write a clean free memory queue
720 for (page = 1; page < lp->mPage; page++) { /* Write the free page numbers */
721 outb(page, EWRK3_FMQ); /* to the Free Memory Queue */
724 START_EWRK3; /* Enable the TX and/or RX */
731 static void ewrk3_timeout(struct net_device *dev)
733 struct ewrk3_private *lp = netdev_priv(dev);
735 u_long iobase = dev->base_addr;
737 if (!lp->hard_strapped)
739 printk(KERN_WARNING"%s: transmit timed/locked out, status %04x, resetting.\n",
740 dev->name, inb(EWRK3_CSR));
743 ** Mask all board interrupts
748 ** Stop the TX and RX...
755 ** Unmask EWRK3 board interrupts
759 dev->trans_start = jiffies;
760 netif_wake_queue(dev);
765 ** Writes a socket buffer to the free page queue
767 static int ewrk3_queue_pkt (struct sk_buff *skb, struct net_device *dev)
769 struct ewrk3_private *lp = netdev_priv(dev);
770 u_long iobase = dev->base_addr;
771 void __iomem *buf = NULL;
775 spin_lock_irq (&lp->hw_lock);
778 /* if no resources available, exit, request packet be queued */
779 if (inb (EWRK3_FMQC) == 0) {
780 printk (KERN_WARNING "%s: ewrk3_queue_pkt(): No free resources...\n",
782 printk (KERN_WARNING "%s: ewrk3_queue_pkt(): CSR: %02x ICR: %02x FMQC: %02x\n",
783 dev->name, inb (EWRK3_CSR), inb (EWRK3_ICR),
789 ** Get a free page from the FMQ
791 if ((page = inb (EWRK3_FMQ)) >= lp->mPage) {
792 printk ("ewrk3_queue_pkt(): Invalid free memory page (%d).\n",
799 ** Set up shared memory window and pointer into the window
801 if (lp->shmem_length == IO_ONLY) {
802 outb (page, EWRK3_IOPR);
803 } else if (lp->shmem_length == SHMEM_2K) {
805 outb (page, EWRK3_MPR);
806 } else if (lp->shmem_length == SHMEM_32K) {
807 buf = (((short) page << 11) & 0x7800) + lp->shmem;
808 outb ((page >> 4), EWRK3_MPR);
809 } else if (lp->shmem_length == SHMEM_64K) {
810 buf = (((short) page << 11) & 0xf800) + lp->shmem;
811 outb ((page >> 5), EWRK3_MPR);
813 printk (KERN_ERR "%s: Oops - your private data area is hosed!\n",
819 ** Set up the buffer control structures and copy the data from
820 ** the socket buffer to the shared memory .
822 if (lp->shmem_length == IO_ONLY) {
824 u_char *p = skb->data;
825 outb ((char) (TCR_QMODE | TCR_PAD | TCR_IFC), EWRK3_DATA);
826 outb ((char) (skb->len & 0xff), EWRK3_DATA);
827 outb ((char) ((skb->len >> 8) & 0xff), EWRK3_DATA);
828 outb ((char) 0x04, EWRK3_DATA);
829 for (i = 0; i < skb->len; i++) {
830 outb (*p++, EWRK3_DATA);
832 outb (page, EWRK3_TQ); /* Start sending pkt */
834 writeb ((char) (TCR_QMODE | TCR_PAD | TCR_IFC), buf); /* ctrl byte */
836 writeb ((char) (skb->len & 0xff), buf); /* length (16 bit xfer) */
839 writeb(((skb->len >> 8) & 0xff) | XCT, buf);
841 writeb (0x04, buf); /* index byte */
843 writeb (0x00, (buf + skb->len)); /* Write the XCT flag */
844 memcpy_toio (buf, skb->data, PRELOAD); /* Write PRELOAD bytes */
845 outb (page, EWRK3_TQ); /* Start sending pkt */
846 memcpy_toio (buf + PRELOAD,
849 writeb (0xff, (buf + skb->len)); /* Write the XCT flag */
851 writeb ((skb->len >> 8) & 0xff, buf);
853 writeb (0x04, buf); /* index byte */
855 memcpy_toio (buf, skb->data, skb->len); /* Write data bytes */
856 outb (page, EWRK3_TQ); /* Start sending pkt */
861 spin_unlock_irq (&lp->hw_lock);
863 dev->stats.tx_bytes += skb->len;
864 dev->trans_start = jiffies;
867 /* Check for free resources: stop Tx queue if there are none */
868 if (inb (EWRK3_FMQC) == 0)
869 netif_stop_queue (dev);
875 spin_unlock_irq (&lp->hw_lock);
880 ** The EWRK3 interrupt handler.
882 static irqreturn_t ewrk3_interrupt(int irq, void *dev_id)
884 struct net_device *dev = dev_id;
885 struct ewrk3_private *lp;
889 lp = netdev_priv(dev);
890 iobase = dev->base_addr;
892 /* get the interrupt information */
893 csr = inb(EWRK3_CSR);
896 ** Mask the EWRK3 board interrupts and turn on the LED
898 spin_lock(&lp->hw_lock);
905 if (csr & CSR_RNE) /* Rx interrupt (packet[s] arrived) */
908 if (csr & CSR_TNE) /* Tx interrupt (packet sent) */
912 ** Now deal with the TX/RX disable flags. These are set when there
913 ** are no more resources. If resources free up then enable these
914 ** interrupts, otherwise mask them - failure to do this will result
915 ** in the system hanging in an interrupt loop.
917 if (inb(EWRK3_FMQC)) { /* any resources available? */
918 lp->irq_mask |= ICR_TXDM | ICR_RXDM; /* enable the interrupt source */
919 csr &= ~(CSR_TXD | CSR_RXD); /* ensure restart of a stalled TX or RX */
920 outb(csr, EWRK3_CSR);
921 netif_wake_queue(dev);
923 lp->irq_mask &= ~(ICR_TXDM | ICR_RXDM); /* disable the interrupt source */
926 /* Unmask the EWRK3 board interrupts and turn off the LED */
927 cr &= ~(lp->led_mask);
930 spin_unlock(&lp->hw_lock);
934 /* Called with lp->hw_lock held */
935 static int ewrk3_rx(struct net_device *dev)
937 struct ewrk3_private *lp = netdev_priv(dev);
938 u_long iobase = dev->base_addr;
941 void __iomem *buf = NULL;
943 while (inb(EWRK3_RQC) && !status) { /* Whilst there's incoming data */
944 if ((page = inb(EWRK3_RQ)) < lp->mPage) { /* Get next entry's buffer page */
946 ** Set up shared memory window and pointer into the window
948 if (lp->shmem_length == IO_ONLY) {
949 outb(page, EWRK3_IOPR);
950 } else if (lp->shmem_length == SHMEM_2K) {
952 outb(page, EWRK3_MPR);
953 } else if (lp->shmem_length == SHMEM_32K) {
954 buf = (((short) page << 11) & 0x7800) + lp->shmem;
955 outb((page >> 4), EWRK3_MPR);
956 } else if (lp->shmem_length == SHMEM_64K) {
957 buf = (((short) page << 11) & 0xf800) + lp->shmem;
958 outb((page >> 5), EWRK3_MPR);
961 printk("%s: Oops - your private data area is hosed!\n", dev->name);
968 if (lp->shmem_length == IO_ONLY) {
969 rx_status = inb(EWRK3_DATA);
970 pkt_len = inb(EWRK3_DATA);
971 pkt_len |= ((u_short) inb(EWRK3_DATA) << 8);
973 rx_status = readb(buf);
975 pkt_len = readw(buf);
979 if (!(rx_status & R_ROK)) { /* There was an error. */
980 dev->stats.rx_errors++; /* Update the error stats. */
981 if (rx_status & R_DBE)
982 dev->stats.rx_frame_errors++;
983 if (rx_status & R_CRC)
984 dev->stats.rx_crc_errors++;
985 if (rx_status & R_PLL)
986 dev->stats.rx_fifo_errors++;
990 if ((skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
992 skb_reserve(skb, 2); /* Align to 16 bytes */
993 p = skb_put(skb, pkt_len);
995 if (lp->shmem_length == IO_ONLY) {
996 *p = inb(EWRK3_DATA); /* dummy read */
997 for (i = 0; i < pkt_len; i++) {
998 *p++ = inb(EWRK3_DATA);
1001 memcpy_fromio(p, buf, pkt_len);
1004 for (i = 1; i < EWRK3_PKT_STAT_SZ - 1; i++) {
1005 if (pkt_len < i * EWRK3_PKT_BIN_SZ) {
1006 lp->pktStats.bins[i]++;
1007 i = EWRK3_PKT_STAT_SZ;
1010 p = skb->data; /* Look at the dest addr */
1011 if (p[0] & 0x01) { /* Multicast/Broadcast */
1012 if ((*(s16 *) & p[0] == -1) && (*(s16 *) & p[2] == -1) && (*(s16 *) & p[4] == -1)) {
1013 lp->pktStats.broadcast++;
1015 lp->pktStats.multicast++;
1017 } else if ((*(s16 *) & p[0] == *(s16 *) & dev->dev_addr[0]) &&
1018 (*(s16 *) & p[2] == *(s16 *) & dev->dev_addr[2]) &&
1019 (*(s16 *) & p[4] == *(s16 *) & dev->dev_addr[4])) {
1020 lp->pktStats.unicast++;
1022 lp->pktStats.bins[0]++; /* Duplicates stats.rx_packets */
1023 if (lp->pktStats.bins[0] == 0) { /* Reset counters */
1024 memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1027 ** Notify the upper protocol layers that there is another
1030 skb->protocol = eth_type_trans(skb, dev);
1036 dev->last_rx = jiffies;
1037 dev->stats.rx_packets++;
1038 dev->stats.rx_bytes += pkt_len;
1040 printk("%s: Insufficient memory; nuking packet.\n", dev->name);
1041 dev->stats.rx_dropped++; /* Really, deferred. */
1047 ** Return the received buffer to the free memory queue
1049 outb(page, EWRK3_FMQ);
1051 printk("ewrk3_rx(): Illegal page number, page %d\n", page);
1052 printk("ewrk3_rx(): CSR: %02x ICR: %02x FMQC: %02x\n", inb(EWRK3_CSR), inb(EWRK3_ICR), inb(EWRK3_FMQC));
1059 ** Buffer sent - check for TX buffer errors.
1060 ** Called with lp->hw_lock held
1062 static int ewrk3_tx(struct net_device *dev)
1064 struct ewrk3_private *lp = netdev_priv(dev);
1065 u_long iobase = dev->base_addr;
1068 while ((tx_status = inb(EWRK3_TDQ)) > 0) { /* Whilst there's old buffers */
1069 if (tx_status & T_VSTS) { /* The status is valid */
1070 if (tx_status & T_TXE) {
1071 dev->stats.tx_errors++;
1072 if (tx_status & T_NCL)
1073 dev->stats.tx_carrier_errors++;
1074 if (tx_status & T_LCL)
1075 dev->stats.tx_window_errors++;
1076 if (tx_status & T_CTU) {
1077 if ((tx_status & T_COLL) ^ T_XUR) {
1078 lp->pktStats.tx_underruns++;
1080 lp->pktStats.excessive_underruns++;
1082 } else if (tx_status & T_COLL) {
1083 if ((tx_status & T_COLL) ^ T_XCOLL) {
1084 dev->stats.collisions++;
1086 lp->pktStats.excessive_collisions++;
1090 dev->stats.tx_packets++;
1098 static int ewrk3_close(struct net_device *dev)
1100 struct ewrk3_private *lp = netdev_priv(dev);
1101 u_long iobase = dev->base_addr;
1104 netif_stop_queue(dev);
1106 if (ewrk3_debug > 1) {
1107 printk("%s: Shutting down ethercard, status was %2.2x.\n",
1108 dev->name, inb(EWRK3_CSR));
1111 ** We stop the EWRK3 here... mask interrupts and stop TX & RX
1118 ** Clean out the TX and RX queues here (note that one entry
1119 ** may get added to either the TXD or RX queues if the TX or RX
1120 ** just starts processing a packet before the STOP_EWRK3 command
1121 ** is received. This will be flushed in the ewrk3_open() call).
1123 while (inb(EWRK3_TQ));
1124 while (inb(EWRK3_TDQ));
1125 while (inb(EWRK3_RQ));
1127 if (!lp->hard_strapped) {
1128 free_irq(dev->irq, dev);
1134 ** Set or clear the multicast filter for this adapter.
1136 static void set_multicast_list(struct net_device *dev)
1138 struct ewrk3_private *lp = netdev_priv(dev);
1139 u_long iobase = dev->base_addr;
1142 csr = inb(EWRK3_CSR);
1144 if (lp->shmem_length == IO_ONLY) {
1147 lp->mctbl = lp->shmem + PAGE0_HTE;
1150 csr &= ~(CSR_PME | CSR_MCE);
1151 if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
1153 outb(csr, EWRK3_CSR);
1155 SetMulticastFilter(dev);
1157 outb(csr, EWRK3_CSR);
1162 ** Calculate the hash code and update the logical address filter
1163 ** from a list of ethernet multicast addresses.
1164 ** Little endian crc one liner from Matt Thomas, DEC.
1166 ** Note that when clearing the table, the broadcast bit must remain asserted
1167 ** to receive broadcast messages.
1169 static void SetMulticastFilter(struct net_device *dev)
1171 struct ewrk3_private *lp = netdev_priv(dev);
1172 struct dev_mc_list *dmi = dev->mc_list;
1173 u_long iobase = dev->base_addr;
1175 char *addrs, bit, byte;
1176 short __iomem *p = lp->mctbl;
1180 spin_lock_irq(&lp->hw_lock);
1182 if (lp->shmem_length == IO_ONLY) {
1183 outb(0, EWRK3_IOPR);
1184 outw(PAGE0_HTE, EWRK3_PIR1);
1189 if (dev->flags & IFF_ALLMULTI) {
1190 for (i = 0; i < (HASH_TABLE_LEN >> 3); i++) {
1191 if (lp->shmem_length == IO_ONLY) {
1192 outb(0xff, EWRK3_DATA);
1193 } else { /* memset didn't work here */
1200 /* Clear table except for broadcast bit */
1201 if (lp->shmem_length == IO_ONLY) {
1202 for (i = 0; i < (HASH_TABLE_LEN >> 4) - 1; i++) {
1203 outb(0x00, EWRK3_DATA);
1205 outb(0x80, EWRK3_DATA);
1206 i++; /* insert the broadcast bit */
1207 for (; i < (HASH_TABLE_LEN >> 3); i++) {
1208 outb(0x00, EWRK3_DATA);
1211 memset_io(lp->mctbl, 0, HASH_TABLE_LEN >> 3);
1212 writeb(0x80, lp->mctbl + (HASH_TABLE_LEN >> 4) - 1);
1216 for (i = 0; i < dev->mc_count; i++) { /* for each address in the list */
1217 addrs = dmi->dmi_addr;
1219 if ((*addrs & 0x01) == 1) { /* multicast address? */
1220 crc = ether_crc_le(ETH_ALEN, addrs);
1221 hashcode = crc & ((1 << 9) - 1); /* hashcode is 9 LSb of CRC */
1223 byte = hashcode >> 3; /* bit[3-8] -> byte in filter */
1224 bit = 1 << (hashcode & 0x07); /* bit[0-2] -> bit in byte */
1226 if (lp->shmem_length == IO_ONLY) {
1229 outw(PAGE0_HTE + byte, EWRK3_PIR1);
1230 tmp = inb(EWRK3_DATA);
1232 outw(PAGE0_HTE + byte, EWRK3_PIR1);
1233 outb(tmp, EWRK3_DATA);
1235 writeb(readb(lp->mctbl + byte) | bit, lp->mctbl + byte);
1241 spin_unlock_irq(&lp->hw_lock);
1245 ** ISA bus I/O device probe
1247 static int __init isa_probe(struct net_device *dev, u_long ioaddr)
1249 int i = num_ewrks3s, maxSlots;
1254 if (ioaddr >= 0x400)
1257 if (ioaddr == 0) { /* Autoprobing */
1258 iobase = EWRK3_IO_BASE; /* Get the first slot address */
1260 } else { /* Probe a specific location */
1265 for (; (i < maxSlots) && (dev != NULL);
1266 iobase += EWRK3_IOP_INC, i++)
1268 if (request_region(iobase, EWRK3_TOTAL_SIZE, DRV_NAME)) {
1269 if (DevicePresent(iobase) == 0) {
1271 ret = ewrk3_hw_init(dev, iobase);
1276 release_region(iobase, EWRK3_TOTAL_SIZE);
1285 ** EISA bus I/O device probe. Probe from slot 1 since slot 0 is usually
1288 static int __init eisa_probe(struct net_device *dev, u_long ioaddr)
1294 if (ioaddr < 0x1000)
1301 for (i = 1; (i < maxSlots) && (dev != NULL); i++, iobase += EISA_SLOT_INC) {
1302 if (EISA_signature(name, EISA_ID) == 0) {
1303 if (request_region(iobase, EWRK3_TOTAL_SIZE, DRV_NAME) &&
1304 DevicePresent(iobase) == 0) {
1306 ret = ewrk3_hw_init(dev, iobase);
1311 release_region(iobase, EWRK3_TOTAL_SIZE);
1321 ** Read the EWRK3 EEPROM using this routine
1323 static int Read_EEPROM(u_long iobase, u_char eaddr)
1327 outb((eaddr & 0x3f), EWRK3_PIR1); /* set up 6 bits of address info */
1328 outb(EEPROM_RD, EWRK3_IOPR); /* issue read command */
1329 for (i = 0; i < 5000; i++)
1330 inb(EWRK3_CSR); /* wait 1msec */
1332 return inw(EWRK3_EPROM1); /* 16 bits data return */
1336 ** Write the EWRK3 EEPROM using this routine
1338 static int Write_EEPROM(short data, u_long iobase, u_char eaddr)
1342 outb(EEPROM_WR_EN, EWRK3_IOPR); /* issue write enable command */
1343 for (i = 0; i < 5000; i++)
1344 inb(EWRK3_CSR); /* wait 1msec */
1345 outw(data, EWRK3_EPROM1); /* write data to register */
1346 outb((eaddr & 0x3f), EWRK3_PIR1); /* set up 6 bits of address info */
1347 outb(EEPROM_WR, EWRK3_IOPR); /* issue write command */
1348 for (i = 0; i < 75000; i++)
1349 inb(EWRK3_CSR); /* wait 15msec */
1350 outb(EEPROM_WR_DIS, EWRK3_IOPR); /* issue write disable command */
1351 for (i = 0; i < 5000; i++)
1352 inb(EWRK3_CSR); /* wait 1msec */
1358 ** Look for a particular board name in the on-board EEPROM.
1360 static void __init EthwrkSignature(char *name, char *eeprom_image)
1363 char *signatures[] = EWRK3_SIGNATURE;
1365 for (i=0; *signatures[i] != '\0'; i++)
1366 if( !strncmp(eeprom_image+EEPROM_PNAME7, signatures[i], strlen(signatures[i])) )
1369 if (*signatures[i] != '\0') {
1370 memcpy(name, eeprom_image+EEPROM_PNAME7, EWRK3_STRLEN);
1371 name[EWRK3_STRLEN] = '\0';
1379 ** Look for a special sequence in the Ethernet station address PROM that
1380 ** is common across all EWRK3 products.
1382 ** Search the Ethernet address ROM for the signature. Since the ROM address
1383 ** counter can start at an arbitrary point, the search must include the entire
1384 ** probe sequence length plus the (length_of_the_signature - 1).
1385 ** Stop the search IMMEDIATELY after the signature is found so that the
1386 ** PROM address counter is correctly positioned at the start of the
1387 ** ethernet address for later read out.
1390 static int __init DevicePresent(u_long iobase)
1397 char Sig[sizeof(u32) << 1];
1402 int i, j, status = 0;
1404 dev.llsig.a = ETH_PROM_SIG;
1405 dev.llsig.b = ETH_PROM_SIG;
1406 sigLength = sizeof(u32) << 1;
1408 for (i = 0, j = 0; j < sigLength && i < PROBE_LENGTH + sigLength - 1; i++) {
1409 data = inb(EWRK3_APROM);
1410 if (dev.Sig[j] == data) { /* track signature */
1412 } else { /* lost signature; begin search again */
1413 if (data == dev.Sig[0]) {
1421 if (j != sigLength) {
1422 status = -ENODEV; /* search failed */
1427 static u_char __init get_hw_addr(struct net_device *dev, u_char * eeprom_image, char chipType)
1431 u_char crc, lfsr, sd, status = 0;
1432 u_long iobase = dev->base_addr;
1435 if (chipType == LeMAC2) {
1436 for (crc = 0x6a, j = 0; j < ETH_ALEN; j++) {
1437 sd = dev->dev_addr[j] = eeprom_image[EEPROM_PADDR0 + j];
1438 outb(dev->dev_addr[j], EWRK3_PAR0 + j);
1439 for (k = 0; k < 8; k++, sd >>= 1) {
1440 lfsr = ((((crc & 0x02) >> 1) ^ (crc & 0x01)) ^ (sd & 0x01)) << 7;
1441 crc = (crc >> 1) + lfsr;
1444 if (crc != eeprom_image[EEPROM_PA_CRC])
1447 for (i = 0, k = 0; i < ETH_ALEN;) {
1452 k += (u_char) (tmp = inb(EWRK3_APROM));
1453 dev->dev_addr[i] = (u_char) tmp;
1454 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
1456 k += (u_short) ((tmp = inb(EWRK3_APROM)) << 8);
1457 dev->dev_addr[i] = (u_char) tmp;
1458 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
1466 chksum = inb(EWRK3_APROM);
1467 chksum |= (inb(EWRK3_APROM) << 8);
1476 ** Look for a particular board name in the EISA configuration space
1478 static int __init EISA_signature(char *name, s32 eisa_id)
1481 char *signatures[] = EWRK3_SIGNATURE;
1482 char ManCode[EWRK3_STRLEN];
1490 for (i = 0; i < 4; i++) {
1491 Eisa.Id[i] = inb(eisa_id + i);
1494 ManCode[0] = (((Eisa.Id[0] >> 2) & 0x1f) + 0x40);
1495 ManCode[1] = (((Eisa.Id[1] & 0xe0) >> 5) + ((Eisa.Id[0] & 0x03) << 3) + 0x40);
1496 ManCode[2] = (((Eisa.Id[2] >> 4) & 0x0f) + 0x30);
1497 ManCode[3] = ((Eisa.Id[2] & 0x0f) + 0x30);
1498 ManCode[4] = (((Eisa.Id[3] >> 4) & 0x0f) + 0x30);
1501 for (i = 0; (*signatures[i] != '\0') && (*name == '\0'); i++) {
1502 if (strstr(ManCode, signatures[i]) != NULL) {
1503 strcpy(name, ManCode);
1508 return status; /* return the device name string */
1511 static void ewrk3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1513 int fwrev = Read_EEPROM(dev->base_addr, EEPROM_REVLVL);
1515 strcpy(info->driver, DRV_NAME);
1516 strcpy(info->version, DRV_VERSION);
1517 sprintf(info->fw_version, "%d", fwrev);
1518 strcpy(info->bus_info, "N/A");
1519 info->eedump_len = EEPROM_MAX;
1522 static int ewrk3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1524 struct ewrk3_private *lp = netdev_priv(dev);
1525 unsigned long iobase = dev->base_addr;
1526 u8 cr = inb(EWRK3_CR);
1528 switch (lp->adapter_name[4]) {
1529 case '3': /* DE203 */
1530 ecmd->supported = SUPPORTED_BNC;
1531 ecmd->port = PORT_BNC;
1534 case '4': /* DE204 */
1535 ecmd->supported = SUPPORTED_TP;
1536 ecmd->port = PORT_TP;
1539 case '5': /* DE205 */
1540 ecmd->supported = SUPPORTED_TP | SUPPORTED_BNC | SUPPORTED_AUI;
1541 ecmd->autoneg = !(cr & CR_APD);
1543 ** Port is only valid if autoneg is disabled
1544 ** and even then we don't know if AUI is jumpered.
1547 ecmd->port = (cr & CR_PSEL) ? PORT_BNC : PORT_TP;
1551 ecmd->supported |= SUPPORTED_10baseT_Half;
1552 ecmd->speed = SPEED_10;
1553 ecmd->duplex = DUPLEX_HALF;
1557 static int ewrk3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1559 struct ewrk3_private *lp = netdev_priv(dev);
1560 unsigned long iobase = dev->base_addr;
1561 unsigned long flags;
1564 /* DE205 is the only card with anything to set */
1565 if (lp->adapter_name[4] != '5')
1568 /* Sanity-check parameters */
1569 if (ecmd->speed != SPEED_10)
1571 if (ecmd->port != PORT_TP && ecmd->port != PORT_BNC)
1572 return -EINVAL; /* AUI is not software-selectable */
1573 if (ecmd->transceiver != XCVR_INTERNAL)
1575 if (ecmd->duplex != DUPLEX_HALF)
1577 if (ecmd->phy_address != 0)
1580 spin_lock_irqsave(&lp->hw_lock, flags);
1583 /* If Autoneg is set, change to Auto Port mode */
1584 /* Otherwise, disable Auto Port and set port explicitly */
1585 if (ecmd->autoneg) {
1589 if (ecmd->port == PORT_TP)
1590 cr &= ~CR_PSEL; /* Force TP */
1592 cr |= CR_PSEL; /* Force BNC */
1595 /* Commit the changes */
1597 spin_unlock_irqrestore(&lp->hw_lock, flags);
1601 static u32 ewrk3_get_link(struct net_device *dev)
1603 unsigned long iobase = dev->base_addr;
1604 u8 cmr = inb(EWRK3_CMR);
1605 /* DE203 has BNC only and link status does not apply */
1606 /* On DE204 this is always valid since TP is the only port. */
1607 /* On DE205 this reflects TP status even if BNC or AUI is selected. */
1608 return !(cmr & CMR_LINK);
1611 static int ewrk3_phys_id(struct net_device *dev, u32 data)
1613 struct ewrk3_private *lp = netdev_priv(dev);
1614 unsigned long iobase = dev->base_addr;
1615 unsigned long flags;
1619 /* Toggle LED 4x per second */
1622 spin_lock_irqsave(&lp->hw_lock, flags);
1624 /* Bail if a PHYS_ID is already in progress */
1625 if (lp->led_mask == 0) {
1626 spin_unlock_irqrestore(&lp->hw_lock, flags);
1630 /* Prevent ISR from twiddling the LED */
1634 /* Toggle the LED */
1636 outb(cr ^ CR_LED, EWRK3_CR);
1638 /* Wait a little while */
1639 spin_unlock_irqrestore(&lp->hw_lock, flags);
1641 spin_lock_irqsave(&lp->hw_lock, flags);
1643 /* Exit if we got a signal */
1644 if (signal_pending(current))
1648 lp->led_mask = CR_LED;
1650 outb(cr & ~CR_LED, EWRK3_CR);
1651 spin_unlock_irqrestore(&lp->hw_lock, flags);
1652 return signal_pending(current) ? -ERESTARTSYS : 0;
1655 static const struct ethtool_ops ethtool_ops_203 = {
1656 .get_drvinfo = ewrk3_get_drvinfo,
1657 .get_settings = ewrk3_get_settings,
1658 .set_settings = ewrk3_set_settings,
1659 .phys_id = ewrk3_phys_id,
1662 static const struct ethtool_ops ethtool_ops = {
1663 .get_drvinfo = ewrk3_get_drvinfo,
1664 .get_settings = ewrk3_get_settings,
1665 .set_settings = ewrk3_set_settings,
1666 .get_link = ewrk3_get_link,
1667 .phys_id = ewrk3_phys_id,
1671 ** Perform IOCTL call functions here. Some are privileged operations and the
1672 ** effective uid is checked in those cases.
1674 static int ewrk3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1676 struct ewrk3_private *lp = netdev_priv(dev);
1677 struct ewrk3_ioctl *ioc = (struct ewrk3_ioctl *) &rq->ifr_ifru;
1678 u_long iobase = dev->base_addr;
1679 int i, j, status = 0;
1681 unsigned long flags;
1683 u_char addr[HASH_TABLE_LEN * ETH_ALEN];
1684 u_short val[(HASH_TABLE_LEN * ETH_ALEN) >> 1];
1687 union ewrk3_addr *tmp;
1689 /* All we handle are private IOCTLs */
1690 if (cmd != EWRK3IOCTL)
1693 tmp = kmalloc(sizeof(union ewrk3_addr), GFP_KERNEL);
1698 case EWRK3_GET_HWADDR: /* Get the hardware address */
1699 for (i = 0; i < ETH_ALEN; i++) {
1700 tmp->addr[i] = dev->dev_addr[i];
1702 ioc->len = ETH_ALEN;
1703 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1707 case EWRK3_SET_HWADDR: /* Set the hardware address */
1708 if (capable(CAP_NET_ADMIN)) {
1709 spin_lock_irqsave(&lp->hw_lock, flags);
1710 csr = inb(EWRK3_CSR);
1711 csr |= (CSR_TXD | CSR_RXD);
1712 outb(csr, EWRK3_CSR); /* Disable the TX and RX */
1713 spin_unlock_irqrestore(&lp->hw_lock, flags);
1715 if (copy_from_user(tmp->addr, ioc->data, ETH_ALEN)) {
1719 spin_lock_irqsave(&lp->hw_lock, flags);
1720 for (i = 0; i < ETH_ALEN; i++) {
1721 dev->dev_addr[i] = tmp->addr[i];
1722 outb(tmp->addr[i], EWRK3_PAR0 + i);
1725 csr = inb(EWRK3_CSR);
1726 csr &= ~(CSR_TXD | CSR_RXD); /* Enable the TX and RX */
1727 outb(csr, EWRK3_CSR);
1728 spin_unlock_irqrestore(&lp->hw_lock, flags);
1734 case EWRK3_SET_PROM: /* Set Promiscuous Mode */
1735 if (capable(CAP_NET_ADMIN)) {
1736 spin_lock_irqsave(&lp->hw_lock, flags);
1737 csr = inb(EWRK3_CSR);
1740 outb(csr, EWRK3_CSR);
1741 spin_unlock_irqrestore(&lp->hw_lock, flags);
1747 case EWRK3_CLR_PROM: /* Clear Promiscuous Mode */
1748 if (capable(CAP_NET_ADMIN)) {
1749 spin_lock_irqsave(&lp->hw_lock, flags);
1750 csr = inb(EWRK3_CSR);
1752 outb(csr, EWRK3_CSR);
1753 spin_unlock_irqrestore(&lp->hw_lock, flags);
1759 case EWRK3_GET_MCA: /* Get the multicast address table */
1760 spin_lock_irqsave(&lp->hw_lock, flags);
1761 if (lp->shmem_length == IO_ONLY) {
1762 outb(0, EWRK3_IOPR);
1763 outw(PAGE0_HTE, EWRK3_PIR1);
1764 for (i = 0; i < (HASH_TABLE_LEN >> 3); i++) {
1765 tmp->addr[i] = inb(EWRK3_DATA);
1769 memcpy_fromio(tmp->addr, lp->shmem + PAGE0_HTE, (HASH_TABLE_LEN >> 3));
1771 spin_unlock_irqrestore(&lp->hw_lock, flags);
1773 ioc->len = (HASH_TABLE_LEN >> 3);
1774 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1778 case EWRK3_SET_MCA: /* Set a multicast address */
1779 if (capable(CAP_NET_ADMIN)) {
1780 if (ioc->len > 1024)
1785 if (copy_from_user(tmp->addr, ioc->data, ETH_ALEN * ioc->len)) {
1789 set_multicast_list(dev);
1795 case EWRK3_CLR_MCA: /* Clear all multicast addresses */
1796 if (capable(CAP_NET_ADMIN)) {
1797 set_multicast_list(dev);
1803 case EWRK3_MCA_EN: /* Enable multicast addressing */
1804 if (capable(CAP_NET_ADMIN)) {
1805 spin_lock_irqsave(&lp->hw_lock, flags);
1806 csr = inb(EWRK3_CSR);
1809 outb(csr, EWRK3_CSR);
1810 spin_unlock_irqrestore(&lp->hw_lock, flags);
1816 case EWRK3_GET_STATS: { /* Get the driver statistics */
1817 struct ewrk3_stats *tmp_stats =
1818 kmalloc(sizeof(lp->pktStats), GFP_KERNEL);
1824 spin_lock_irqsave(&lp->hw_lock, flags);
1825 memcpy(tmp_stats, &lp->pktStats, sizeof(lp->pktStats));
1826 spin_unlock_irqrestore(&lp->hw_lock, flags);
1828 ioc->len = sizeof(lp->pktStats);
1829 if (copy_to_user(ioc->data, tmp_stats, sizeof(lp->pktStats)))
1834 case EWRK3_CLR_STATS: /* Zero out the driver statistics */
1835 if (capable(CAP_NET_ADMIN)) {
1836 spin_lock_irqsave(&lp->hw_lock, flags);
1837 memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1838 spin_unlock_irqrestore(&lp->hw_lock,flags);
1844 case EWRK3_GET_CSR: /* Get the CSR Register contents */
1845 tmp->addr[0] = inb(EWRK3_CSR);
1847 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1850 case EWRK3_SET_CSR: /* Set the CSR Register contents */
1851 if (capable(CAP_NET_ADMIN)) {
1852 if (copy_from_user(tmp->addr, ioc->data, 1)) {
1856 outb(tmp->addr[0], EWRK3_CSR);
1862 case EWRK3_GET_EEPROM: /* Get the EEPROM contents */
1863 if (capable(CAP_NET_ADMIN)) {
1864 for (i = 0; i < (EEPROM_MAX >> 1); i++) {
1865 tmp->val[i] = (short) Read_EEPROM(iobase, i);
1868 tmp->addr[i++] = inb(EWRK3_CMR); /* Config/Management Reg. */
1869 for (j = 0; j < ETH_ALEN; j++) {
1870 tmp->addr[i++] = inb(EWRK3_PAR0 + j);
1872 ioc->len = EEPROM_MAX + 1 + ETH_ALEN;
1873 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1880 case EWRK3_SET_EEPROM: /* Set the EEPROM contents */
1881 if (capable(CAP_NET_ADMIN)) {
1882 if (copy_from_user(tmp->addr, ioc->data, EEPROM_MAX)) {
1886 for (i = 0; i < (EEPROM_MAX >> 1); i++) {
1887 Write_EEPROM(tmp->val[i], iobase, i);
1894 case EWRK3_GET_CMR: /* Get the CMR Register contents */
1895 tmp->addr[0] = inb(EWRK3_CMR);
1897 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1900 case EWRK3_SET_TX_CUT_THRU: /* Set TX cut through mode */
1901 if (capable(CAP_NET_ADMIN)) {
1908 case EWRK3_CLR_TX_CUT_THRU: /* Clear TX cut through mode */
1909 if (capable(CAP_NET_ADMIN)) {
1917 status = -EOPNOTSUPP;
1924 static struct net_device *ewrk3_devs[MAX_NUM_EWRK3S];
1926 static int io[MAX_NUM_EWRK3S+1] = { 0x300, 0, };
1928 /* '21' below should really be 'MAX_NUM_EWRK3S' */
1929 module_param_array(io, int, NULL, 0);
1930 module_param_array(irq, int, NULL, 0);
1931 MODULE_PARM_DESC(io, "EtherWORKS 3 I/O base address(es)");
1932 MODULE_PARM_DESC(irq, "EtherWORKS 3 IRQ number(s)");
1934 static __exit void ewrk3_exit_module(void)
1938 for( i=0; i<ndevs; i++ ) {
1939 struct net_device *dev = ewrk3_devs[i];
1940 struct ewrk3_private *lp = netdev_priv(dev);
1941 ewrk3_devs[i] = NULL;
1942 unregister_netdev(dev);
1943 release_region(dev->base_addr, EWRK3_TOTAL_SIZE);
1949 static __init int ewrk3_init_module(void)
1953 while( io[i] && irq[i] ) {
1954 struct net_device *dev
1955 = alloc_etherdev(sizeof(struct ewrk3_private));
1960 if (ewrk3_probe1(dev, io[i], irq[i]) != 0) {
1965 ewrk3_devs[ndevs++] = dev;
1969 return ndevs ? 0 : -EIO;
1973 /* Hack for breakage in new module stuff */
1974 module_exit(ewrk3_exit_module);
1975 module_init(ewrk3_init_module);
1977 MODULE_LICENSE("GPL");
1983 * compile-command: "gcc -D__KERNEL__ -I/linux/include -Wall -Wstrict-prototypes -fomit-frame-pointer -fno-strength-reduce -malign-loops=2 -malign-jumps=2 -malign-functions=2 -O2 -m486 -c ewrk3.c"
1985 * compile-command: "gcc -D__KERNEL__ -DMODULE -I/linux/include -Wall -Wstrict-prototypes -fomit-frame-pointer -fno-strength-reduce -malign-loops=2 -malign-jumps=2 -malign-functions=2 -O2 -m486 -c ewrk3.c"