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