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>
165 #include <asm/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 /* If you change this, remember to also change MODULE_PARM array limits */
206 #ifndef MAX_NUM_EWRK3S
207 #define MAX_NUM_EWRK3S 21
210 #ifndef EWRK3_EISA_IO_PORTS
211 #define EWRK3_EISA_IO_PORTS 0x0c00 /* I/O port base address, slot 0 */
214 #ifndef MAX_EISA_SLOTS
215 #define MAX_EISA_SLOTS 16
216 #define EISA_SLOT_INC 0x1000
219 #define QUEUE_PKT_TIMEOUT (1*HZ) /* Jiffies */
222 ** EtherWORKS 3 shared memory window sizes
225 #define SHMEM_2K 0x800
226 #define SHMEM_32K 0x8000
227 #define SHMEM_64K 0x10000
230 ** EtherWORKS 3 IRQ ENABLE/DISABLE
232 #define ENABLE_IRQs { \
233 icr |= lp->irq_mask;\
234 outb(icr, EWRK3_ICR); /* Enable the IRQs */\
237 #define DISABLE_IRQs { \
238 icr = inb(EWRK3_ICR);\
239 icr &= ~lp->irq_mask;\
240 outb(icr, EWRK3_ICR); /* Disable the IRQs */\
244 ** EtherWORKS 3 START/STOP
246 #define START_EWRK3 { \
247 csr = inb(EWRK3_CSR);\
248 csr &= ~(CSR_TXD|CSR_RXD);\
249 outb(csr, EWRK3_CSR); /* Enable the TX and/or RX */\
252 #define STOP_EWRK3 { \
253 csr = (CSR_TXD|CSR_RXD);\
254 outb(csr, EWRK3_CSR); /* Disable the TX and/or RX */\
258 ** The EtherWORKS 3 private structure
260 #define EWRK3_PKT_STAT_SZ 16
261 #define EWRK3_PKT_BIN_SZ 128 /* Should be >=100 unless you
262 increase EWRK3_PKT_STAT_SZ */
265 u32 bins[EWRK3_PKT_STAT_SZ];
269 u32 excessive_collisions;
271 u32 excessive_underruns;
274 struct ewrk3_private {
275 char adapter_name[80]; /* Name exported to /proc/ioports */
276 u_long shmem_base; /* Shared memory start address */
277 u_long shmem_length; /* Shared memory window length */
278 struct net_device_stats stats; /* Public stats */
279 struct ewrk3_stats pktStats; /* Private stats counters */
280 u_char irq_mask; /* Adapter IRQ mask bits */
281 u_char mPage; /* Maximum 2kB Page number */
282 u_char lemac; /* Chip rev. level */
283 u_char hard_strapped; /* Don't allow a full open */
284 u_char txc; /* Transmit cut through */
285 u_char *mctbl; /* Pointer to the multicast table */
286 u_char led_mask; /* Used to reserve LED access for ethtool */
291 ** Force the EtherWORKS 3 card to be in 2kB MODE
293 #define FORCE_2K_MODE { \
294 shmem_length = SHMEM_2K;\
295 outb(((mem_start - 0x80000) >> 11), EWRK3_MBR);\
301 static int ewrk3_open(struct net_device *dev);
302 static int ewrk3_queue_pkt(struct sk_buff *skb, struct net_device *dev);
303 static irqreturn_t ewrk3_interrupt(int irq, void *dev_id, struct pt_regs *regs);
304 static int ewrk3_close(struct net_device *dev);
305 static struct net_device_stats *ewrk3_get_stats(struct net_device *dev);
306 static void set_multicast_list(struct net_device *dev);
307 static int ewrk3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
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);\
344 struct net_device * __init ewrk3_probe(int unit)
346 struct net_device *dev = alloc_etherdev(sizeof(struct ewrk3_private));
350 return ERR_PTR(-ENOMEM);
353 sprintf(dev->name, "eth%d", unit);
354 netdev_boot_setup_check(dev);
356 SET_MODULE_OWNER(dev);
358 err = ewrk3_probe1(dev, dev->base_addr, dev->irq);
368 static int __init ewrk3_probe1(struct net_device *dev, u_long iobase, int irq)
372 dev->base_addr = iobase;
375 /* Address PROM pattern */
376 err = isa_probe(dev, iobase);
378 err = eisa_probe(dev, iobase);
383 err = register_netdev(dev);
385 release_region(dev->base_addr, EWRK3_TOTAL_SIZE);
391 ewrk3_hw_init(struct net_device *dev, u_long iobase)
393 struct ewrk3_private *lp;
395 u_long mem_start, shmem_length;
396 u_char cr, cmr, icr, nicsr, lemac, hard_strapped = 0;
397 u_char eeprom_image[EEPROM_MAX], chksum, eisa_cr = 0;
400 ** Stop the EWRK3. Enable the DBR ROM. Disable interrupts and remote boot.
401 ** This also disables the EISA_ENABLE bit in the EISA Control Register.
404 eisa_cr = inb(EISA_CR);
407 nicsr = inb(EWRK3_CSR);
409 icr = inb(EWRK3_ICR);
411 outb(icr, EWRK3_ICR); /* Disable all the IRQs */
413 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 = (struct ewrk3_private *) dev->priv;
534 lp->shmem_base = mem_start;
535 lp->shmem_length = shmem_length;
537 lp->hard_strapped = hard_strapped;
538 lp->led_mask = CR_LED;
539 spin_lock_init(&lp->hw_lock);
543 lp->mPage <<= 1; /* 2 DRAMS on module */
545 sprintf(lp->adapter_name, "%s (%s)", name, dev->name);
547 lp->irq_mask = ICR_TNEM | ICR_TXDM | ICR_RNEM | ICR_RXDM;
549 if (!hard_strapped) {
551 ** Enable EWRK3 board interrupts for autoprobing
553 icr |= ICR_IE; /* Enable interrupts */
554 outb(icr, EWRK3_ICR);
556 /* The DMA channel may be passed in on this parameter. */
559 /* To auto-IRQ we enable the initialization-done and DMA err,
560 interrupts. For now we will always get a DMA error. */
564 unsigned long irq_mask;
567 irq_mask = probe_irq_on();
570 ** Trigger a TNE interrupt.
573 outb(1, EWRK3_TDQ); /* Write to the TX done queue */
574 outb(icr, EWRK3_ICR); /* Unmask the TXD interrupt */
576 irqnum = irq[((icr & IRQ_SEL) >> 4)];
579 dev->irq = probe_irq_off(irq_mask);
580 if ((dev->irq) && (irqnum == dev->irq)) {
581 printk(" and uses IRQ%d.\n", dev->irq);
584 printk(" and failed to detect IRQ line.\n");
585 } else if ((irqnum == 1) && (lemac == LeMAC2)) {
586 printk(" and an illegal IRQ line detected.\n");
588 printk(", but incorrect IRQ line detected.\n");
593 DISABLE_IRQs; /* Mask all interrupts */
597 printk(" and requires IRQ%d.\n", dev->irq);
601 if (ewrk3_debug > 1) {
604 /* The EWRK3-specific entries in the device structure. */
605 dev->open = ewrk3_open;
606 dev->hard_start_xmit = ewrk3_queue_pkt;
607 dev->stop = ewrk3_close;
608 dev->get_stats = ewrk3_get_stats;
609 dev->set_multicast_list = set_multicast_list;
610 dev->do_ioctl = ewrk3_ioctl;
611 dev->tx_timeout = ewrk3_timeout;
612 dev->watchdog_timeo = QUEUE_PKT_TIMEOUT;
620 static int ewrk3_open(struct net_device *dev)
622 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
623 u_long iobase = dev->base_addr;
628 ** Stop the TX and RX...
632 if (!lp->hard_strapped) {
633 if (request_irq(dev->irq, (void *) ewrk3_interrupt, 0, "ewrk3", dev)) {
634 printk("ewrk3_open(): Requested IRQ%d is busy\n", dev->irq);
639 ** Re-initialize the EWRK3...
643 if (ewrk3_debug > 1) {
644 printk("%s: ewrk3 open with irq %d\n", dev->name, dev->irq);
645 printk(" physical address: ");
646 for (i = 0; i < 5; i++) {
647 printk("%2.2x:", (u_char) dev->dev_addr[i]);
649 printk("%2.2x\n", (u_char) dev->dev_addr[i]);
650 if (lp->shmem_length == 0) {
651 printk(" no shared memory, I/O only mode\n");
653 printk(" start of shared memory: 0x%08lx\n", lp->shmem_base);
654 printk(" window length: 0x%04lx\n", lp->shmem_length);
656 printk(" # of DRAMS: %d\n", ((inb(EWRK3_CMR) & 0x02) ? 2 : 1));
657 printk(" csr: 0x%02x\n", inb(EWRK3_CSR));
658 printk(" cr: 0x%02x\n", inb(EWRK3_CR));
659 printk(" icr: 0x%02x\n", inb(EWRK3_ICR));
660 printk(" cmr: 0x%02x\n", inb(EWRK3_CMR));
661 printk(" fmqc: 0x%02x\n", inb(EWRK3_FMQC));
663 netif_start_queue(dev);
665 ** Unmask EWRK3 board interrupts
667 icr = inb(EWRK3_ICR);
672 printk(KERN_ERR "%s: ewrk3 available for hard strapped set up only.\n", dev->name);
673 printk(KERN_ERR " Run the 'ewrk3setup' utility or remove the hard straps.\n");
681 ** Initialize the EtherWORKS 3 operating conditions
683 static void ewrk3_init(struct net_device *dev)
685 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
687 u_long iobase = dev->base_addr;
691 ** Enable any multicasts
693 set_multicast_list(dev);
696 ** Set hardware MAC address. Address is initialized from the EEPROM
697 ** during startup but may have since been changed by the user.
699 for (i=0; i<ETH_ALEN; i++)
700 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
703 ** Clean out any remaining entries in all the queues here
705 while (inb(EWRK3_TQ));
706 while (inb(EWRK3_TDQ));
707 while (inb(EWRK3_RQ));
708 while (inb(EWRK3_FMQ));
711 ** Write a clean free memory queue
713 for (page = 1; page < lp->mPage; page++) { /* Write the free page numbers */
714 outb(page, EWRK3_FMQ); /* to the Free Memory Queue */
717 START_EWRK3; /* Enable the TX and/or RX */
724 static void ewrk3_timeout(struct net_device *dev)
726 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
728 u_long iobase = dev->base_addr;
730 if (!lp->hard_strapped)
732 printk(KERN_WARNING"%s: transmit timed/locked out, status %04x, resetting.\n",
733 dev->name, inb(EWRK3_CSR));
736 ** Mask all board interrupts
741 ** Stop the TX and RX...
748 ** Unmask EWRK3 board interrupts
752 dev->trans_start = jiffies;
753 netif_wake_queue(dev);
758 ** Writes a socket buffer to the free page queue
760 static int ewrk3_queue_pkt (struct sk_buff *skb, struct net_device *dev)
762 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
763 u_long iobase = dev->base_addr;
768 spin_lock_irq (&lp->hw_lock);
771 /* if no resources available, exit, request packet be queued */
772 if (inb (EWRK3_FMQC) == 0) {
773 printk (KERN_WARNING "%s: ewrk3_queue_pkt(): No free resources...\n",
775 printk (KERN_WARNING "%s: ewrk3_queue_pkt(): CSR: %02x ICR: %02x FMQC: %02x\n",
776 dev->name, inb (EWRK3_CSR), inb (EWRK3_ICR),
782 ** Get a free page from the FMQ
784 if ((page = inb (EWRK3_FMQ)) >= lp->mPage) {
785 printk ("ewrk3_queue_pkt(): Invalid free memory page (%d).\n",
792 ** Set up shared memory window and pointer into the window
794 if (lp->shmem_length == IO_ONLY) {
795 outb (page, EWRK3_IOPR);
796 } else if (lp->shmem_length == SHMEM_2K) {
797 buf = lp->shmem_base;
798 outb (page, EWRK3_MPR);
799 } else if (lp->shmem_length == SHMEM_32K) {
800 buf = ((((short) page << 11) & 0x7800) + lp->shmem_base);
801 outb ((page >> 4), EWRK3_MPR);
802 } else if (lp->shmem_length == SHMEM_64K) {
803 buf = ((((short) page << 11) & 0xf800) + lp->shmem_base);
804 outb ((page >> 5), EWRK3_MPR);
806 printk (KERN_ERR "%s: Oops - your private data area is hosed!\n",
812 ** Set up the buffer control structures and copy the data from
813 ** the socket buffer to the shared memory .
815 if (lp->shmem_length == IO_ONLY) {
817 u_char *p = skb->data;
818 outb ((char) (TCR_QMODE | TCR_PAD | TCR_IFC), EWRK3_DATA);
819 outb ((char) (skb->len & 0xff), EWRK3_DATA);
820 outb ((char) ((skb->len >> 8) & 0xff), EWRK3_DATA);
821 outb ((char) 0x04, EWRK3_DATA);
822 for (i = 0; i < skb->len; i++) {
823 outb (*p++, EWRK3_DATA);
825 outb (page, EWRK3_TQ); /* Start sending pkt */
827 isa_writeb ((char) (TCR_QMODE | TCR_PAD | TCR_IFC), buf); /* ctrl byte */
829 isa_writeb ((char) (skb->len & 0xff), buf); /* length (16 bit xfer) */
833 (((skb->len >> 8) & 0xff) | XCT), buf);
835 isa_writeb (0x04, buf); /* index byte */
837 isa_writeb (0x00, (buf + skb->len)); /* Write the XCT flag */
838 isa_memcpy_toio (buf, skb->data, PRELOAD); /* Write PRELOAD bytes */
839 outb (page, EWRK3_TQ); /* Start sending pkt */
840 isa_memcpy_toio (buf + PRELOAD,
843 isa_writeb (0xff, (buf + skb->len)); /* Write the XCT flag */
846 ((skb->len >> 8) & 0xff), buf);
848 isa_writeb (0x04, buf); /* index byte */
850 isa_memcpy_toio (buf, skb->data, skb->len); /* Write data bytes */
851 outb (page, EWRK3_TQ); /* Start sending pkt */
856 spin_unlock_irq (&lp->hw_lock);
858 lp->stats.tx_bytes += skb->len;
859 dev->trans_start = jiffies;
862 /* Check for free resources: stop Tx queue if there are none */
863 if (inb (EWRK3_FMQC) == 0)
864 netif_stop_queue (dev);
870 spin_unlock_irq (&lp->hw_lock);
875 ** The EWRK3 interrupt handler.
877 static irqreturn_t ewrk3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
879 struct net_device *dev = dev_id;
880 struct ewrk3_private *lp;
884 lp = (struct ewrk3_private *) dev->priv;
885 iobase = dev->base_addr;
887 /* get the interrupt information */
888 csr = inb(EWRK3_CSR);
891 ** Mask the EWRK3 board interrupts and turn on the LED
893 spin_lock(&lp->hw_lock);
900 if (csr & CSR_RNE) /* Rx interrupt (packet[s] arrived) */
903 if (csr & CSR_TNE) /* Tx interrupt (packet sent) */
907 ** Now deal with the TX/RX disable flags. These are set when there
908 ** are no more resources. If resources free up then enable these
909 ** interrupts, otherwise mask them - failure to do this will result
910 ** in the system hanging in an interrupt loop.
912 if (inb(EWRK3_FMQC)) { /* any resources available? */
913 lp->irq_mask |= ICR_TXDM | ICR_RXDM; /* enable the interrupt source */
914 csr &= ~(CSR_TXD | CSR_RXD); /* ensure restart of a stalled TX or RX */
915 outb(csr, EWRK3_CSR);
916 netif_wake_queue(dev);
918 lp->irq_mask &= ~(ICR_TXDM | ICR_RXDM); /* disable the interrupt source */
921 /* Unmask the EWRK3 board interrupts and turn off the LED */
922 cr &= ~(lp->led_mask);
925 spin_unlock(&lp->hw_lock);
929 /* Called with lp->hw_lock held */
930 static int ewrk3_rx(struct net_device *dev)
932 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
933 u_long iobase = dev->base_addr;
938 while (inb(EWRK3_RQC) && !status) { /* Whilst there's incoming data */
939 if ((page = inb(EWRK3_RQ)) < lp->mPage) { /* Get next entry's buffer page */
941 ** Set up shared memory window and pointer into the window
943 if (lp->shmem_length == IO_ONLY) {
944 outb(page, EWRK3_IOPR);
945 } else if (lp->shmem_length == SHMEM_2K) {
946 buf = lp->shmem_base;
947 outb(page, EWRK3_MPR);
948 } else if (lp->shmem_length == SHMEM_32K) {
949 buf = ((((short) page << 11) & 0x7800) + lp->shmem_base);
950 outb((page >> 4), EWRK3_MPR);
951 } else if (lp->shmem_length == SHMEM_64K) {
952 buf = ((((short) page << 11) & 0xf800) + lp->shmem_base);
953 outb((page >> 5), EWRK3_MPR);
956 printk("%s: Oops - your private data area is hosed!\n", dev->name);
963 if (lp->shmem_length == IO_ONLY) {
964 rx_status = inb(EWRK3_DATA);
965 pkt_len = inb(EWRK3_DATA);
966 pkt_len |= ((u_short) inb(EWRK3_DATA) << 8);
968 rx_status = isa_readb(buf);
970 pkt_len = isa_readw(buf);
974 if (!(rx_status & R_ROK)) { /* There was an error. */
975 lp->stats.rx_errors++; /* Update the error stats. */
976 if (rx_status & R_DBE)
977 lp->stats.rx_frame_errors++;
978 if (rx_status & R_CRC)
979 lp->stats.rx_crc_errors++;
980 if (rx_status & R_PLL)
981 lp->stats.rx_fifo_errors++;
985 if ((skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
988 skb_reserve(skb, 2); /* Align to 16 bytes */
989 p = skb_put(skb, pkt_len);
991 if (lp->shmem_length == IO_ONLY) {
992 *p = inb(EWRK3_DATA); /* dummy read */
993 for (i = 0; i < pkt_len; i++) {
994 *p++ = inb(EWRK3_DATA);
997 isa_memcpy_fromio(p, buf, pkt_len);
1000 for (i = 1; i < EWRK3_PKT_STAT_SZ - 1; i++) {
1001 if (pkt_len < i * EWRK3_PKT_BIN_SZ) {
1002 lp->pktStats.bins[i]++;
1003 i = EWRK3_PKT_STAT_SZ;
1006 p = skb->data; /* Look at the dest addr */
1007 if (p[0] & 0x01) { /* Multicast/Broadcast */
1008 if ((*(s16 *) & p[0] == -1) && (*(s16 *) & p[2] == -1) && (*(s16 *) & p[4] == -1)) {
1009 lp->pktStats.broadcast++;
1011 lp->pktStats.multicast++;
1013 } else if ((*(s16 *) & p[0] == *(s16 *) & dev->dev_addr[0]) &&
1014 (*(s16 *) & p[2] == *(s16 *) & dev->dev_addr[2]) &&
1015 (*(s16 *) & p[4] == *(s16 *) & dev->dev_addr[4])) {
1016 lp->pktStats.unicast++;
1018 lp->pktStats.bins[0]++; /* Duplicates stats.rx_packets */
1019 if (lp->pktStats.bins[0] == 0) { /* Reset counters */
1020 memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1023 ** Notify the upper protocol layers that there is another
1026 skb->protocol = eth_type_trans(skb, dev);
1032 dev->last_rx = jiffies;
1033 lp->stats.rx_packets++;
1034 lp->stats.rx_bytes += pkt_len;
1036 printk("%s: Insufficient memory; nuking packet.\n", dev->name);
1037 lp->stats.rx_dropped++; /* Really, deferred. */
1043 ** Return the received buffer to the free memory queue
1045 outb(page, EWRK3_FMQ);
1047 printk("ewrk3_rx(): Illegal page number, page %d\n", page);
1048 printk("ewrk3_rx(): CSR: %02x ICR: %02x FMQC: %02x\n", inb(EWRK3_CSR), inb(EWRK3_ICR), inb(EWRK3_FMQC));
1055 ** Buffer sent - check for TX buffer errors.
1056 ** Called with lp->hw_lock held
1058 static int ewrk3_tx(struct net_device *dev)
1060 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
1061 u_long iobase = dev->base_addr;
1064 while ((tx_status = inb(EWRK3_TDQ)) > 0) { /* Whilst there's old buffers */
1065 if (tx_status & T_VSTS) { /* The status is valid */
1066 if (tx_status & T_TXE) {
1067 lp->stats.tx_errors++;
1068 if (tx_status & T_NCL)
1069 lp->stats.tx_carrier_errors++;
1070 if (tx_status & T_LCL)
1071 lp->stats.tx_window_errors++;
1072 if (tx_status & T_CTU) {
1073 if ((tx_status & T_COLL) ^ T_XUR) {
1074 lp->pktStats.tx_underruns++;
1076 lp->pktStats.excessive_underruns++;
1078 } else if (tx_status & T_COLL) {
1079 if ((tx_status & T_COLL) ^ T_XCOLL) {
1080 lp->stats.collisions++;
1082 lp->pktStats.excessive_collisions++;
1086 lp->stats.tx_packets++;
1094 static int ewrk3_close(struct net_device *dev)
1096 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
1097 u_long iobase = dev->base_addr;
1100 netif_stop_queue(dev);
1102 if (ewrk3_debug > 1) {
1103 printk("%s: Shutting down ethercard, status was %2.2x.\n",
1104 dev->name, inb(EWRK3_CSR));
1107 ** We stop the EWRK3 here... mask interrupts and stop TX & RX
1114 ** Clean out the TX and RX queues here (note that one entry
1115 ** may get added to either the TXD or RX queues if the TX or RX
1116 ** just starts processing a packet before the STOP_EWRK3 command
1117 ** is received. This will be flushed in the ewrk3_open() call).
1119 while (inb(EWRK3_TQ));
1120 while (inb(EWRK3_TDQ));
1121 while (inb(EWRK3_RQ));
1123 if (!lp->hard_strapped) {
1124 free_irq(dev->irq, dev);
1129 static struct net_device_stats *ewrk3_get_stats(struct net_device *dev)
1131 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
1133 /* Null body since there is no framing error counter */
1138 ** Set or clear the multicast filter for this adapter.
1140 static void set_multicast_list(struct net_device *dev)
1142 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
1143 u_long iobase = dev->base_addr;
1146 csr = inb(EWRK3_CSR);
1148 if (lp->shmem_length == IO_ONLY) {
1149 lp->mctbl = (char *) PAGE0_HTE;
1151 lp->mctbl = (char *) (lp->shmem_base + PAGE0_HTE);
1154 csr &= ~(CSR_PME | CSR_MCE);
1155 if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
1157 outb(csr, EWRK3_CSR);
1159 SetMulticastFilter(dev);
1161 outb(csr, EWRK3_CSR);
1166 ** Calculate the hash code and update the logical address filter
1167 ** from a list of ethernet multicast addresses.
1168 ** Little endian crc one liner from Matt Thomas, DEC.
1170 ** Note that when clearing the table, the broadcast bit must remain asserted
1171 ** to receive broadcast messages.
1173 static void SetMulticastFilter(struct net_device *dev)
1175 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
1176 struct dev_mc_list *dmi = dev->mc_list;
1177 u_long iobase = dev->base_addr;
1179 char *addrs, bit, byte;
1180 short *p = (short *) lp->mctbl;
1184 spin_lock_irq(&lp->hw_lock);
1186 if (lp->shmem_length == IO_ONLY) {
1187 outb(0, EWRK3_IOPR);
1188 outw(EEPROM_OFFSET(lp->mctbl), EWRK3_PIR1);
1193 if (dev->flags & IFF_ALLMULTI) {
1194 for (i = 0; i < (HASH_TABLE_LEN >> 3); i++) {
1195 if (lp->shmem_length == IO_ONLY) {
1196 outb(0xff, EWRK3_DATA);
1197 } else { /* memset didn't work here */
1198 isa_writew(0xffff, (int) p);
1204 /* Clear table except for broadcast bit */
1205 if (lp->shmem_length == IO_ONLY) {
1206 for (i = 0; i < (HASH_TABLE_LEN >> 4) - 1; i++) {
1207 outb(0x00, EWRK3_DATA);
1209 outb(0x80, EWRK3_DATA);
1210 i++; /* insert the broadcast bit */
1211 for (; i < (HASH_TABLE_LEN >> 3); i++) {
1212 outb(0x00, EWRK3_DATA);
1215 isa_memset_io((int) lp->mctbl, 0, (HASH_TABLE_LEN >> 3));
1216 isa_writeb(0x80, (int) (lp->mctbl + (HASH_TABLE_LEN >> 4) - 1));
1220 for (i = 0; i < dev->mc_count; i++) { /* for each address in the list */
1221 addrs = dmi->dmi_addr;
1223 if ((*addrs & 0x01) == 1) { /* multicast address? */
1224 crc = ether_crc_le(ETH_ALEN, addrs);
1225 hashcode = crc & ((1 << 9) - 1); /* hashcode is 9 LSb of CRC */
1227 byte = hashcode >> 3; /* bit[3-8] -> byte in filter */
1228 bit = 1 << (hashcode & 0x07); /* bit[0-2] -> bit in byte */
1230 if (lp->shmem_length == IO_ONLY) {
1233 outw((short) ((long) lp->mctbl) + byte, EWRK3_PIR1);
1234 tmp = inb(EWRK3_DATA);
1236 outw((short) ((long) lp->mctbl) + byte, EWRK3_PIR1);
1237 outb(tmp, EWRK3_DATA);
1239 isa_writeb(isa_readb((int)(lp->mctbl + byte)) | bit, (int)(lp->mctbl + byte));
1245 spin_unlock_irq(&lp->hw_lock);
1249 ** ISA bus I/O device probe
1251 static int __init isa_probe(struct net_device *dev, u_long ioaddr)
1253 int i = num_ewrks3s, maxSlots;
1258 if (ioaddr >= 0x400)
1261 if (ioaddr == 0) { /* Autoprobing */
1262 iobase = EWRK3_IO_BASE; /* Get the first slot address */
1264 } else { /* Probe a specific location */
1269 for (; (i < maxSlots) && (dev != NULL);
1270 iobase += EWRK3_IOP_INC, i++)
1272 if (request_region(iobase, EWRK3_TOTAL_SIZE, dev->name)) {
1273 if (DevicePresent(iobase) == 0) {
1275 ret = ewrk3_hw_init(dev, iobase);
1280 release_region(iobase, EWRK3_TOTAL_SIZE);
1289 ** EISA bus I/O device probe. Probe from slot 1 since slot 0 is usually
1292 static int __init eisa_probe(struct net_device *dev, u_long ioaddr)
1298 if (ioaddr < 0x1000)
1301 if (ioaddr == 0) { /* Autoprobing */
1302 iobase = EISA_SLOT_INC; /* Get the first slot address */
1304 maxSlots = MAX_EISA_SLOTS;
1305 } else { /* Probe a specific location */
1311 for (i = 1; (i < maxSlots) && (dev != NULL); i++, iobase += EISA_SLOT_INC) {
1312 if (EISA_signature(name, EISA_ID) == 0) {
1313 if (request_region(iobase, EWRK3_TOTAL_SIZE, dev->name) &&
1314 DevicePresent(iobase) == 0) {
1316 ret = ewrk3_hw_init(dev, iobase);
1321 release_region(iobase, EWRK3_TOTAL_SIZE);
1331 ** Read the EWRK3 EEPROM using this routine
1333 static int Read_EEPROM(u_long iobase, u_char eaddr)
1337 outb((eaddr & 0x3f), EWRK3_PIR1); /* set up 6 bits of address info */
1338 outb(EEPROM_RD, EWRK3_IOPR); /* issue read command */
1339 for (i = 0; i < 5000; i++)
1340 inb(EWRK3_CSR); /* wait 1msec */
1342 return inw(EWRK3_EPROM1); /* 16 bits data return */
1346 ** Write the EWRK3 EEPROM using this routine
1348 static int Write_EEPROM(short data, u_long iobase, u_char eaddr)
1352 outb(EEPROM_WR_EN, EWRK3_IOPR); /* issue write enable command */
1353 for (i = 0; i < 5000; i++)
1354 inb(EWRK3_CSR); /* wait 1msec */
1355 outw(data, EWRK3_EPROM1); /* write data to register */
1356 outb((eaddr & 0x3f), EWRK3_PIR1); /* set up 6 bits of address info */
1357 outb(EEPROM_WR, EWRK3_IOPR); /* issue write command */
1358 for (i = 0; i < 75000; i++)
1359 inb(EWRK3_CSR); /* wait 15msec */
1360 outb(EEPROM_WR_DIS, EWRK3_IOPR); /* issue write disable command */
1361 for (i = 0; i < 5000; i++)
1362 inb(EWRK3_CSR); /* wait 1msec */
1368 ** Look for a particular board name in the on-board EEPROM.
1370 static void __init EthwrkSignature(char *name, char *eeprom_image)
1373 char *signatures[] = EWRK3_SIGNATURE;
1375 for (i=0; *signatures[i] != '\0'; i++)
1376 if( !strncmp(eeprom_image+EEPROM_PNAME7, signatures[i], strlen(signatures[i])) )
1379 if (*signatures[i] != '\0') {
1380 memcpy(name, eeprom_image+EEPROM_PNAME7, EWRK3_STRLEN);
1381 name[EWRK3_STRLEN] = '\0';
1389 ** Look for a special sequence in the Ethernet station address PROM that
1390 ** is common across all EWRK3 products.
1392 ** Search the Ethernet address ROM for the signature. Since the ROM address
1393 ** counter can start at an arbitrary point, the search must include the entire
1394 ** probe sequence length plus the (length_of_the_signature - 1).
1395 ** Stop the search IMMEDIATELY after the signature is found so that the
1396 ** PROM address counter is correctly positioned at the start of the
1397 ** ethernet address for later read out.
1400 static int __init DevicePresent(u_long iobase)
1407 char Sig[sizeof(u32) << 1];
1412 int i, j, status = 0;
1414 dev.llsig.a = ETH_PROM_SIG;
1415 dev.llsig.b = ETH_PROM_SIG;
1416 sigLength = sizeof(u32) << 1;
1418 for (i = 0, j = 0; j < sigLength && i < PROBE_LENGTH + sigLength - 1; i++) {
1419 data = inb(EWRK3_APROM);
1420 if (dev.Sig[j] == data) { /* track signature */
1422 } else { /* lost signature; begin search again */
1423 if (data == dev.Sig[0]) {
1431 if (j != sigLength) {
1432 status = -ENODEV; /* search failed */
1437 static u_char __init get_hw_addr(struct net_device *dev, u_char * eeprom_image, char chipType)
1441 u_char crc, lfsr, sd, status = 0;
1442 u_long iobase = dev->base_addr;
1445 if (chipType == LeMAC2) {
1446 for (crc = 0x6a, j = 0; j < ETH_ALEN; j++) {
1447 sd = dev->dev_addr[j] = eeprom_image[EEPROM_PADDR0 + j];
1448 outb(dev->dev_addr[j], EWRK3_PAR0 + j);
1449 for (k = 0; k < 8; k++, sd >>= 1) {
1450 lfsr = ((((crc & 0x02) >> 1) ^ (crc & 0x01)) ^ (sd & 0x01)) << 7;
1451 crc = (crc >> 1) + lfsr;
1454 if (crc != eeprom_image[EEPROM_PA_CRC])
1457 for (i = 0, k = 0; i < ETH_ALEN;) {
1462 k += (u_char) (tmp = inb(EWRK3_APROM));
1463 dev->dev_addr[i] = (u_char) tmp;
1464 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
1466 k += (u_short) ((tmp = inb(EWRK3_APROM)) << 8);
1467 dev->dev_addr[i] = (u_char) tmp;
1468 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
1476 chksum = inb(EWRK3_APROM);
1477 chksum |= (inb(EWRK3_APROM) << 8);
1486 ** Look for a particular board name in the EISA configuration space
1488 static int __init EISA_signature(char *name, s32 eisa_id)
1491 char *signatures[] = EWRK3_SIGNATURE;
1492 char ManCode[EWRK3_STRLEN];
1500 for (i = 0; i < 4; i++) {
1501 Eisa.Id[i] = inb(eisa_id + i);
1504 ManCode[0] = (((Eisa.Id[0] >> 2) & 0x1f) + 0x40);
1505 ManCode[1] = (((Eisa.Id[1] & 0xe0) >> 5) + ((Eisa.Id[0] & 0x03) << 3) + 0x40);
1506 ManCode[2] = (((Eisa.Id[2] >> 4) & 0x0f) + 0x30);
1507 ManCode[3] = ((Eisa.Id[2] & 0x0f) + 0x30);
1508 ManCode[4] = (((Eisa.Id[3] >> 4) & 0x0f) + 0x30);
1511 for (i = 0; (*signatures[i] != '\0') && (*name == '\0'); i++) {
1512 if (strstr(ManCode, signatures[i]) != NULL) {
1513 strcpy(name, ManCode);
1518 return status; /* return the device name string */
1521 static int ewrk3_ethtool_ioctl(struct net_device *dev, void *useraddr)
1523 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
1524 u_long iobase = dev->base_addr;
1527 if (get_user(ethcmd, (u32 *)useraddr))
1532 /* Get driver info */
1533 case ETHTOOL_GDRVINFO: {
1534 struct ethtool_drvinfo info = { ETHTOOL_GDRVINFO };
1535 int fwrev = Read_EEPROM(dev->base_addr, EEPROM_REVLVL);
1537 strcpy(info.driver, DRV_NAME);
1538 strcpy(info.version, DRV_VERSION);
1539 sprintf(info.fw_version, "%d", fwrev);
1540 strcpy(info.bus_info, "N/A");
1541 info.eedump_len = EEPROM_MAX;
1542 if (copy_to_user(useraddr, &info, sizeof(info)))
1548 case ETHTOOL_GSET: {
1549 struct ethtool_cmd ecmd = { ETHTOOL_GSET };
1550 u_char cr = inb(EWRK3_CR);
1552 switch (lp->adapter_name[4]) {
1553 case '3': /* DE203 */
1554 ecmd.supported = SUPPORTED_BNC;
1555 ecmd.port = PORT_BNC;
1558 case '4': /* DE204 */
1559 ecmd.supported = SUPPORTED_TP;
1560 ecmd.port = PORT_TP;
1563 case '5': /* DE205 */
1564 ecmd.supported = SUPPORTED_TP | SUPPORTED_BNC | SUPPORTED_AUI;
1565 ecmd.autoneg = !(cr & CR_APD);
1567 ** Port is only valid if autoneg is disabled
1568 ** and even then we don't know if AUI is jumpered.
1571 ecmd.port = (cr & CR_PSEL) ? PORT_BNC : PORT_TP;
1575 ecmd.supported |= SUPPORTED_10baseT_Half;
1576 ecmd.speed = SPEED_10;
1577 ecmd.duplex = DUPLEX_HALF;
1579 if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
1585 case ETHTOOL_SSET: {
1586 struct ethtool_cmd ecmd;
1590 /* DE205 is the only card with anything to set */
1591 if (lp->adapter_name[4] != '5')
1594 if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
1597 /* Sanity-check parameters */
1598 if (ecmd.speed != SPEED_10)
1600 if (ecmd.port != PORT_TP && ecmd.port != PORT_BNC)
1601 return -EINVAL; /* AUI is not software-selectable */
1602 if (ecmd.transceiver != XCVR_INTERNAL)
1604 if (ecmd.duplex != DUPLEX_HALF)
1606 if (ecmd.phy_address != 0)
1609 spin_lock_irqsave(&lp->hw_lock, flags);
1612 /* If Autoneg is set, change to Auto Port mode */
1613 /* Otherwise, disable Auto Port and set port explicitly */
1618 if (ecmd.port == PORT_TP)
1619 cr &= ~CR_PSEL; /* Force TP */
1621 cr |= CR_PSEL; /* Force BNC */
1624 /* Commit the changes */
1627 spin_unlock_irqrestore(&lp->hw_lock, flags);
1628 if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
1633 /* Get link status */
1634 case ETHTOOL_GLINK: {
1635 struct ethtool_value edata = { ETHTOOL_GLINK };
1636 u_char cmr = inb(EWRK3_CMR);
1638 /* DE203 has BNC only and link status does not apply */
1639 if (lp->adapter_name[4] == '3')
1642 /* On DE204 this is always valid since TP is the only port. */
1643 /* On DE205 this reflects TP status even if BNC or AUI is selected. */
1644 edata.data = !(cmr & CMR_LINK);
1646 if (copy_to_user(useraddr, &edata, sizeof(edata)))
1651 /* Blink LED for identification */
1652 case ETHTOOL_PHYS_ID: {
1653 struct ethtool_value edata;
1658 if (copy_from_user(&edata, useraddr, sizeof(edata)))
1661 /* Toggle LED 4x per second */
1662 count = edata.data << 2;
1664 spin_lock_irqsave(&lp->hw_lock, flags);
1666 /* Bail if a PHYS_ID is already in progress */
1667 if (lp->led_mask == 0) {
1668 spin_unlock_irqrestore(&lp->hw_lock, flags);
1672 /* Prevent ISR from twiddling the LED */
1676 /* Toggle the LED */
1678 outb(cr ^ CR_LED, EWRK3_CR);
1680 /* Wait a little while */
1681 spin_unlock_irqrestore(&lp->hw_lock, flags);
1682 set_current_state(TASK_UNINTERRUPTIBLE);
1683 schedule_timeout(HZ>>2);
1684 spin_lock_irqsave(&lp->hw_lock, flags);
1686 /* Exit if we got a signal */
1687 if (signal_pending(current))
1691 lp->led_mask = CR_LED;
1693 outb(cr & ~CR_LED, EWRK3_CR);
1694 spin_unlock_irqrestore(&lp->hw_lock, flags);
1695 return signal_pending(current) ? -ERESTARTSYS : 0;
1704 ** Perform IOCTL call functions here. Some are privileged operations and the
1705 ** effective uid is checked in those cases.
1707 static int ewrk3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1709 struct ewrk3_private *lp = (struct ewrk3_private *) dev->priv;
1710 struct ewrk3_ioctl *ioc = (struct ewrk3_ioctl *) &rq->ifr_data;
1711 u_long iobase = dev->base_addr;
1712 int i, j, status = 0;
1714 unsigned long flags;
1716 u_char addr[HASH_TABLE_LEN * ETH_ALEN];
1717 u_short val[(HASH_TABLE_LEN * ETH_ALEN) >> 1];
1720 union ewrk3_addr *tmp;
1722 /* ethtool IOCTLs are handled elsewhere */
1723 if (cmd == SIOCETHTOOL)
1724 return ewrk3_ethtool_ioctl(dev, (void *)rq->ifr_data);
1726 /* Other than ethtool, all we handle are private IOCTLs */
1727 if (cmd != EWRK3IOCTL)
1730 tmp = kmalloc(sizeof(union ewrk3_addr), GFP_KERNEL);
1735 case EWRK3_GET_HWADDR: /* Get the hardware address */
1736 for (i = 0; i < ETH_ALEN; i++) {
1737 tmp->addr[i] = dev->dev_addr[i];
1739 ioc->len = ETH_ALEN;
1740 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1744 case EWRK3_SET_HWADDR: /* Set the hardware address */
1745 if (capable(CAP_NET_ADMIN)) {
1746 spin_lock_irqsave(&lp->hw_lock, flags);
1747 csr = inb(EWRK3_CSR);
1748 csr |= (CSR_TXD | CSR_RXD);
1749 outb(csr, EWRK3_CSR); /* Disable the TX and RX */
1750 spin_unlock_irqrestore(&lp->hw_lock, flags);
1752 if (copy_from_user(tmp->addr, ioc->data, ETH_ALEN)) {
1756 spin_lock_irqsave(&lp->hw_lock, flags);
1757 for (i = 0; i < ETH_ALEN; i++) {
1758 dev->dev_addr[i] = tmp->addr[i];
1759 outb(tmp->addr[i], EWRK3_PAR0 + i);
1762 csr = inb(EWRK3_CSR);
1763 csr &= ~(CSR_TXD | CSR_RXD); /* Enable the TX and RX */
1764 outb(csr, EWRK3_CSR);
1765 spin_unlock_irqrestore(&lp->hw_lock, flags);
1771 case EWRK3_SET_PROM: /* Set Promiscuous Mode */
1772 if (capable(CAP_NET_ADMIN)) {
1773 spin_lock_irqsave(&lp->hw_lock, flags);
1774 csr = inb(EWRK3_CSR);
1777 outb(csr, EWRK3_CSR);
1778 spin_unlock_irqrestore(&lp->hw_lock, flags);
1784 case EWRK3_CLR_PROM: /* Clear Promiscuous Mode */
1785 if (capable(CAP_NET_ADMIN)) {
1786 spin_lock_irqsave(&lp->hw_lock, flags);
1787 csr = inb(EWRK3_CSR);
1789 outb(csr, EWRK3_CSR);
1790 spin_unlock_irqrestore(&lp->hw_lock, flags);
1796 case EWRK3_GET_MCA: /* Get the multicast address table */
1797 spin_lock_irqsave(&lp->hw_lock, flags);
1798 if (lp->shmem_length == IO_ONLY) {
1799 outb(0, EWRK3_IOPR);
1800 outw(PAGE0_HTE, EWRK3_PIR1);
1801 for (i = 0; i < (HASH_TABLE_LEN >> 3); i++) {
1802 tmp->addr[i] = inb(EWRK3_DATA);
1806 isa_memcpy_fromio(tmp->addr, lp->shmem_base + PAGE0_HTE, (HASH_TABLE_LEN >> 3));
1808 spin_unlock_irqrestore(&lp->hw_lock, flags);
1810 ioc->len = (HASH_TABLE_LEN >> 3);
1811 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1815 case EWRK3_SET_MCA: /* Set a multicast address */
1816 if (capable(CAP_NET_ADMIN)) {
1817 if (ioc->len > 1024)
1822 if (copy_from_user(tmp->addr, ioc->data, ETH_ALEN * ioc->len)) {
1826 set_multicast_list(dev);
1832 case EWRK3_CLR_MCA: /* Clear all multicast addresses */
1833 if (capable(CAP_NET_ADMIN)) {
1834 set_multicast_list(dev);
1840 case EWRK3_MCA_EN: /* Enable multicast addressing */
1841 if (capable(CAP_NET_ADMIN)) {
1842 spin_lock_irqsave(&lp->hw_lock, flags);
1843 csr = inb(EWRK3_CSR);
1846 outb(csr, EWRK3_CSR);
1847 spin_unlock_irqrestore(&lp->hw_lock, flags);
1853 case EWRK3_GET_STATS: { /* Get the driver statistics */
1854 struct ewrk3_stats *tmp_stats =
1855 kmalloc(sizeof(lp->pktStats), GFP_KERNEL);
1861 spin_lock_irqsave(&lp->hw_lock, flags);
1862 memcpy(tmp_stats, &lp->pktStats, sizeof(lp->pktStats));
1863 spin_unlock_irqrestore(&lp->hw_lock, flags);
1865 ioc->len = sizeof(lp->pktStats);
1866 if (copy_to_user(ioc->data, tmp_stats, sizeof(lp->pktStats)))
1871 case EWRK3_CLR_STATS: /* Zero out the driver statistics */
1872 if (capable(CAP_NET_ADMIN)) {
1873 spin_lock_irqsave(&lp->hw_lock, flags);
1874 memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1875 spin_unlock_irqrestore(&lp->hw_lock,flags);
1881 case EWRK3_GET_CSR: /* Get the CSR Register contents */
1882 tmp->addr[0] = inb(EWRK3_CSR);
1884 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1887 case EWRK3_SET_CSR: /* Set the CSR Register contents */
1888 if (capable(CAP_NET_ADMIN)) {
1889 if (copy_from_user(tmp->addr, ioc->data, 1)) {
1893 outb(tmp->addr[0], EWRK3_CSR);
1899 case EWRK3_GET_EEPROM: /* Get the EEPROM contents */
1900 if (capable(CAP_NET_ADMIN)) {
1901 for (i = 0; i < (EEPROM_MAX >> 1); i++) {
1902 tmp->val[i] = (short) Read_EEPROM(iobase, i);
1905 tmp->addr[i++] = inb(EWRK3_CMR); /* Config/Management Reg. */
1906 for (j = 0; j < ETH_ALEN; j++) {
1907 tmp->addr[i++] = inb(EWRK3_PAR0 + j);
1909 ioc->len = EEPROM_MAX + 1 + ETH_ALEN;
1910 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1917 case EWRK3_SET_EEPROM: /* Set the EEPROM contents */
1918 if (capable(CAP_NET_ADMIN)) {
1919 if (copy_from_user(tmp->addr, ioc->data, EEPROM_MAX)) {
1923 for (i = 0; i < (EEPROM_MAX >> 1); i++) {
1924 Write_EEPROM(tmp->val[i], iobase, i);
1931 case EWRK3_GET_CMR: /* Get the CMR Register contents */
1932 tmp->addr[0] = inb(EWRK3_CMR);
1934 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1937 case EWRK3_SET_TX_CUT_THRU: /* Set TX cut through mode */
1938 if (capable(CAP_NET_ADMIN)) {
1945 case EWRK3_CLR_TX_CUT_THRU: /* Clear TX cut through mode */
1946 if (capable(CAP_NET_ADMIN)) {
1954 status = -EOPNOTSUPP;
1961 static struct net_device *ewrk3_devs[MAX_NUM_EWRK3S];
1963 static int io[MAX_NUM_EWRK3S+1] = { 0x300, 0, };
1965 /* '21' below should really be 'MAX_NUM_EWRK3S' */
1966 MODULE_PARM(io, "0-21i");
1967 MODULE_PARM(irq, "0-21i");
1968 MODULE_PARM_DESC(io, "EtherWORKS 3 I/O base address(es)");
1969 MODULE_PARM_DESC(irq, "EtherWORKS 3 IRQ number(s)");
1971 static __exit void ewrk3_exit_module(void)
1975 for( i=0; i<ndevs; i++ ) {
1976 unregister_netdev(ewrk3_devs[i]);
1977 release_region(ewrk3_devs[i]->base_addr, EWRK3_TOTAL_SIZE);
1978 free_netdev(ewrk3_devs[i]);
1979 ewrk3_devs[i] = NULL;
1983 static __init int ewrk3_init_module(void)
1987 while( io[i] && irq[i] ) {
1988 struct net_device *dev
1989 = alloc_etherdev(sizeof(struct ewrk3_private));
1994 if (ewrk3_probe1(dev, io[i], irq[i]) != 0) {
1999 ewrk3_devs[ndevs++] = dev;
2003 return ndevs ? 0 : -EIO;
2007 /* Hack for breakage in new module stuff */
2008 module_exit(ewrk3_exit_module);
2009 module_init(ewrk3_init_module);
2011 MODULE_LICENSE("GPL");
2017 * 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"
2019 * 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"