?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[TG3]: Set minimal hw interrupt mitigation.
[linux-2.6/verdex.git] / drivers / net / ewrk3.c
blobdcf969b20be90848035e21a0424c903e69c5d3b8
1 /* ewrk3.c: A DIGITAL EtherWORKS 3 ethernet driver for Linux.
2
3 Written 1994 by David C. Davies.
4
5 Copyright 1994 Digital Equipment Corporation.
6
7 This software may be used and distributed according to the terms of
8 the GNU General Public License, incorporated herein by reference.
9
10 This driver is written for the Digital Equipment Corporation series
11 of EtherWORKS ethernet cards:
12
13 DE203 Turbo (BNC)
14 DE204 Turbo (TP)
15 DE205 Turbo (TP BNC)
16
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.
20
21 The author may be reached at davies@maniac.ultranet.com.
22
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.
27
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.
32
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.
38
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:
43
44 FORCE_2K_MODE;
45
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.
49
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) ...
55
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
58 {5,10,11,15}.
59
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).
63
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:
67
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
70 temporary directory.
71 2) edit the source code near line 1898 to reflect the I/O address and
72 IRQ you're using.
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.
77 5) insmod ewrk3.o
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).
82 7) enjoy!
83
84 Note that autoprobing is not allowed in loadable modules - the system is
85 already up and running and you're messing with interrupts.
86
87 To unload a module, turn off the associated interface
88 'ifconfig eth?? down' then 'rmmod ewrk3'.
89
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%.
93
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.
100
101 TO DO:
102 ------
103
104
105 Revision History
106 ----------------
107
108 Version Date Description
109
110 0.1 26-aug-94 Initial writing. ALPHA code release.
111 0.11 31-aug-94 Fixed: 2k mode memory base calc.,
112 LeMAC version 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>
142
143 =========================================================================
144 */
145
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>
165
166 #include <asm/io.h>
167 #include <asm/dma.h>
168 #include <asm/uaccess.h>
169
170 #include "ewrk3.h"
171
172 #define DRV_NAME "ewrk3"
173 #define DRV_VERSION "0.48"
174
175 static char version[] __initdata =
176 DRV_NAME ":v" DRV_VERSION " 2002/10/18 davies@maniac.ultranet.com\n";
177
178 #ifdef EWRK3_DEBUG
179 static int ewrk3_debug = EWRK3_DEBUG;
180 #else
181 static int ewrk3_debug = 1;
182 #endif
183
184 #define EWRK3_NDA 0xffe0 /* No Device Address */
185
186 #define PROBE_LENGTH 32
187 #define ETH_PROM_SIG 0xAA5500FFUL
188
189 #ifndef EWRK3_SIGNATURE
190 #define EWRK3_SIGNATURE {"DE203","DE204","DE205",""}
191 #define EWRK3_STRLEN 8
192 #endif
193
194 #ifndef EWRK3_RAM_BASE_ADDRESSES
195 #define EWRK3_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0x00000}
196 #endif
197
198 /*
199 ** Sets up the I/O area for the autoprobe.
200 */
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 */
204
205 #ifndef MAX_NUM_EWRK3S
206 #define MAX_NUM_EWRK3S 21
207 #endif
208
209 #ifndef EWRK3_EISA_IO_PORTS
210 #define EWRK3_EISA_IO_PORTS 0x0c00 /* I/O port base address, slot 0 */
211 #endif
212
213 #ifndef MAX_EISA_SLOTS
214 #define MAX_EISA_SLOTS 16
215 #define EISA_SLOT_INC 0x1000
216 #endif
217
218 #define QUEUE_PKT_TIMEOUT (1*HZ) /* Jiffies */
219
220 /*
221 ** EtherWORKS 3 shared memory window sizes
222 */
223 #define IO_ONLY 0x00
224 #define SHMEM_2K 0x800
225 #define SHMEM_32K 0x8000
226 #define SHMEM_64K 0x10000
227
228 /*
229 ** EtherWORKS 3 IRQ ENABLE/DISABLE
230 */
231 #define ENABLE_IRQs { \
232 icr |= lp->irq_mask;\
233 outb(icr, EWRK3_ICR); /* Enable the IRQs */\
234 }
235
236 #define DISABLE_IRQs { \
237 icr = inb(EWRK3_ICR);\
238 icr &= ~lp->irq_mask;\
239 outb(icr, EWRK3_ICR); /* Disable the IRQs */\
240 }
241
242 /*
243 ** EtherWORKS 3 START/STOP
244 */
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 */\
249 }
250
251 #define STOP_EWRK3 { \
252 csr = (CSR_TXD|CSR_RXD);\
253 outb(csr, EWRK3_CSR); /* Disable the TX and/or RX */\
254 }
255
256 /*
257 ** The EtherWORKS 3 private structure
258 */
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 */
262
263 struct ewrk3_stats {
264 u32 bins[EWRK3_PKT_STAT_SZ];
265 u32 unicast;
266 u32 multicast;
267 u32 broadcast;
268 u32 excessive_collisions;
269 u32 tx_underruns;
270 u32 excessive_underruns;
271 };
272
273 struct ewrk3_private {
274 char adapter_name[80]; /* Name exported to /proc/ioports */
275 u_long shmem_base; /* Shared memory start address */
276 void __iomem *shmem;
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 void __iomem *mctbl; /* Pointer to the multicast table */
286 u_char led_mask; /* Used to reserve LED access for ethtool */
287 spinlock_t hw_lock;
288 };
289
290 /*
291 ** Force the EtherWORKS 3 card to be in 2kB MODE
292 */
293 #define FORCE_2K_MODE { \
294 shmem_length = SHMEM_2K;\
295 outb(((mem_start - 0x80000) >> 11), EWRK3_MBR);\
296 }
297
298 /*
299 ** Public Functions
300 */
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);
308 static struct ethtool_ops ethtool_ops_203;
309 static struct ethtool_ops ethtool_ops;
310
311 /*
312 ** Private functions
313 */
314 static int ewrk3_hw_init(struct net_device *dev, u_long iobase);
315 static void ewrk3_init(struct net_device *dev);
316 static int ewrk3_rx(struct net_device *dev);
317 static int ewrk3_tx(struct net_device *dev);
318 static void ewrk3_timeout(struct net_device *dev);
319
320 static void EthwrkSignature(char *name, char *eeprom_image);
321 static int DevicePresent(u_long iobase);
322 static void SetMulticastFilter(struct net_device *dev);
323 static int EISA_signature(char *name, s32 eisa_id);
324
325 static int Read_EEPROM(u_long iobase, u_char eaddr);
326 static int Write_EEPROM(short data, u_long iobase, u_char eaddr);
327 static u_char get_hw_addr(struct net_device *dev, u_char * eeprom_image, char chipType);
328
329 static int ewrk3_probe1(struct net_device *dev, u_long iobase, int irq);
330 static int isa_probe(struct net_device *dev, u_long iobase);
331 static int eisa_probe(struct net_device *dev, u_long iobase);
332
333 static u_char irq[MAX_NUM_EWRK3S+1] = {5, 0, 10, 3, 11, 9, 15, 12};
334
335 static char name[EWRK3_STRLEN + 1];
336 static int num_ewrks3s;
337
338 /*
339 ** Miscellaneous defines...
340 */
341 #define INIT_EWRK3 {\
342 outb(EEPROM_INIT, EWRK3_IOPR);\
343 mdelay(1);\
344 }
345
346 #ifndef MODULE
347 struct net_device * __init ewrk3_probe(int unit)
348 {
349 struct net_device *dev = alloc_etherdev(sizeof(struct ewrk3_private));
350 int err;
351
352 if (!dev)
353 return ERR_PTR(-ENOMEM);
354
355 if (unit >= 0) {
356 sprintf(dev->name, "eth%d", unit);
357 netdev_boot_setup_check(dev);
358 }
359 SET_MODULE_OWNER(dev);
360
361 err = ewrk3_probe1(dev, dev->base_addr, dev->irq);
362 if (err)
363 goto out;
364 return dev;
365 out:
366 free_netdev(dev);
367 return ERR_PTR(err);
368
369 }
370 #endif
371
372 static int __init ewrk3_probe1(struct net_device *dev, u_long iobase, int irq)
373 {
374 int err;
375
376 dev->base_addr = iobase;
377 dev->irq = irq;
378
379 /* Address PROM pattern */
380 err = isa_probe(dev, iobase);
381 if (err != 0)
382 err = eisa_probe(dev, iobase);
383
384 if (err)
385 return err;
386
387 err = register_netdev(dev);
388 if (err)
389 release_region(dev->base_addr, EWRK3_TOTAL_SIZE);
390
391 return err;
392 }
393
394 static int __init
395 ewrk3_hw_init(struct net_device *dev, u_long iobase)
396 {
397 struct ewrk3_private *lp;
398 int i, status = 0;
399 u_long mem_start, shmem_length;
400 u_char cr, cmr, icr, nicsr, lemac, hard_strapped = 0;
401 u_char eeprom_image[EEPROM_MAX], chksum, eisa_cr = 0;
402
403 /*
404 ** Stop the EWRK3. Enable the DBR ROM. Disable interrupts and remote boot.
405 ** This also disables the EISA_ENABLE bit in the EISA Control Register.
406 */
407 if (iobase > 0x400)
408 eisa_cr = inb(EISA_CR);
409 INIT_EWRK3;
410
411 nicsr = inb(EWRK3_CSR);
412
413 icr = inb(EWRK3_ICR);
414 icr &= 0x70;
415 outb(icr, EWRK3_ICR); /* Disable all the IRQs */
416
417 if (nicsr == (CSR_TXD | CSR_RXD))
418 return -ENXIO;
419
420
421 /* Check that the EEPROM is alive and well and not living on Pluto... */
422 for (chksum = 0, i = 0; i < EEPROM_MAX; i += 2) {
423 union {
424 short val;
425 char c[2];
426 } tmp;
427
428 tmp.val = (short) Read_EEPROM(iobase, (i >> 1));
429 eeprom_image[i] = tmp.c[0];
430 eeprom_image[i + 1] = tmp.c[1];
431 chksum += eeprom_image[i] + eeprom_image[i + 1];
432 }
433
434 if (chksum != 0) { /* Bad EEPROM Data! */
435 printk("%s: Device has a bad on-board EEPROM.\n", dev->name);
436 return -ENXIO;
437 }
438
439 EthwrkSignature(name, eeprom_image);
440 if (*name == '\0')
441 return -ENXIO;
442
443 dev->base_addr = iobase;
444
445 if (iobase > 0x400) {
446 outb(eisa_cr, EISA_CR); /* Rewrite the EISA CR */
447 }
448 lemac = eeprom_image[EEPROM_CHIPVER];
449 cmr = inb(EWRK3_CMR);
450
451 if (((lemac == LeMAC) && ((cmr & CMR_NO_EEPROM) != CMR_NO_EEPROM)) ||
452 ((lemac == LeMAC2) && !(cmr & CMR_HS))) {
453 printk("%s: %s at %#4lx", dev->name, name, iobase);
454 hard_strapped = 1;
455 } else if ((iobase & 0x0fff) == EWRK3_EISA_IO_PORTS) {
456 /* EISA slot address */
457 printk("%s: %s at %#4lx (EISA slot %ld)",
458 dev->name, name, iobase, ((iobase >> 12) & 0x0f));
459 } else { /* ISA port address */
460 printk("%s: %s at %#4lx", dev->name, name, iobase);
461 }
462
463 printk(", h/w address ");
464 if (lemac != LeMAC2)
465 DevicePresent(iobase); /* need after EWRK3_INIT */
466 status = get_hw_addr(dev, eeprom_image, lemac);
467 for (i = 0; i < ETH_ALEN - 1; i++) { /* get the ethernet addr. */
468 printk("%2.2x:", dev->dev_addr[i]);
469 }
470 printk("%2.2x,\n", dev->dev_addr[i]);
471
472 if (status) {
473 printk(" which has an EEPROM CRC error.\n");
474 return -ENXIO;
475 }
476
477 if (lemac == LeMAC2) { /* Special LeMAC2 CMR things */
478 cmr &= ~(CMR_RA | CMR_WB | CMR_LINK | CMR_POLARITY | CMR_0WS);
479 if (eeprom_image[EEPROM_MISC0] & READ_AHEAD)
480 cmr |= CMR_RA;
481 if (eeprom_image[EEPROM_MISC0] & WRITE_BEHIND)
482 cmr |= CMR_WB;
483 if (eeprom_image[EEPROM_NETMAN0] & NETMAN_POL)
484 cmr |= CMR_POLARITY;
485 if (eeprom_image[EEPROM_NETMAN0] & NETMAN_LINK)
486 cmr |= CMR_LINK;
487 if (eeprom_image[EEPROM_MISC0] & _0WS_ENA)
488 cmr |= CMR_0WS;
489 }
490 if (eeprom_image[EEPROM_SETUP] & SETUP_DRAM)
491 cmr |= CMR_DRAM;
492 outb(cmr, EWRK3_CMR);
493
494 cr = inb(EWRK3_CR); /* Set up the Control Register */
495 cr |= eeprom_image[EEPROM_SETUP] & SETUP_APD;
496 if (cr & SETUP_APD)
497 cr |= eeprom_image[EEPROM_SETUP] & SETUP_PS;
498 cr |= eeprom_image[EEPROM_MISC0] & FAST_BUS;
499 cr |= eeprom_image[EEPROM_MISC0] & ENA_16;
500 outb(cr, EWRK3_CR);
501
502 /*
503 ** Determine the base address and window length for the EWRK3
504 ** RAM from the memory base register.
505 */
506 mem_start = inb(EWRK3_MBR);
507 shmem_length = 0;
508 if (mem_start != 0) {
509 if ((mem_start >= 0x0a) && (mem_start <= 0x0f)) {
510 mem_start *= SHMEM_64K;
511 shmem_length = SHMEM_64K;
512 } else if ((mem_start >= 0x14) && (mem_start <= 0x1f)) {
513 mem_start *= SHMEM_32K;
514 shmem_length = SHMEM_32K;
515 } else if ((mem_start >= 0x40) && (mem_start <= 0xff)) {
516 mem_start = mem_start * SHMEM_2K + 0x80000;
517 shmem_length = SHMEM_2K;
518 } else {
519 return -ENXIO;
520 }
521 }
522 /*
523 ** See the top of this source code for comments about
524 ** uncommenting this line.
525 */
526 /* FORCE_2K_MODE; */
527
528 if (hard_strapped) {
529 printk(" is hard strapped.\n");
530 } else if (mem_start) {
531 printk(" has a %dk RAM window", (int) (shmem_length >> 10));
532 printk(" at 0x%.5lx", mem_start);
533 } else {
534 printk(" is in I/O only mode");
535 }
536
537 lp = netdev_priv(dev);
538 lp->shmem_base = mem_start;
539 lp->shmem = ioremap(mem_start, shmem_length);
540 if (!lp->shmem)
541 return -ENOMEM;
542 lp->shmem_length = shmem_length;
543 lp->lemac = lemac;
544 lp->hard_strapped = hard_strapped;
545 lp->led_mask = CR_LED;
546 spin_lock_init(&lp->hw_lock);
547
548 lp->mPage = 64;
549 if (cmr & CMR_DRAM)
550 lp->mPage <<= 1; /* 2 DRAMS on module */
551
552 sprintf(lp->adapter_name, "%s (%s)", name, dev->name);
553
554 lp->irq_mask = ICR_TNEM | ICR_TXDM | ICR_RNEM | ICR_RXDM;
555
556 if (!hard_strapped) {
557 /*
558 ** Enable EWRK3 board interrupts for autoprobing
559 */
560 icr |= ICR_IE; /* Enable interrupts */
561 outb(icr, EWRK3_ICR);
562
563 /* The DMA channel may be passed in on this parameter. */
564 dev->dma = 0;
565
566 /* To auto-IRQ we enable the initialization-done and DMA err,
567 interrupts. For now we will always get a DMA error. */
568 if (dev->irq < 2) {
569 #ifndef MODULE
570 u_char irqnum;
571 unsigned long irq_mask;
572
573
574 irq_mask = probe_irq_on();
575
576 /*
577 ** Trigger a TNE interrupt.
578 */
579 icr |= ICR_TNEM;
580 outb(1, EWRK3_TDQ); /* Write to the TX done queue */
581 outb(icr, EWRK3_ICR); /* Unmask the TXD interrupt */
582
583 irqnum = irq[((icr & IRQ_SEL) >> 4)];
584
585 mdelay(20);
586 dev->irq = probe_irq_off(irq_mask);
587 if ((dev->irq) && (irqnum == dev->irq)) {
588 printk(" and uses IRQ%d.\n", dev->irq);
589 } else {
590 if (!dev->irq) {
591 printk(" and failed to detect IRQ line.\n");
592 } else if ((irqnum == 1) && (lemac == LeMAC2)) {
593 printk(" and an illegal IRQ line detected.\n");
594 } else {
595 printk(", but incorrect IRQ line detected.\n");
596 }
597 iounmap(lp->shmem);
598 return -ENXIO;
599 }
600
601 DISABLE_IRQs; /* Mask all interrupts */
602
603 #endif /* MODULE */
604 } else {
605 printk(" and requires IRQ%d.\n", dev->irq);
606 }
607 }
608
609 if (ewrk3_debug > 1) {
610 printk(version);
611 }
612 /* The EWRK3-specific entries in the device structure. */
613 dev->open = ewrk3_open;
614 dev->hard_start_xmit = ewrk3_queue_pkt;
615 dev->stop = ewrk3_close;
616 dev->get_stats = ewrk3_get_stats;
617 dev->set_multicast_list = set_multicast_list;
618 dev->do_ioctl = ewrk3_ioctl;
619 if (lp->adapter_name[4] == '3')
620 SET_ETHTOOL_OPS(dev, &ethtool_ops_203);
621 else
622 SET_ETHTOOL_OPS(dev, &ethtool_ops);
623 dev->tx_timeout = ewrk3_timeout;
624 dev->watchdog_timeo = QUEUE_PKT_TIMEOUT;
625
626 dev->mem_start = 0;
627
628 return 0;
629 }
630 \f
631
632 static int ewrk3_open(struct net_device *dev)
633 {
634 struct ewrk3_private *lp = netdev_priv(dev);
635 u_long iobase = dev->base_addr;
636 int i, status = 0;
637 u_char icr, csr;
638
639 /*
640 ** Stop the TX and RX...
641 */
642 STOP_EWRK3;
643
644 if (!lp->hard_strapped) {
645 if (request_irq(dev->irq, (void *) ewrk3_interrupt, 0, "ewrk3", dev)) {
646 printk("ewrk3_open(): Requested IRQ%d is busy\n", dev->irq);
647 status = -EAGAIN;
648 } else {
649
650 /*
651 ** Re-initialize the EWRK3...
652 */
653 ewrk3_init(dev);
654
655 if (ewrk3_debug > 1) {
656 printk("%s: ewrk3 open with irq %d\n", dev->name, dev->irq);
657 printk(" physical address: ");
658 for (i = 0; i < 5; i++) {
659 printk("%2.2x:", (u_char) dev->dev_addr[i]);
660 }
661 printk("%2.2x\n", (u_char) dev->dev_addr[i]);
662 if (lp->shmem_length == 0) {
663 printk(" no shared memory, I/O only mode\n");
664 } else {
665 printk(" start of shared memory: 0x%08lx\n", lp->shmem_base);
666 printk(" window length: 0x%04lx\n", lp->shmem_length);
667 }
668 printk(" # of DRAMS: %d\n", ((inb(EWRK3_CMR) & 0x02) ? 2 : 1));
669 printk(" csr: 0x%02x\n", inb(EWRK3_CSR));
670 printk(" cr: 0x%02x\n", inb(EWRK3_CR));
671 printk(" icr: 0x%02x\n", inb(EWRK3_ICR));
672 printk(" cmr: 0x%02x\n", inb(EWRK3_CMR));
673 printk(" fmqc: 0x%02x\n", inb(EWRK3_FMQC));
674 }
675 netif_start_queue(dev);
676 /*
677 ** Unmask EWRK3 board interrupts
678 */
679 icr = inb(EWRK3_ICR);
680 ENABLE_IRQs;
681
682 }
683 } else {
684 printk(KERN_ERR "%s: ewrk3 available for hard strapped set up only.\n", dev->name);
685 printk(KERN_ERR " Run the 'ewrk3setup' utility or remove the hard straps.\n");
686 return -EINVAL;
687 }
688
689 return status;
690 }
691
692 /*
693 ** Initialize the EtherWORKS 3 operating conditions
694 */
695 static void ewrk3_init(struct net_device *dev)
696 {
697 struct ewrk3_private *lp = netdev_priv(dev);
698 u_char csr, page;
699 u_long iobase = dev->base_addr;
700 int i;
701
702 /*
703 ** Enable any multicasts
704 */
705 set_multicast_list(dev);
706
707 /*
708 ** Set hardware MAC address. Address is initialized from the EEPROM
709 ** during startup but may have since been changed by the user.
710 */
711 for (i=0; i<ETH_ALEN; i++)
712 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
713
714 /*
715 ** Clean out any remaining entries in all the queues here
716 */
717 while (inb(EWRK3_TQ));
718 while (inb(EWRK3_TDQ));
719 while (inb(EWRK3_RQ));
720 while (inb(EWRK3_FMQ));
721
722 /*
723 ** Write a clean free memory queue
724 */
725 for (page = 1; page < lp->mPage; page++) { /* Write the free page numbers */
726 outb(page, EWRK3_FMQ); /* to the Free Memory Queue */
727 }
728
729 START_EWRK3; /* Enable the TX and/or RX */
730 }
731
732 /*
733 * Transmit timeout
734 */
735
736 static void ewrk3_timeout(struct net_device *dev)
737 {
738 struct ewrk3_private *lp = netdev_priv(dev);
739 u_char icr, csr;
740 u_long iobase = dev->base_addr;
741
742 if (!lp->hard_strapped)
743 {
744 printk(KERN_WARNING"%s: transmit timed/locked out, status %04x, resetting.\n",
745 dev->name, inb(EWRK3_CSR));
746
747 /*
748 ** Mask all board interrupts
749 */
750 DISABLE_IRQs;
751
752 /*
753 ** Stop the TX and RX...
754 */
755 STOP_EWRK3;
756
757 ewrk3_init(dev);
758
759 /*
760 ** Unmask EWRK3 board interrupts
761 */
762 ENABLE_IRQs;
763
764 dev->trans_start = jiffies;
765 netif_wake_queue(dev);
766 }
767 }
768
769 /*
770 ** Writes a socket buffer to the free page queue
771 */
772 static int ewrk3_queue_pkt (struct sk_buff *skb, struct net_device *dev)
773 {
774 struct ewrk3_private *lp = netdev_priv(dev);
775 u_long iobase = dev->base_addr;
776 void __iomem *buf = NULL;
777 u_char icr;
778 u_char page;
779
780 spin_lock_irq (&lp->hw_lock);
781 DISABLE_IRQs;
782
783 /* if no resources available, exit, request packet be queued */
784 if (inb (EWRK3_FMQC) == 0) {
785 printk (KERN_WARNING "%s: ewrk3_queue_pkt(): No free resources...\n",
786 dev->name);
787 printk (KERN_WARNING "%s: ewrk3_queue_pkt(): CSR: %02x ICR: %02x FMQC: %02x\n",
788 dev->name, inb (EWRK3_CSR), inb (EWRK3_ICR),
789 inb (EWRK3_FMQC));
790 goto err_out;
791 }
792
793 /*
794 ** Get a free page from the FMQ
795 */
796 if ((page = inb (EWRK3_FMQ)) >= lp->mPage) {
797 printk ("ewrk3_queue_pkt(): Invalid free memory page (%d).\n",
798 (u_char) page);
799 goto err_out;
800 }
801
802
803 /*
804 ** Set up shared memory window and pointer into the window
805 */
806 if (lp->shmem_length == IO_ONLY) {
807 outb (page, EWRK3_IOPR);
808 } else if (lp->shmem_length == SHMEM_2K) {
809 buf = lp->shmem;
810 outb (page, EWRK3_MPR);
811 } else if (lp->shmem_length == SHMEM_32K) {
812 buf = (((short) page << 11) & 0x7800) + lp->shmem;
813 outb ((page >> 4), EWRK3_MPR);
814 } else if (lp->shmem_length == SHMEM_64K) {
815 buf = (((short) page << 11) & 0xf800) + lp->shmem;
816 outb ((page >> 5), EWRK3_MPR);
817 } else {
818 printk (KERN_ERR "%s: Oops - your private data area is hosed!\n",
819 dev->name);
820 BUG ();
821 }
822
823 /*
824 ** Set up the buffer control structures and copy the data from
825 ** the socket buffer to the shared memory .
826 */
827 if (lp->shmem_length == IO_ONLY) {
828 int i;
829 u_char *p = skb->data;
830 outb ((char) (TCR_QMODE | TCR_PAD | TCR_IFC), EWRK3_DATA);
831 outb ((char) (skb->len & 0xff), EWRK3_DATA);
832 outb ((char) ((skb->len >> 8) & 0xff), EWRK3_DATA);
833 outb ((char) 0x04, EWRK3_DATA);
834 for (i = 0; i < skb->len; i++) {
835 outb (*p++, EWRK3_DATA);
836 }
837 outb (page, EWRK3_TQ); /* Start sending pkt */
838 } else {
839 writeb ((char) (TCR_QMODE | TCR_PAD | TCR_IFC), buf); /* ctrl byte */
840 buf += 1;
841 writeb ((char) (skb->len & 0xff), buf); /* length (16 bit xfer) */
842 buf += 1;
843 if (lp->txc) {
844 writeb(((skb->len >> 8) & 0xff) | XCT, buf);
845 buf += 1;
846 writeb (0x04, buf); /* index byte */
847 buf += 1;
848 writeb (0x00, (buf + skb->len)); /* Write the XCT flag */
849 memcpy_toio (buf, skb->data, PRELOAD); /* Write PRELOAD bytes */
850 outb (page, EWRK3_TQ); /* Start sending pkt */
851 memcpy_toio (buf + PRELOAD,
852 skb->data + PRELOAD,
853 skb->len - PRELOAD);
854 writeb (0xff, (buf + skb->len)); /* Write the XCT flag */
855 } else {
856 writeb ((skb->len >> 8) & 0xff, buf);
857 buf += 1;
858 writeb (0x04, buf); /* index byte */
859 buf += 1;
860 memcpy_toio (buf, skb->data, skb->len); /* Write data bytes */
861 outb (page, EWRK3_TQ); /* Start sending pkt */
862 }
863 }
864
865 ENABLE_IRQs;
866 spin_unlock_irq (&lp->hw_lock);
867
868 lp->stats.tx_bytes += skb->len;
869 dev->trans_start = jiffies;
870 dev_kfree_skb (skb);
871
872 /* Check for free resources: stop Tx queue if there are none */
873 if (inb (EWRK3_FMQC) == 0)
874 netif_stop_queue (dev);
875
876 return 0;
877
878 err_out:
879 ENABLE_IRQs;
880 spin_unlock_irq (&lp->hw_lock);
881 return 1;
882 }
883
884 /*
885 ** The EWRK3 interrupt handler.
886 */
887 static irqreturn_t ewrk3_interrupt(int irq, void *dev_id, struct pt_regs *regs)
888 {
889 struct net_device *dev = dev_id;
890 struct ewrk3_private *lp;
891 u_long iobase;
892 u_char icr, cr, csr;
893
894 lp = netdev_priv(dev);
895 iobase = dev->base_addr;
896
897 /* get the interrupt information */
898 csr = inb(EWRK3_CSR);
899
900 /*
901 ** Mask the EWRK3 board interrupts and turn on the LED
902 */
903 spin_lock(&lp->hw_lock);
904 DISABLE_IRQs;
905
906 cr = inb(EWRK3_CR);
907 cr |= lp->led_mask;
908 outb(cr, EWRK3_CR);
909
910 if (csr & CSR_RNE) /* Rx interrupt (packet[s] arrived) */
911 ewrk3_rx(dev);
912
913 if (csr & CSR_TNE) /* Tx interrupt (packet sent) */
914 ewrk3_tx(dev);
915
916 /*
917 ** Now deal with the TX/RX disable flags. These are set when there
918 ** are no more resources. If resources free up then enable these
919 ** interrupts, otherwise mask them - failure to do this will result
920 ** in the system hanging in an interrupt loop.
921 */
922 if (inb(EWRK3_FMQC)) { /* any resources available? */
923 lp->irq_mask |= ICR_TXDM | ICR_RXDM; /* enable the interrupt source */
924 csr &= ~(CSR_TXD | CSR_RXD); /* ensure restart of a stalled TX or RX */
925 outb(csr, EWRK3_CSR);
926 netif_wake_queue(dev);
927 } else {
928 lp->irq_mask &= ~(ICR_TXDM | ICR_RXDM); /* disable the interrupt source */
929 }
930
931 /* Unmask the EWRK3 board interrupts and turn off the LED */
932 cr &= ~(lp->led_mask);
933 outb(cr, EWRK3_CR);
934 ENABLE_IRQs;
935 spin_unlock(&lp->hw_lock);
936 return IRQ_HANDLED;
937 }
938
939 /* Called with lp->hw_lock held */
940 static int ewrk3_rx(struct net_device *dev)
941 {
942 struct ewrk3_private *lp = netdev_priv(dev);
943 u_long iobase = dev->base_addr;
944 int i, status = 0;
945 u_char page;
946 void __iomem *buf = NULL;
947
948 while (inb(EWRK3_RQC) && !status) { /* Whilst there's incoming data */
949 if ((page = inb(EWRK3_RQ)) < lp->mPage) { /* Get next entry's buffer page */
950 /*
951 ** Set up shared memory window and pointer into the window
952 */
953 if (lp->shmem_length == IO_ONLY) {
954 outb(page, EWRK3_IOPR);
955 } else if (lp->shmem_length == SHMEM_2K) {
956 buf = lp->shmem;
957 outb(page, EWRK3_MPR);
958 } else if (lp->shmem_length == SHMEM_32K) {
959 buf = (((short) page << 11) & 0x7800) + lp->shmem;
960 outb((page >> 4), EWRK3_MPR);
961 } else if (lp->shmem_length == SHMEM_64K) {
962 buf = (((short) page << 11) & 0xf800) + lp->shmem;
963 outb((page >> 5), EWRK3_MPR);
964 } else {
965 status = -1;
966 printk("%s: Oops - your private data area is hosed!\n", dev->name);
967 }
968
969 if (!status) {
970 char rx_status;
971 int pkt_len;
972
973 if (lp->shmem_length == IO_ONLY) {
974 rx_status = inb(EWRK3_DATA);
975 pkt_len = inb(EWRK3_DATA);
976 pkt_len |= ((u_short) inb(EWRK3_DATA) << 8);
977 } else {
978 rx_status = readb(buf);
979 buf += 1;
980 pkt_len = readw(buf);
981 buf += 3;
982 }
983
984 if (!(rx_status & R_ROK)) { /* There was an error. */
985 lp->stats.rx_errors++; /* Update the error stats. */
986 if (rx_status & R_DBE)
987 lp->stats.rx_frame_errors++;
988 if (rx_status & R_CRC)
989 lp->stats.rx_crc_errors++;
990 if (rx_status & R_PLL)
991 lp->stats.rx_fifo_errors++;
992 } else {
993 struct sk_buff *skb;
994
995 if ((skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
996 unsigned char *p;
997 skb->dev = dev;
998 skb_reserve(skb, 2); /* Align to 16 bytes */
999 p = skb_put(skb, pkt_len);
1000
1001 if (lp->shmem_length == IO_ONLY) {
1002 *p = inb(EWRK3_DATA); /* dummy read */
1003 for (i = 0; i < pkt_len; i++) {
1004 *p++ = inb(EWRK3_DATA);
1005 }
1006 } else {
1007 memcpy_fromio(p, buf, pkt_len);
1008 }
1009
1010 for (i = 1; i < EWRK3_PKT_STAT_SZ - 1; i++) {
1011 if (pkt_len < i * EWRK3_PKT_BIN_SZ) {
1012 lp->pktStats.bins[i]++;
1013 i = EWRK3_PKT_STAT_SZ;
1014 }
1015 }
1016 p = skb->data; /* Look at the dest addr */
1017 if (p[0] & 0x01) { /* Multicast/Broadcast */
1018 if ((*(s16 *) & p[0] == -1) && (*(s16 *) & p[2] == -1) && (*(s16 *) & p[4] == -1)) {
1019 lp->pktStats.broadcast++;
1020 } else {
1021 lp->pktStats.multicast++;
1022 }
1023 } else if ((*(s16 *) & p[0] == *(s16 *) & dev->dev_addr[0]) &&
1024 (*(s16 *) & p[2] == *(s16 *) & dev->dev_addr[2]) &&
1025 (*(s16 *) & p[4] == *(s16 *) & dev->dev_addr[4])) {
1026 lp->pktStats.unicast++;
1027 }
1028 lp->pktStats.bins[0]++; /* Duplicates stats.rx_packets */
1029 if (lp->pktStats.bins[0] == 0) { /* Reset counters */
1030 memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1031 }
1032 /*
1033 ** Notify the upper protocol layers that there is another
1034 ** packet to handle
1035 */
1036 skb->protocol = eth_type_trans(skb, dev);
1037 netif_rx(skb);
1038
1039 /*
1040 ** Update stats
1041 */
1042 dev->last_rx = jiffies;
1043 lp->stats.rx_packets++;
1044 lp->stats.rx_bytes += pkt_len;
1045 } else {
1046 printk("%s: Insufficient memory; nuking packet.\n", dev->name);
1047 lp->stats.rx_dropped++; /* Really, deferred. */
1048 break;
1049 }
1050 }
1051 }
1052 /*
1053 ** Return the received buffer to the free memory queue
1054 */
1055 outb(page, EWRK3_FMQ);
1056 } else {
1057 printk("ewrk3_rx(): Illegal page number, page %d\n", page);
1058 printk("ewrk3_rx(): CSR: %02x ICR: %02x FMQC: %02x\n", inb(EWRK3_CSR), inb(EWRK3_ICR), inb(EWRK3_FMQC));
1059 }
1060 }
1061 return status;
1062 }
1063
1064 /*
1065 ** Buffer sent - check for TX buffer errors.
1066 ** Called with lp->hw_lock held
1067 */
1068 static int ewrk3_tx(struct net_device *dev)
1069 {
1070 struct ewrk3_private *lp = netdev_priv(dev);
1071 u_long iobase = dev->base_addr;
1072 u_char tx_status;
1073
1074 while ((tx_status = inb(EWRK3_TDQ)) > 0) { /* Whilst there's old buffers */
1075 if (tx_status & T_VSTS) { /* The status is valid */
1076 if (tx_status & T_TXE) {
1077 lp->stats.tx_errors++;
1078 if (tx_status & T_NCL)
1079 lp->stats.tx_carrier_errors++;
1080 if (tx_status & T_LCL)
1081 lp->stats.tx_window_errors++;
1082 if (tx_status & T_CTU) {
1083 if ((tx_status & T_COLL) ^ T_XUR) {
1084 lp->pktStats.tx_underruns++;
1085 } else {
1086 lp->pktStats.excessive_underruns++;
1087 }
1088 } else if (tx_status & T_COLL) {
1089 if ((tx_status & T_COLL) ^ T_XCOLL) {
1090 lp->stats.collisions++;
1091 } else {
1092 lp->pktStats.excessive_collisions++;
1093 }
1094 }
1095 } else {
1096 lp->stats.tx_packets++;
1097 }
1098 }
1099 }
1100
1101 return 0;
1102 }
1103
1104 static int ewrk3_close(struct net_device *dev)
1105 {
1106 struct ewrk3_private *lp = netdev_priv(dev);
1107 u_long iobase = dev->base_addr;
1108 u_char icr, csr;
1109
1110 netif_stop_queue(dev);
1111
1112 if (ewrk3_debug > 1) {
1113 printk("%s: Shutting down ethercard, status was %2.2x.\n",
1114 dev->name, inb(EWRK3_CSR));
1115 }
1116 /*
1117 ** We stop the EWRK3 here... mask interrupts and stop TX & RX
1118 */
1119 DISABLE_IRQs;
1120
1121 STOP_EWRK3;
1122
1123 /*
1124 ** Clean out the TX and RX queues here (note that one entry
1125 ** may get added to either the TXD or RX queues if the TX or RX
1126 ** just starts processing a packet before the STOP_EWRK3 command
1127 ** is received. This will be flushed in the ewrk3_open() call).
1128 */
1129 while (inb(EWRK3_TQ));
1130 while (inb(EWRK3_TDQ));
1131 while (inb(EWRK3_RQ));
1132
1133 if (!lp->hard_strapped) {
1134 free_irq(dev->irq, dev);
1135 }
1136 return 0;
1137 }
1138
1139 static struct net_device_stats *ewrk3_get_stats(struct net_device *dev)
1140 {
1141 struct ewrk3_private *lp = netdev_priv(dev);
1142
1143 /* Null body since there is no framing error counter */
1144 return &lp->stats;
1145 }
1146
1147 /*
1148 ** Set or clear the multicast filter for this adapter.
1149 */
1150 static void set_multicast_list(struct net_device *dev)
1151 {
1152 struct ewrk3_private *lp = netdev_priv(dev);
1153 u_long iobase = dev->base_addr;
1154 u_char csr;
1155
1156 csr = inb(EWRK3_CSR);
1157
1158 if (lp->shmem_length == IO_ONLY) {
1159 lp->mctbl = NULL;
1160 } else {
1161 lp->mctbl = lp->shmem + PAGE0_HTE;
1162 }
1163
1164 csr &= ~(CSR_PME | CSR_MCE);
1165 if (dev->flags & IFF_PROMISC) { /* set promiscuous mode */
1166 csr |= CSR_PME;
1167 outb(csr, EWRK3_CSR);
1168 } else {
1169 SetMulticastFilter(dev);
1170 csr |= CSR_MCE;
1171 outb(csr, EWRK3_CSR);
1172 }
1173 }
1174
1175 /*
1176 ** Calculate the hash code and update the logical address filter
1177 ** from a list of ethernet multicast addresses.
1178 ** Little endian crc one liner from Matt Thomas, DEC.
1179 **
1180 ** Note that when clearing the table, the broadcast bit must remain asserted
1181 ** to receive broadcast messages.
1182 */
1183 static void SetMulticastFilter(struct net_device *dev)
1184 {
1185 struct ewrk3_private *lp = netdev_priv(dev);
1186 struct dev_mc_list *dmi = dev->mc_list;
1187 u_long iobase = dev->base_addr;
1188 int i;
1189 char *addrs, bit, byte;
1190 short __iomem *p = lp->mctbl;
1191 u16 hashcode;
1192 u32 crc;
1193
1194 spin_lock_irq(&lp->hw_lock);
1195
1196 if (lp->shmem_length == IO_ONLY) {
1197 outb(0, EWRK3_IOPR);
1198 outw(PAGE0_HTE, EWRK3_PIR1);
1199 } else {
1200 outb(0, EWRK3_MPR);
1201 }
1202
1203 if (dev->flags & IFF_ALLMULTI) {
1204 for (i = 0; i < (HASH_TABLE_LEN >> 3); i++) {
1205 if (lp->shmem_length == IO_ONLY) {
1206 outb(0xff, EWRK3_DATA);
1207 } else { /* memset didn't work here */
1208 writew(0xffff, p);
1209 p++;
1210 i++;
1211 }
1212 }
1213 } else {
1214 /* Clear table except for broadcast bit */
1215 if (lp->shmem_length == IO_ONLY) {
1216 for (i = 0; i < (HASH_TABLE_LEN >> 4) - 1; i++) {
1217 outb(0x00, EWRK3_DATA);
1218 }
1219 outb(0x80, EWRK3_DATA);
1220 i++; /* insert the broadcast bit */
1221 for (; i < (HASH_TABLE_LEN >> 3); i++) {
1222 outb(0x00, EWRK3_DATA);
1223 }
1224 } else {
1225 memset_io(lp->mctbl, 0, HASH_TABLE_LEN >> 3);
1226 writeb(0x80, lp->mctbl + (HASH_TABLE_LEN >> 4) - 1);
1227 }
1228
1229 /* Update table */
1230 for (i = 0; i < dev->mc_count; i++) { /* for each address in the list */
1231 addrs = dmi->dmi_addr;
1232 dmi = dmi->next;
1233 if ((*addrs & 0x01) == 1) { /* multicast address? */
1234 crc = ether_crc_le(ETH_ALEN, addrs);
1235 hashcode = crc & ((1 << 9) - 1); /* hashcode is 9 LSb of CRC */
1236
1237 byte = hashcode >> 3; /* bit[3-8] -> byte in filter */
1238 bit = 1 << (hashcode & 0x07); /* bit[0-2] -> bit in byte */
1239
1240 if (lp->shmem_length == IO_ONLY) {
1241 u_char tmp;
1242
1243 outw(PAGE0_HTE + byte, EWRK3_PIR1);
1244 tmp = inb(EWRK3_DATA);
1245 tmp |= bit;
1246 outw(PAGE0_HTE + byte, EWRK3_PIR1);
1247 outb(tmp, EWRK3_DATA);
1248 } else {
1249 writeb(readb(lp->mctbl + byte) | bit, lp->mctbl + byte);
1250 }
1251 }
1252 }
1253 }
1254
1255 spin_unlock_irq(&lp->hw_lock);
1256 }
1257
1258 /*
1259 ** ISA bus I/O device probe
1260 */
1261 static int __init isa_probe(struct net_device *dev, u_long ioaddr)
1262 {
1263 int i = num_ewrks3s, maxSlots;
1264 int ret = -ENODEV;
1265
1266 u_long iobase;
1267
1268 if (ioaddr >= 0x400)
1269 goto out;
1270
1271 if (ioaddr == 0) { /* Autoprobing */
1272 iobase = EWRK3_IO_BASE; /* Get the first slot address */
1273 maxSlots = 24;
1274 } else { /* Probe a specific location */
1275 iobase = ioaddr;
1276 maxSlots = i + 1;
1277 }
1278
1279 for (; (i < maxSlots) && (dev != NULL);
1280 iobase += EWRK3_IOP_INC, i++)
1281 {
1282 if (request_region(iobase, EWRK3_TOTAL_SIZE, DRV_NAME)) {
1283 if (DevicePresent(iobase) == 0) {
1284 int irq = dev->irq;
1285 ret = ewrk3_hw_init(dev, iobase);
1286 if (!ret)
1287 break;
1288 dev->irq = irq;
1289 }
1290 release_region(iobase, EWRK3_TOTAL_SIZE);
1291 }
1292 }
1293 out:
1294
1295 return ret;
1296 }
1297
1298 /*
1299 ** EISA bus I/O device probe. Probe from slot 1 since slot 0 is usually
1300 ** the motherboard.
1301 */
1302 static int __init eisa_probe(struct net_device *dev, u_long ioaddr)
1303 {
1304 int i, maxSlots;
1305 u_long iobase;
1306 int ret = -ENODEV;
1307
1308 if (ioaddr < 0x1000)
1309 goto out;
1310
1311 if (ioaddr == 0) { /* Autoprobing */
1312 iobase = EISA_SLOT_INC; /* Get the first slot address */
1313 i = 1;
1314 maxSlots = MAX_EISA_SLOTS;
1315 } else { /* Probe a specific location */
1316 iobase = ioaddr;
1317 i = (ioaddr >> 12);
1318 maxSlots = i + 1;
1319 }
1320
1321 for (i = 1; (i < maxSlots) && (dev != NULL); i++, iobase += EISA_SLOT_INC) {
1322 if (EISA_signature(name, EISA_ID) == 0) {
1323 if (request_region(iobase, EWRK3_TOTAL_SIZE, DRV_NAME) &&
1324 DevicePresent(iobase) == 0) {
1325 int irq = dev->irq;
1326 ret = ewrk3_hw_init(dev, iobase);
1327 if (!ret)
1328 break;
1329 dev->irq = irq;
1330 }
1331 release_region(iobase, EWRK3_TOTAL_SIZE);
1332 }
1333 }
1334
1335 out:
1336 return ret;
1337 }
1338
1339
1340 /*
1341 ** Read the EWRK3 EEPROM using this routine
1342 */
1343 static int Read_EEPROM(u_long iobase, u_char eaddr)
1344 {
1345 int i;
1346
1347 outb((eaddr & 0x3f), EWRK3_PIR1); /* set up 6 bits of address info */
1348 outb(EEPROM_RD, EWRK3_IOPR); /* issue read command */
1349 for (i = 0; i < 5000; i++)
1350 inb(EWRK3_CSR); /* wait 1msec */
1351
1352 return inw(EWRK3_EPROM1); /* 16 bits data return */
1353 }
1354
1355 /*
1356 ** Write the EWRK3 EEPROM using this routine
1357 */
1358 static int Write_EEPROM(short data, u_long iobase, u_char eaddr)
1359 {
1360 int i;
1361
1362 outb(EEPROM_WR_EN, EWRK3_IOPR); /* issue write enable command */
1363 for (i = 0; i < 5000; i++)
1364 inb(EWRK3_CSR); /* wait 1msec */
1365 outw(data, EWRK3_EPROM1); /* write data to register */
1366 outb((eaddr & 0x3f), EWRK3_PIR1); /* set up 6 bits of address info */
1367 outb(EEPROM_WR, EWRK3_IOPR); /* issue write command */
1368 for (i = 0; i < 75000; i++)
1369 inb(EWRK3_CSR); /* wait 15msec */
1370 outb(EEPROM_WR_DIS, EWRK3_IOPR); /* issue write disable command */
1371 for (i = 0; i < 5000; i++)
1372 inb(EWRK3_CSR); /* wait 1msec */
1373
1374 return 0;
1375 }
1376
1377 /*
1378 ** Look for a particular board name in the on-board EEPROM.
1379 */
1380 static void __init EthwrkSignature(char *name, char *eeprom_image)
1381 {
1382 int i;
1383 char *signatures[] = EWRK3_SIGNATURE;
1384
1385 for (i=0; *signatures[i] != '\0'; i++)
1386 if( !strncmp(eeprom_image+EEPROM_PNAME7, signatures[i], strlen(signatures[i])) )
1387 break;
1388
1389 if (*signatures[i] != '\0') {
1390 memcpy(name, eeprom_image+EEPROM_PNAME7, EWRK3_STRLEN);
1391 name[EWRK3_STRLEN] = '\0';
1392 } else
1393 name[0] = '\0';
1394
1395 return;
1396 }
1397
1398 /*
1399 ** Look for a special sequence in the Ethernet station address PROM that
1400 ** is common across all EWRK3 products.
1401 **
1402 ** Search the Ethernet address ROM for the signature. Since the ROM address
1403 ** counter can start at an arbitrary point, the search must include the entire
1404 ** probe sequence length plus the (length_of_the_signature - 1).
1405 ** Stop the search IMMEDIATELY after the signature is found so that the
1406 ** PROM address counter is correctly positioned at the start of the
1407 ** ethernet address for later read out.
1408 */
1409
1410 static int __init DevicePresent(u_long iobase)
1411 {
1412 union {
1413 struct {
1414 u32 a;
1415 u32 b;
1416 } llsig;
1417 char Sig[sizeof(u32) << 1];
1418 }
1419 dev;
1420 short sigLength;
1421 char data;
1422 int i, j, status = 0;
1423
1424 dev.llsig.a = ETH_PROM_SIG;
1425 dev.llsig.b = ETH_PROM_SIG;
1426 sigLength = sizeof(u32) << 1;
1427
1428 for (i = 0, j = 0; j < sigLength && i < PROBE_LENGTH + sigLength - 1; i++) {
1429 data = inb(EWRK3_APROM);
1430 if (dev.Sig[j] == data) { /* track signature */
1431 j++;
1432 } else { /* lost signature; begin search again */
1433 if (data == dev.Sig[0]) {
1434 j = 1;
1435 } else {
1436 j = 0;
1437 }
1438 }
1439 }
1440
1441 if (j != sigLength) {
1442 status = -ENODEV; /* search failed */
1443 }
1444 return status;
1445 }
1446
1447 static u_char __init get_hw_addr(struct net_device *dev, u_char * eeprom_image, char chipType)
1448 {
1449 int i, j, k;
1450 u_short chksum;
1451 u_char crc, lfsr, sd, status = 0;
1452 u_long iobase = dev->base_addr;
1453 u16 tmp;
1454
1455 if (chipType == LeMAC2) {
1456 for (crc = 0x6a, j = 0; j < ETH_ALEN; j++) {
1457 sd = dev->dev_addr[j] = eeprom_image[EEPROM_PADDR0 + j];
1458 outb(dev->dev_addr[j], EWRK3_PAR0 + j);
1459 for (k = 0; k < 8; k++, sd >>= 1) {
1460 lfsr = ((((crc & 0x02) >> 1) ^ (crc & 0x01)) ^ (sd & 0x01)) << 7;
1461 crc = (crc >> 1) + lfsr;
1462 }
1463 }
1464 if (crc != eeprom_image[EEPROM_PA_CRC])
1465 status = -1;
1466 } else {
1467 for (i = 0, k = 0; i < ETH_ALEN;) {
1468 k <<= 1;
1469 if (k > 0xffff)
1470 k -= 0xffff;
1471
1472 k += (u_char) (tmp = inb(EWRK3_APROM));
1473 dev->dev_addr[i] = (u_char) tmp;
1474 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
1475 i++;
1476 k += (u_short) ((tmp = inb(EWRK3_APROM)) << 8);
1477 dev->dev_addr[i] = (u_char) tmp;
1478 outb(dev->dev_addr[i], EWRK3_PAR0 + i);
1479 i++;
1480
1481 if (k > 0xffff)
1482 k -= 0xffff;
1483 }
1484 if (k == 0xffff)
1485 k = 0;
1486 chksum = inb(EWRK3_APROM);
1487 chksum |= (inb(EWRK3_APROM) << 8);
1488 if (k != chksum)
1489 status = -1;
1490 }
1491
1492 return status;
1493 }
1494
1495 /*
1496 ** Look for a particular board name in the EISA configuration space
1497 */
1498 static int __init EISA_signature(char *name, s32 eisa_id)
1499 {
1500 u_long i;
1501 char *signatures[] = EWRK3_SIGNATURE;
1502 char ManCode[EWRK3_STRLEN];
1503 union {
1504 s32 ID;
1505 char Id[4];
1506 } Eisa;
1507 int status = 0;
1508
1509 *name = '\0';
1510 for (i = 0; i < 4; i++) {
1511 Eisa.Id[i] = inb(eisa_id + i);
1512 }
1513
1514 ManCode[0] = (((Eisa.Id[0] >> 2) & 0x1f) + 0x40);
1515 ManCode[1] = (((Eisa.Id[1] & 0xe0) >> 5) + ((Eisa.Id[0] & 0x03) << 3) + 0x40);
1516 ManCode[2] = (((Eisa.Id[2] >> 4) & 0x0f) + 0x30);
1517 ManCode[3] = ((Eisa.Id[2] & 0x0f) + 0x30);
1518 ManCode[4] = (((Eisa.Id[3] >> 4) & 0x0f) + 0x30);
1519 ManCode[5] = '\0';
1520
1521 for (i = 0; (*signatures[i] != '\0') && (*name == '\0'); i++) {
1522 if (strstr(ManCode, signatures[i]) != NULL) {
1523 strcpy(name, ManCode);
1524 status = 1;
1525 }
1526 }
1527
1528 return status; /* return the device name string */
1529 }
1530
1531 static void ewrk3_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1532 {
1533 int fwrev = Read_EEPROM(dev->base_addr, EEPROM_REVLVL);
1534
1535 strcpy(info->driver, DRV_NAME);
1536 strcpy(info->version, DRV_VERSION);
1537 sprintf(info->fw_version, "%d", fwrev);
1538 strcpy(info->bus_info, "N/A");
1539 info->eedump_len = EEPROM_MAX;
1540 }
1541
1542 static int ewrk3_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1543 {
1544 struct ewrk3_private *lp = netdev_priv(dev);
1545 unsigned long iobase = dev->base_addr;
1546 u8 cr = inb(EWRK3_CR);
1547
1548 switch (lp->adapter_name[4]) {
1549 case '3': /* DE203 */
1550 ecmd->supported = SUPPORTED_BNC;
1551 ecmd->port = PORT_BNC;
1552 break;
1553
1554 case '4': /* DE204 */
1555 ecmd->supported = SUPPORTED_TP;
1556 ecmd->port = PORT_TP;
1557 break;
1558
1559 case '5': /* DE205 */
1560 ecmd->supported = SUPPORTED_TP | SUPPORTED_BNC | SUPPORTED_AUI;
1561 ecmd->autoneg = !(cr & CR_APD);
1562 /*
1563 ** Port is only valid if autoneg is disabled
1564 ** and even then we don't know if AUI is jumpered.
1565 */
1566 if (!ecmd->autoneg)
1567 ecmd->port = (cr & CR_PSEL) ? PORT_BNC : PORT_TP;
1568 break;
1569 }
1570
1571 ecmd->supported |= SUPPORTED_10baseT_Half;
1572 ecmd->speed = SPEED_10;
1573 ecmd->duplex = DUPLEX_HALF;
1574 return 0;
1575 }
1576
1577 static int ewrk3_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
1578 {
1579 struct ewrk3_private *lp = netdev_priv(dev);
1580 unsigned long iobase = dev->base_addr;
1581 unsigned long flags;
1582 u8 cr;
1583
1584 /* DE205 is the only card with anything to set */
1585 if (lp->adapter_name[4] != '5')
1586 return -EOPNOTSUPP;
1587
1588 /* Sanity-check parameters */
1589 if (ecmd->speed != SPEED_10)
1590 return -EINVAL;
1591 if (ecmd->port != PORT_TP && ecmd->port != PORT_BNC)
1592 return -EINVAL; /* AUI is not software-selectable */
1593 if (ecmd->transceiver != XCVR_INTERNAL)
1594 return -EINVAL;
1595 if (ecmd->duplex != DUPLEX_HALF)
1596 return -EINVAL;
1597 if (ecmd->phy_address != 0)
1598 return -EINVAL;
1599
1600 spin_lock_irqsave(&lp->hw_lock, flags);
1601 cr = inb(EWRK3_CR);
1602
1603 /* If Autoneg is set, change to Auto Port mode */
1604 /* Otherwise, disable Auto Port and set port explicitly */
1605 if (ecmd->autoneg) {
1606 cr &= ~CR_APD;
1607 } else {
1608 cr |= CR_APD;
1609 if (ecmd->port == PORT_TP)
1610 cr &= ~CR_PSEL; /* Force TP */
1611 else
1612 cr |= CR_PSEL; /* Force BNC */
1613 }
1614
1615 /* Commit the changes */
1616 outb(cr, EWRK3_CR);
1617 spin_unlock_irqrestore(&lp->hw_lock, flags);
1618 return 0;
1619 }
1620
1621 static u32 ewrk3_get_link(struct net_device *dev)
1622 {
1623 unsigned long iobase = dev->base_addr;
1624 u8 cmr = inb(EWRK3_CMR);
1625 /* DE203 has BNC only and link status does not apply */
1626 /* On DE204 this is always valid since TP is the only port. */
1627 /* On DE205 this reflects TP status even if BNC or AUI is selected. */
1628 return !(cmr & CMR_LINK);
1629 }
1630
1631 static int ewrk3_phys_id(struct net_device *dev, u32 data)
1632 {
1633 struct ewrk3_private *lp = netdev_priv(dev);
1634 unsigned long iobase = dev->base_addr;
1635 unsigned long flags;
1636 u8 cr;
1637 int count;
1638
1639 /* Toggle LED 4x per second */
1640 count = data << 2;
1641
1642 spin_lock_irqsave(&lp->hw_lock, flags);
1643
1644 /* Bail if a PHYS_ID is already in progress */
1645 if (lp->led_mask == 0) {
1646 spin_unlock_irqrestore(&lp->hw_lock, flags);
1647 return -EBUSY;
1648 }
1649
1650 /* Prevent ISR from twiddling the LED */
1651 lp->led_mask = 0;
1652
1653 while (count--) {
1654 /* Toggle the LED */
1655 cr = inb(EWRK3_CR);
1656 outb(cr ^ CR_LED, EWRK3_CR);
1657
1658 /* Wait a little while */
1659 spin_unlock_irqrestore(&lp->hw_lock, flags);
1660 msleep(250);
1661 spin_lock_irqsave(&lp->hw_lock, flags);
1662
1663 /* Exit if we got a signal */
1664 if (signal_pending(current))
1665 break;
1666 }
1667
1668 lp->led_mask = CR_LED;
1669 cr = inb(EWRK3_CR);
1670 outb(cr & ~CR_LED, EWRK3_CR);
1671 spin_unlock_irqrestore(&lp->hw_lock, flags);
1672 return signal_pending(current) ? -ERESTARTSYS : 0;
1673 }
1674
1675 static struct ethtool_ops ethtool_ops_203 = {
1676 .get_drvinfo = ewrk3_get_drvinfo,
1677 .get_settings = ewrk3_get_settings,
1678 .set_settings = ewrk3_set_settings,
1679 .phys_id = ewrk3_phys_id,
1680 };
1681
1682 static struct ethtool_ops ethtool_ops = {
1683 .get_drvinfo = ewrk3_get_drvinfo,
1684 .get_settings = ewrk3_get_settings,
1685 .set_settings = ewrk3_set_settings,
1686 .get_link = ewrk3_get_link,
1687 .phys_id = ewrk3_phys_id,
1688 };
1689
1690 /*
1691 ** Perform IOCTL call functions here. Some are privileged operations and the
1692 ** effective uid is checked in those cases.
1693 */
1694 static int ewrk3_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1695 {
1696 struct ewrk3_private *lp = netdev_priv(dev);
1697 struct ewrk3_ioctl *ioc = (struct ewrk3_ioctl *) &rq->ifr_ifru;
1698 u_long iobase = dev->base_addr;
1699 int i, j, status = 0;
1700 u_char csr;
1701 unsigned long flags;
1702 union ewrk3_addr {
1703 u_char addr[HASH_TABLE_LEN * ETH_ALEN];
1704 u_short val[(HASH_TABLE_LEN * ETH_ALEN) >> 1];
1705 };
1706
1707 union ewrk3_addr *tmp;
1708
1709 /* All we handle are private IOCTLs */
1710 if (cmd != EWRK3IOCTL)
1711 return -EOPNOTSUPP;
1712
1713 tmp = kmalloc(sizeof(union ewrk3_addr), GFP_KERNEL);
1714 if(tmp==NULL)
1715 return -ENOMEM;
1716
1717 switch (ioc->cmd) {
1718 case EWRK3_GET_HWADDR: /* Get the hardware address */
1719 for (i = 0; i < ETH_ALEN; i++) {
1720 tmp->addr[i] = dev->dev_addr[i];
1721 }
1722 ioc->len = ETH_ALEN;
1723 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1724 status = -EFAULT;
1725 break;
1726
1727 case EWRK3_SET_HWADDR: /* Set the hardware address */
1728 if (capable(CAP_NET_ADMIN)) {
1729 spin_lock_irqsave(&lp->hw_lock, flags);
1730 csr = inb(EWRK3_CSR);
1731 csr |= (CSR_TXD | CSR_RXD);
1732 outb(csr, EWRK3_CSR); /* Disable the TX and RX */
1733 spin_unlock_irqrestore(&lp->hw_lock, flags);
1734
1735 if (copy_from_user(tmp->addr, ioc->data, ETH_ALEN)) {
1736 status = -EFAULT;
1737 break;
1738 }
1739 spin_lock_irqsave(&lp->hw_lock, flags);
1740 for (i = 0; i < ETH_ALEN; i++) {
1741 dev->dev_addr[i] = tmp->addr[i];
1742 outb(tmp->addr[i], EWRK3_PAR0 + i);
1743 }
1744
1745 csr = inb(EWRK3_CSR);
1746 csr &= ~(CSR_TXD | CSR_RXD); /* Enable the TX and RX */
1747 outb(csr, EWRK3_CSR);
1748 spin_unlock_irqrestore(&lp->hw_lock, flags);
1749 } else {
1750 status = -EPERM;
1751 }
1752
1753 break;
1754 case EWRK3_SET_PROM: /* Set Promiscuous Mode */
1755 if (capable(CAP_NET_ADMIN)) {
1756 spin_lock_irqsave(&lp->hw_lock, flags);
1757 csr = inb(EWRK3_CSR);
1758 csr |= CSR_PME;
1759 csr &= ~CSR_MCE;
1760 outb(csr, EWRK3_CSR);
1761 spin_unlock_irqrestore(&lp->hw_lock, flags);
1762 } else {
1763 status = -EPERM;
1764 }
1765
1766 break;
1767 case EWRK3_CLR_PROM: /* Clear Promiscuous Mode */
1768 if (capable(CAP_NET_ADMIN)) {
1769 spin_lock_irqsave(&lp->hw_lock, flags);
1770 csr = inb(EWRK3_CSR);
1771 csr &= ~CSR_PME;
1772 outb(csr, EWRK3_CSR);
1773 spin_unlock_irqrestore(&lp->hw_lock, flags);
1774 } else {
1775 status = -EPERM;
1776 }
1777
1778 break;
1779 case EWRK3_GET_MCA: /* Get the multicast address table */
1780 spin_lock_irqsave(&lp->hw_lock, flags);
1781 if (lp->shmem_length == IO_ONLY) {
1782 outb(0, EWRK3_IOPR);
1783 outw(PAGE0_HTE, EWRK3_PIR1);
1784 for (i = 0; i < (HASH_TABLE_LEN >> 3); i++) {
1785 tmp->addr[i] = inb(EWRK3_DATA);
1786 }
1787 } else {
1788 outb(0, EWRK3_MPR);
1789 memcpy_fromio(tmp->addr, lp->shmem + PAGE0_HTE, (HASH_TABLE_LEN >> 3));
1790 }
1791 spin_unlock_irqrestore(&lp->hw_lock, flags);
1792
1793 ioc->len = (HASH_TABLE_LEN >> 3);
1794 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1795 status = -EFAULT;
1796
1797 break;
1798 case EWRK3_SET_MCA: /* Set a multicast address */
1799 if (capable(CAP_NET_ADMIN)) {
1800 if (ioc->len > 1024)
1801 {
1802 status = -EINVAL;
1803 break;
1804 }
1805 if (copy_from_user(tmp->addr, ioc->data, ETH_ALEN * ioc->len)) {
1806 status = -EFAULT;
1807 break;
1808 }
1809 set_multicast_list(dev);
1810 } else {
1811 status = -EPERM;
1812 }
1813
1814 break;
1815 case EWRK3_CLR_MCA: /* Clear all multicast addresses */
1816 if (capable(CAP_NET_ADMIN)) {
1817 set_multicast_list(dev);
1818 } else {
1819 status = -EPERM;
1820 }
1821
1822 break;
1823 case EWRK3_MCA_EN: /* Enable multicast addressing */
1824 if (capable(CAP_NET_ADMIN)) {
1825 spin_lock_irqsave(&lp->hw_lock, flags);
1826 csr = inb(EWRK3_CSR);
1827 csr |= CSR_MCE;
1828 csr &= ~CSR_PME;
1829 outb(csr, EWRK3_CSR);
1830 spin_unlock_irqrestore(&lp->hw_lock, flags);
1831 } else {
1832 status = -EPERM;
1833 }
1834
1835 break;
1836 case EWRK3_GET_STATS: { /* Get the driver statistics */
1837 struct ewrk3_stats *tmp_stats =
1838 kmalloc(sizeof(lp->pktStats), GFP_KERNEL);
1839 if (!tmp_stats) {
1840 status = -ENOMEM;
1841 break;
1842 }
1843
1844 spin_lock_irqsave(&lp->hw_lock, flags);
1845 memcpy(tmp_stats, &lp->pktStats, sizeof(lp->pktStats));
1846 spin_unlock_irqrestore(&lp->hw_lock, flags);
1847
1848 ioc->len = sizeof(lp->pktStats);
1849 if (copy_to_user(ioc->data, tmp_stats, sizeof(lp->pktStats)))
1850 status = -EFAULT;
1851 kfree(tmp_stats);
1852 break;
1853 }
1854 case EWRK3_CLR_STATS: /* Zero out the driver statistics */
1855 if (capable(CAP_NET_ADMIN)) {
1856 spin_lock_irqsave(&lp->hw_lock, flags);
1857 memset(&lp->pktStats, 0, sizeof(lp->pktStats));
1858 spin_unlock_irqrestore(&lp->hw_lock,flags);
1859 } else {
1860 status = -EPERM;
1861 }
1862
1863 break;
1864 case EWRK3_GET_CSR: /* Get the CSR Register contents */
1865 tmp->addr[0] = inb(EWRK3_CSR);
1866 ioc->len = 1;
1867 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1868 status = -EFAULT;
1869 break;
1870 case EWRK3_SET_CSR: /* Set the CSR Register contents */
1871 if (capable(CAP_NET_ADMIN)) {
1872 if (copy_from_user(tmp->addr, ioc->data, 1)) {
1873 status = -EFAULT;
1874 break;
1875 }
1876 outb(tmp->addr[0], EWRK3_CSR);
1877 } else {
1878 status = -EPERM;
1879 }
1880
1881 break;
1882 case EWRK3_GET_EEPROM: /* Get the EEPROM contents */
1883 if (capable(CAP_NET_ADMIN)) {
1884 for (i = 0; i < (EEPROM_MAX >> 1); i++) {
1885 tmp->val[i] = (short) Read_EEPROM(iobase, i);
1886 }
1887 i = EEPROM_MAX;
1888 tmp->addr[i++] = inb(EWRK3_CMR); /* Config/Management Reg. */
1889 for (j = 0; j < ETH_ALEN; j++) {
1890 tmp->addr[i++] = inb(EWRK3_PAR0 + j);
1891 }
1892 ioc->len = EEPROM_MAX + 1 + ETH_ALEN;
1893 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1894 status = -EFAULT;
1895 } else {
1896 status = -EPERM;
1897 }
1898
1899 break;
1900 case EWRK3_SET_EEPROM: /* Set the EEPROM contents */
1901 if (capable(CAP_NET_ADMIN)) {
1902 if (copy_from_user(tmp->addr, ioc->data, EEPROM_MAX)) {
1903 status = -EFAULT;
1904 break;
1905 }
1906 for (i = 0; i < (EEPROM_MAX >> 1); i++) {
1907 Write_EEPROM(tmp->val[i], iobase, i);
1908 }
1909 } else {
1910 status = -EPERM;
1911 }
1912
1913 break;
1914 case EWRK3_GET_CMR: /* Get the CMR Register contents */
1915 tmp->addr[0] = inb(EWRK3_CMR);
1916 ioc->len = 1;
1917 if (copy_to_user(ioc->data, tmp->addr, ioc->len))
1918 status = -EFAULT;
1919 break;
1920 case EWRK3_SET_TX_CUT_THRU: /* Set TX cut through mode */
1921 if (capable(CAP_NET_ADMIN)) {
1922 lp->txc = 1;
1923 } else {
1924 status = -EPERM;
1925 }
1926
1927 break;
1928 case EWRK3_CLR_TX_CUT_THRU: /* Clear TX cut through mode */
1929 if (capable(CAP_NET_ADMIN)) {
1930 lp->txc = 0;
1931 } else {
1932 status = -EPERM;
1933 }
1934
1935 break;
1936 default:
1937 status = -EOPNOTSUPP;
1938 }
1939 kfree(tmp);
1940 return status;
1941 }
1942
1943 #ifdef MODULE
1944 static struct net_device *ewrk3_devs[MAX_NUM_EWRK3S];
1945 static int ndevs;
1946 static int io[MAX_NUM_EWRK3S+1] = { 0x300, 0, };
1947
1948 /* '21' below should really be 'MAX_NUM_EWRK3S' */
1949 module_param_array(io, int, NULL, 0);
1950 module_param_array(irq, int, NULL, 0);
1951 MODULE_PARM_DESC(io, "EtherWORKS 3 I/O base address(es)");
1952 MODULE_PARM_DESC(irq, "EtherWORKS 3 IRQ number(s)");
1953
1954 static __exit void ewrk3_exit_module(void)
1955 {
1956 int i;
1957
1958 for( i=0; i<ndevs; i++ ) {
1959 struct net_device *dev = ewrk3_devs[i];
1960 struct ewrk3_private *lp = netdev_priv(dev);
1961 ewrk3_devs[i] = NULL;
1962 unregister_netdev(dev);
1963 release_region(dev->base_addr, EWRK3_TOTAL_SIZE);
1964 iounmap(lp->shmem);
1965 free_netdev(dev);
1966 }
1967 }
1968
1969 static __init int ewrk3_init_module(void)
1970 {
1971 int i=0;
1972
1973 while( io[i] && irq[i] ) {
1974 struct net_device *dev
1975 = alloc_etherdev(sizeof(struct ewrk3_private));
1976
1977 if (!dev)
1978 break;
1979
1980 if (ewrk3_probe1(dev, io[i], irq[i]) != 0) {
1981 free_netdev(dev);
1982 break;
1983 }
1984
1985 ewrk3_devs[ndevs++] = dev;
1986 i++;
1987 }
1988
1989 return ndevs ? 0 : -EIO;
1990 }
1991
1992
1993 /* Hack for breakage in new module stuff */
1994 module_exit(ewrk3_exit_module);
1995 module_init(ewrk3_init_module);
1996 #endif /* MODULE */
1997 MODULE_LICENSE("GPL");
1998
1999 \f
2000
2001 /*
2002 * Local variables:
2003 * 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"
2004 *
2005 * 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"
2006 * End:
2007 */
Verdex Pro support