1 /*
2 net-3-driver for the 3c523 Etherlink/MC card (i82586 Ethernet chip)
3
4
5 This is an extension to the Linux operating system, and is covered by the
6 same Gnu Public License that covers that work.
7
8 Copyright 1995, 1996 by Chris Beauregard (cpbeaure@undergrad.math.uwaterloo.ca)
9
10 This is basically Michael Hipp's ni52 driver, with a new probing
11 algorithm and some minor changes to the 82586 CA and reset routines.
12 Thanks a lot Michael for a really clean i82586 implementation! Unless
13 otherwise documented in ni52.c, any bugs are mine.
14
15 Contrary to the Ethernet-HOWTO, this isn't based on the 3c507 driver in
16 any way. The ni52 is a lot easier to modify.
17
18 sources:
19 ni52.c
20
21 Crynwr packet driver collection was a great reference for my first
22 attempt at this sucker. The 3c507 driver also helped, until I noticed
23 that ni52.c was a lot nicer.
24
25 EtherLink/MC: Micro Channel Ethernet Adapter Technical Reference
26 Manual, courtesy of 3Com CardFacts, documents the 3c523-specific
27 stuff. Information on CardFacts is found in the Ethernet HOWTO.
28 Also see <a href="http://www.3com.com/">
29
30 Microprocessor Communications Support Chips, T.J. Byers, ISBN
31 0-444-01224-9, has a section on the i82586. It tells you just enough
32 to know that you really don't want to learn how to program the chip.
33
34 The original device probe code was stolen from ps2esdi.c
35
36 Known Problems:
37 Since most of the code was stolen from ni52.c, you'll run across the
38 same bugs in the 0.62 version of ni52.c, plus maybe a few because of
39 the 3c523 idiosynchacies. The 3c523 has 16K of RAM though, so there
40 shouldn't be the overrun problem that the 8K ni52 has.
41
42 This driver is for a 16K adapter. It should work fine on the 64K
43 adapters, but it will only use one of the 4 banks of RAM. Modifying
44 this for the 64K version would require a lot of heinous bank
45 switching, which I'm sure not interested in doing. If you try to
46 implement a bank switching version, you'll basically have to remember
47 what bank is enabled and do a switch everytime you access a memory
48 location that's not current. You'll also have to remap pointers on
49 the driver side, because it only knows about 16K of the memory.
50 Anyone desperate or masochistic enough to try?
51
52 It seems to be stable now when multiple transmit buffers are used. I
53 can't see any performance difference, but then I'm working on a 386SX.
54
55 Multicast doesn't work. It doesn't even pretend to work. Don't use
56 it. Don't compile your kernel with multicast support. I don't know
57 why.
58
59 Features:
60 This driver is useable as a loadable module. If you try to specify an
61 IRQ or a IO address (via insmod 3c523.o irq=xx io=0xyyy), it will
62 search the MCA slots until it finds a 3c523 with the specified
63 parameters.
64
65 This driver does support multiple ethernet cards when used as a module
66 (up to MAX_3C523_CARDS, the default being 4)
67
68 This has been tested with both BNC and TP versions, internal and
69 external transceivers. Haven't tested with the 64K version (that I
70 know of).
71
72 History:
73 Jan 1st, 1996
74 first public release
75 Feb 4th, 1996
76 update to 1.3.59, incorporated multicast diffs from ni52.c
77 Feb 15th, 1996
78 added shared irq support
79 Apr 1999
80 added support for multiple cards when used as a module
81 added option to disable multicast as is causes problems
82 Ganesh Sittampalam <ganesh.sittampalam@magdalen.oxford.ac.uk>
83 Stuart Adamson <stuart.adamson@compsoc.net>
84
85 $Header: /fsys2/home/chrisb/linux-1.3.59-MCA/drivers/net/RCS/3c523.c,v 1.1 1996/02/05 01:53:46 chrisb Exp chrisb $
86 */
87
88 #include <linux/module.h>
89 #include <linux/kernel.h>
90 #include <linux/sched.h>
91 #include <linux/string.h>
92 #include <linux/errno.h>
93 #include <linux/ioport.h>
94 #include <linux/malloc.h>
95 #include <linux/interrupt.h>
96 #include <linux/delay.h>
97 #include <linux/mca.h>
98 #include <asm/processor.h>
99 #include <asm/bitops.h>
100 #include <asm/io.h>
101
102 #include <linux/netdevice.h>
103 #include <linux/etherdevice.h>
104 #include <linux/skbuff.h>
105 #include <linux/init.h>
106
107 #include "3c523.h"
108
109 /*************************************************************************/
110 #define DEBUG /* debug on */
111 #define SYSBUSVAL 0 /* 1 = 8 Bit, 0 = 16 bit - 3c523 only does 16 bit */
112 #undef ELMC_MULTICAST /* Disable multicast support as it is somewhat seriously broken at the moment */
113
114 #define make32(ptr16) (p->memtop + (short) (ptr16) )
115 #define make24(ptr32) ((char *) (ptr32) - p->base)
116 #define make16(ptr32) ((unsigned short) ((unsigned long) (ptr32) - (unsigned long) p->memtop ))
117
118 /*************************************************************************/
119 /*
120 Tables to which we can map values in the configuration registers.
121 */
122 static int irq_table[] __initdata = {
123 12, 7, 3, 9
124 };
125
126 static int csr_table[] __initdata = {
127 0x300, 0x1300, 0x2300, 0x3300
128 };
129
130 static int shm_table[] __initdata = {
131 0x0c0000, 0x0c8000, 0x0d0000, 0x0d8000
132 };
133
134 /******************* how to calculate the buffers *****************************
135
136
137 * IMPORTANT NOTE: if you configure only one NUM_XMIT_BUFFS, the driver works
138 * --------------- in a different (more stable?) mode. Only in this mode it's
139 * possible to configure the driver with 'NO_NOPCOMMANDS'
140
141 sizeof(scp)=12; sizeof(scb)=16; sizeof(iscp)=8;
142 sizeof(scp)+sizeof(iscp)+sizeof(scb) = 36 = INIT
143 sizeof(rfd) = 24; sizeof(rbd) = 12;
144 sizeof(tbd) = 8; sizeof(transmit_cmd) = 16;
145 sizeof(nop_cmd) = 8;
146
147 * if you don't know the driver, better do not change this values: */
148
149 #define RECV_BUFF_SIZE 1524 /* slightly oversized */
150 #define XMIT_BUFF_SIZE 1524 /* slightly oversized */
151 #define NUM_XMIT_BUFFS 4 /* config for both, 8K and 16K shmem */
152 #define NUM_RECV_BUFFS_8 1 /* config for 8K shared mem */
153 #define NUM_RECV_BUFFS_16 6 /* config for 16K shared mem */
154
155 #if (NUM_XMIT_BUFFS == 1)
156 #define NO_NOPCOMMANDS /* only possible with NUM_XMIT_BUFFS=1 */
157 #endif
158
159 /**************************************************************************/
160
161 #define DELAY(x) { mdelay(32 * x); }
162
163 /* a much shorter delay: */
164 #define DELAY_16(); { udelay(16) ; }
165
166 /* wait for command with timeout: */
167 #define WAIT_4_SCB_CMD() { int i; \
168 for(i=0;i<1024;i++) { \
169 if(!p->scb->cmd) break; \
170 DELAY_16(); \
171 if(i == 1023) { \
172 printk(KERN_WARNING "%s:%d: scb_cmd timed out .. resetting i82586\n",\
173 dev->name,__LINE__); \
174 elmc_id_reset586(); } } }
175
176 static void elmc_interrupt(int irq, void *dev_id, struct pt_regs *reg_ptr);
177 static int elmc_open(struct net_device *dev);
178 static int elmc_close(struct net_device *dev);
179 static int elmc_send_packet(struct sk_buff *, struct net_device *);
180 static struct net_device_stats *elmc_get_stats(struct net_device *dev);
181 static void elmc_timeout(struct net_device *dev);
182 #ifdef ELMC_MULTICAST
183 static void set_multicast_list(struct net_device *dev);
184 #endif
185
186 /* helper-functions */
187 static int init586(struct net_device *dev);
188 static int check586(struct net_device *dev, unsigned long where, unsigned size);
189 static void alloc586(struct net_device *dev);
190 static void startrecv586(struct net_device *dev);
191 static void *alloc_rfa(struct net_device *dev, void *ptr);
192 static void elmc_rcv_int(struct net_device *dev);
193 static void elmc_xmt_int(struct net_device *dev);
194 static void elmc_rnr_int(struct net_device *dev);
195
196 struct priv {
197 struct net_device_stats stats;
198 unsigned long base;
199 char *memtop;
200 volatile struct rfd_struct *rfd_last, *rfd_top, *rfd_first;
201 volatile struct scp_struct *scp; /* volatile is important */
202 volatile struct iscp_struct *iscp; /* volatile is important */
203 volatile struct scb_struct *scb; /* volatile is important */
204 volatile struct tbd_struct *xmit_buffs[NUM_XMIT_BUFFS];
205 volatile struct transmit_cmd_struct *xmit_cmds[NUM_XMIT_BUFFS];
206 #if (NUM_XMIT_BUFFS == 1)
207 volatile struct nop_cmd_struct *nop_cmds[2];
208 #else
209 volatile struct nop_cmd_struct *nop_cmds[NUM_XMIT_BUFFS];
210 #endif
211 volatile int nop_point, num_recv_buffs;
212 volatile char *xmit_cbuffs[NUM_XMIT_BUFFS];
213 volatile int xmit_count, xmit_last;
214 volatile int slot;
215 };
216
217 #define elmc_attn586() {elmc_do_attn586(dev->base_addr,ELMC_CTRL_INTE);}
218 #define elmc_reset586() {elmc_do_reset586(dev->base_addr,ELMC_CTRL_INTE);}
219
220 /* with interrupts disabled - this will clear the interrupt bit in the
221 3c523 control register, and won't put it back. This effectively
222 disables interrupts on the card. */
223 #define elmc_id_attn586() {elmc_do_attn586(dev->base_addr,0);}
224 #define elmc_id_reset586() {elmc_do_reset586(dev->base_addr,0);}
225
226 /*************************************************************************/
227 /*
228 Do a Channel Attention on the 3c523. This is extremely board dependent.
229 */
230 static void elmc_do_attn586(int ioaddr, int ints)
231 {
232 /* the 3c523 requires a minimum of 500 ns. The delays here might be
233 a little too large, and hence they may cut the performance of the
234 card slightly. If someone who knows a little more about Linux
235 timing would care to play with these, I'd appreciate it. */
236
237 /* this bit masking stuff is crap. I'd rather have separate
238 registers with strobe triggers for each of these functions. <sigh>
239 Ya take what ya got. */
240
241 outb(ELMC_CTRL_RST | 0x3 | ELMC_CTRL_CA | ints, ioaddr + ELMC_CTRL);
242 DELAY_16(); /* > 500 ns */
243 outb(ELMC_CTRL_RST | 0x3 | ints, ioaddr + ELMC_CTRL);
244 }
245
246 /*************************************************************************/
247 /*
248 Reset the 82586 on the 3c523. Also very board dependent.
249 */
250 static void elmc_do_reset586(int ioaddr, int ints)
251 {
252 /* toggle the RST bit low then high */
253 outb(0x3 | ELMC_CTRL_LBK, ioaddr + ELMC_CTRL);
254 DELAY_16(); /* > 500 ns */
255 outb(ELMC_CTRL_RST | ELMC_CTRL_LBK | 0x3, ioaddr + ELMC_CTRL);
256
257 elmc_do_attn586(ioaddr, ints);
258 }
259
260 /**********************************************
261 * close device
262 */
263
264 static int elmc_close(struct net_device *dev)
265 {
266 netif_stop_queue(dev);
267 elmc_id_reset586(); /* the hard way to stop the receiver */
268 free_irq(dev->irq, dev);
269 return 0;
270 }
271
272 /**********************************************
273 * open device
274 */
275
276 static int elmc_open(struct net_device *dev)
277 {
278 int ret;
279
280 elmc_id_attn586(); /* disable interrupts */
281
282 ret = request_irq(dev->irq, &elmc_interrupt, SA_SHIRQ | SA_SAMPLE_RANDOM,
283 dev->name, dev);
284 if (ret) {
285 printk(KERN_ERR "%s: couldn't get irq %d\n", dev->name, dev->irq);
286 elmc_id_reset586();
287 return ret;
288 }
289 alloc586(dev);
290 init586(dev);
291 startrecv586(dev);
292 netif_start_queue(dev);
293 return 0; /* most done by init */
294 }
295
296 /**********************************************
297 * Check to see if there's an 82586 out there.
298 */
299
300 static int __init check586(struct net_device *dev, unsigned long where, unsigned size)
301 {
302 struct priv *p = (struct priv *) dev->priv;
303 char *iscp_addrs[2];
304 int i = 0;
305
306 p->base = where + size - 0x01000000;
307 p->memtop = phys_to_virt(where) + size;
308 p->scp = (struct scp_struct *)phys_to_virt(p->base + SCP_DEFAULT_ADDRESS);
309 memset((char *) p->scp, 0, sizeof(struct scp_struct));
310 p->scp->sysbus = SYSBUSVAL; /* 1 = 8Bit-Bus, 0 = 16 Bit */
311
312 iscp_addrs[0] = phys_to_virt(where);
313 iscp_addrs[1] = (char *) p->scp - sizeof(struct iscp_struct);
314
315 for (i = 0; i < 2; i++) {
316 p->iscp = (struct iscp_struct *) iscp_addrs[i];
317 memset((char *) p->iscp, 0, sizeof(struct iscp_struct));
318
319 p->scp->iscp = make24(p->iscp);
320 p->iscp->busy = 1;
321
322 elmc_id_reset586();
323
324 /* reset586 does an implicit CA */
325
326 /* apparently, you sometimes have to kick the 82586 twice... */
327 elmc_id_attn586();
328
329 if (p->iscp->busy) { /* i82586 clears 'busy' after successful init */
330 return 0;
331 }
332 }
333 return 1;
334 }
335
336 /******************************************************************
337 * set iscp at the right place, called by elmc_probe and open586.
338 */
339
340 void alloc586(struct net_device *dev)
341 {
342 struct priv *p = (struct priv *) dev->priv;
343
344 elmc_id_reset586();
345 DELAY(2);
346
347 p->scp = (struct scp_struct *) phys_to_virt(p->base + SCP_DEFAULT_ADDRESS);
348 p->scb = (struct scb_struct *) phys_to_virt(dev->mem_start);
349 p->iscp = (struct iscp_struct *) ((char *) p->scp - sizeof(struct iscp_struct));
350
351 memset((char *) p->iscp, 0, sizeof(struct iscp_struct));
352 memset((char *) p->scp, 0, sizeof(struct scp_struct));
353
354 p->scp->iscp = make24(p->iscp);
355 p->scp->sysbus = SYSBUSVAL;
356 p->iscp->scb_offset = make16(p->scb);
357
358 p->iscp->busy = 1;
359 elmc_id_reset586();
360 elmc_id_attn586();
361
362 DELAY(2);
363
364 if (p->iscp->busy) {
365 printk(KERN_ERR "%s: Init-Problems (alloc).\n", dev->name);
366 }
367 memset((char *) p->scb, 0, sizeof(struct scb_struct));
368 }
369
370 /*****************************************************************/
371
372 static int elmc_getinfo(char *buf, int slot, void *d)
373 {
374 int len = 0;
375 struct net_device *dev = (struct net_device *) d;
376 int i;
377
378 if (dev == NULL)
379 return len;
380
381 len += sprintf(buf + len, "Revision: 0x%x\n",
382 inb(dev->base_addr + ELMC_REVISION) & 0xf);
383 len += sprintf(buf + len, "IRQ: %d\n", dev->irq);
384 len += sprintf(buf + len, "IO Address: %#lx-%#lx\n", dev->base_addr,
385 dev->base_addr + ELMC_IO_EXTENT);
386 len += sprintf(buf + len, "Memory: %#lx-%#lx\n", dev->mem_start,
387 dev->mem_end - 1);
388 len += sprintf(buf + len, "Transceiver: %s\n", dev->if_port ?
389 "External" : "Internal");
390 len += sprintf(buf + len, "Device: %s\n", dev->name);
391 len += sprintf(buf + len, "Hardware Address:");
392 for (i = 0; i < 6; i++) {
393 len += sprintf(buf + len, " %02x", dev->dev_addr[i]);
394 }
395 buf[len++] = '\n';
396 buf[len] = 0;
397
398 return len;
399 } /* elmc_getinfo() */
400
401 /*****************************************************************/
402
403 int __init elmc_probe(struct net_device *dev)
404 {
405 static int slot = 0;
406 int base_addr = dev->base_addr;
407 int irq = dev->irq;
408 u_char status = 0;
409 u_char revision = 0;
410 int i = 0;
411 unsigned int size = 0;
412
413 SET_MODULE_OWNER(dev);
414 if (MCA_bus == 0) {
415 return -ENODEV;
416 }
417 /* search through the slots for the 3c523. */
418 slot = mca_find_adapter(ELMC_MCA_ID, 0);
419 while (slot != -1) {
420 status = mca_read_stored_pos(slot, 2);
421
422 dev->irq=irq_table[(status & ELMC_STATUS_IRQ_SELECT) >> 6];
423 dev->base_addr=csr_table[(status & ELMC_STATUS_CSR_SELECT) >> 1];
424
425 /*
426 If we're trying to match a specified irq or IO address,
427 we'll reject a match unless it's what we're looking for.
428 Also reject it if the card is already in use.
429 */
430
431 if((irq && irq != dev->irq) || (base_addr && base_addr != dev->base_addr)
432 || check_region(dev->base_addr,ELMC_IO_EXTENT)) {
433 slot = mca_find_adapter(ELMC_MCA_ID, slot + 1);
434 continue;
435 }
436 /* found what we're looking for... */
437 break;
438 }
439
440 /* we didn't find any 3c523 in the slots we checked for */
441 if (slot == MCA_NOTFOUND) {
442 return ((base_addr || irq) ? ENXIO : ENODEV);
443 }
444 mca_set_adapter_name(slot, "3Com 3c523 Etherlink/MC");
445 mca_set_adapter_procfn(slot, (MCA_ProcFn) elmc_getinfo, dev);
446
447 /* if we get this far, adapter has been found - carry on */
448 printk(KERN_INFO "%s: 3c523 adapter found in slot %d\n", dev->name, slot + 1);
449
450 /* Now we extract configuration info from the card.
451 The 3c523 provides information in two of the POS registers, but
452 the second one is only needed if we want to tell the card what IRQ
453 to use. I suspect that whoever sets the thing up initially would
454 prefer we don't screw with those things.
455
456 Note that we read the status info when we found the card...
457
458 See 3c523.h for more details.
459 */
460
461 /* revision is stored in the first 4 bits of the revision register */
462 revision = inb(dev->base_addr + ELMC_REVISION) & 0xf;
463
464 /* according to docs, we read the interrupt and write it back to
465 the IRQ select register, since the POST might not configure the IRQ
466 properly. */
467 switch (dev->irq) {
468 case 3:
469 mca_write_pos(slot, 3, 0x04);
470 break;
471 case 7:
472 mca_write_pos(slot, 3, 0x02);
473 break;
474 case 9:
475 mca_write_pos(slot, 3, 0x08);
476 break;
477 case 12:
478 mca_write_pos(slot, 3, 0x01);
479 break;
480 }
481
482 request_region(dev->base_addr, ELMC_IO_EXTENT, "3c523");
483
484 dev->priv = (void *) kmalloc(sizeof(struct priv), GFP_KERNEL);
485 if (dev->priv == NULL) {
486 return -ENOMEM;
487 }
488 memset((char *) dev->priv, 0, sizeof(struct priv));
489
490 ((struct priv *) (dev->priv))->slot = slot;
491
492 printk(KERN_INFO "%s: 3Com 3c523 Rev 0x%x at %#lx\n", dev->name, (int) revision,
493 dev->base_addr);
494
495 /* Determine if we're using the on-board transceiver (i.e. coax) or
496 an external one. The information is pretty much useless, but I
497 guess it's worth brownie points. */
498 dev->if_port = (status & ELMC_STATUS_DISABLE_THIN);
499
500 /* The 3c523 has a 24K chunk of memory. The first 16K is the
501 shared memory, while the last 8K is for the EtherStart BIOS ROM.
502 Which we don't care much about here. We'll just tell Linux that
503 we're using 16K. MCA won't permit address space conflicts caused
504 by not mapping the other 8K. */
505 dev->mem_start = shm_table[(status & ELMC_STATUS_MEMORY_SELECT) >> 3];
506
507 /* We're using MCA, so it's a given that the information about memory
508 size is correct. The Crynwr drivers do something like this. */
509
510 elmc_id_reset586(); /* seems like a good idea before checking it... */
511
512 size = 0x4000; /* check for 16K mem */
513 if (!check586(dev, dev->mem_start, size)) {
514 printk(KERN_ERR "%s: memprobe, Can't find memory at 0x%lx!\n", dev->name,
515 dev->mem_start);
516 release_region(dev->base_addr, ELMC_IO_EXTENT);
517 return -ENODEV;
518 }
519 dev->mem_end = dev->mem_start + size; /* set mem_end showed by 'ifconfig' */
520
521 ((struct priv *) (dev->priv))->base = dev->mem_start + size - 0x01000000;
522 alloc586(dev);
523
524 elmc_id_reset586(); /* make sure it doesn't generate spurious ints */
525
526 /* set number of receive-buffs according to memsize */
527 ((struct priv *) dev->priv)->num_recv_buffs = NUM_RECV_BUFFS_16;
528
529 /* dump all the assorted information */
530 printk(KERN_INFO "%s: IRQ %d, %sternal xcvr, memory %#lx-%#lx.\n", dev->name,
531 dev->irq, dev->if_port ? "ex" : "in",
532 dev->mem_start, dev->mem_end - 1);
533
534 /* The hardware address for the 3c523 is stored in the first six
535 bytes of the IO address. */
536 printk(KERN_INFO "%s: hardware address ", dev->name);
537 for (i = 0; i < 6; i++) {
538 dev->dev_addr[i] = inb(dev->base_addr + i);
539 printk(" %02x", dev->dev_addr[i]);
540 }
541 printk("\n");
542
543 dev->open = &elmc_open;
544 dev->stop = &elmc_close;
545 dev->get_stats = &elmc_get_stats;
546 dev->hard_start_xmit = &elmc_send_packet;
547 dev->tx_timeout = &elmc_timeout;
548 dev->watchdog_timeo = HZ;
549 #ifdef ELMC_MULTICAST
550 dev->set_multicast_list = &set_multicast_list;
551 #else
552 dev->set_multicast_list = NULL;
553 #endif
554
555 ether_setup(dev);
556
557 /* note that we haven't actually requested the IRQ from the kernel.
558 That gets done in elmc_open(). I'm not sure that's such a good idea,
559 but it works, so I'll go with it. */
560
561 #ifndef ELMC_MULTICAST
562 dev->flags&=~IFF_MULTICAST; /* Multicast doesn't work */
563 #endif
564
565 return 0;
566 }
567
568 /**********************************************
569 * init the chip (elmc-interrupt should be disabled?!)
570 * needs a correct 'allocated' memory
571 */
572
573 static int init586(struct net_device *dev)
574 {
575 void *ptr;
576 unsigned long s;
577 int i, result = 0;
578 struct priv *p = (struct priv *) dev->priv;
579 volatile struct configure_cmd_struct *cfg_cmd;
580 volatile struct iasetup_cmd_struct *ias_cmd;
581 volatile struct tdr_cmd_struct *tdr_cmd;
582 volatile struct mcsetup_cmd_struct *mc_cmd;
583 struct dev_mc_list *dmi = dev->mc_list;
584 int num_addrs = dev->mc_count;
585
586 ptr = (void *) ((char *) p->scb + sizeof(struct scb_struct));
587
588 cfg_cmd = (struct configure_cmd_struct *) ptr; /* configure-command */
589 cfg_cmd->cmd_status = 0;
590 cfg_cmd->cmd_cmd = CMD_CONFIGURE | CMD_LAST;
591 cfg_cmd->cmd_link = 0xffff;
592
593 cfg_cmd->byte_cnt = 0x0a; /* number of cfg bytes */
594 cfg_cmd->fifo = 0x08; /* fifo-limit (8=tx:32/rx:64) */
595 cfg_cmd->sav_bf = 0x40; /* hold or discard bad recv frames (bit 7) */
596 cfg_cmd->adr_len = 0x2e; /* addr_len |!src_insert |pre-len |loopback */
597 cfg_cmd->priority = 0x00;
598 cfg_cmd->ifs = 0x60;
599 cfg_cmd->time_low = 0x00;
600 cfg_cmd->time_high = 0xf2;
601 cfg_cmd->promisc = 0;
602 if (dev->flags & (IFF_ALLMULTI | IFF_PROMISC)) {
603 cfg_cmd->promisc = 1;
604 dev->flags |= IFF_PROMISC;
605 }
606 cfg_cmd->carr_coll = 0x00;
607
608 p->scb->cbl_offset = make16(cfg_cmd);
609
610 p->scb->cmd = CUC_START; /* cmd.-unit start */
611 elmc_id_attn586();
612
613 s = jiffies; /* warning: only active with interrupts on !! */
614 while (!(cfg_cmd->cmd_status & STAT_COMPL)) {
615 if (jiffies - s > 30*HZ/100)
616 break;
617 }
618
619 if ((cfg_cmd->cmd_status & (STAT_OK | STAT_COMPL)) != (STAT_COMPL | STAT_OK)) {
620 printk(KERN_WARNING "%s (elmc): configure command failed: %x\n", dev->name, cfg_cmd->cmd_status);
621 return 1;
622 }
623 /*
624 * individual address setup
625 */
626 ias_cmd = (struct iasetup_cmd_struct *) ptr;
627
628 ias_cmd->cmd_status = 0;
629 ias_cmd->cmd_cmd = CMD_IASETUP | CMD_LAST;
630 ias_cmd->cmd_link = 0xffff;
631
632 memcpy((char *) &ias_cmd->iaddr, (char *) dev->dev_addr, ETH_ALEN);
633
634 p->scb->cbl_offset = make16(ias_cmd);
635
636 p->scb->cmd = CUC_START; /* cmd.-unit start */
637 elmc_id_attn586();
638
639 s = jiffies;
640 while (!(ias_cmd->cmd_status & STAT_COMPL)) {
641 if (jiffies - s > 30*HZ/100)
642 break;
643 }
644
645 if ((ias_cmd->cmd_status & (STAT_OK | STAT_COMPL)) != (STAT_OK | STAT_COMPL)) {
646 printk(KERN_WARNING "%s (elmc): individual address setup command failed: %04x\n", dev->name, ias_cmd->cmd_status);
647 return 1;
648 }
649 /*
650 * TDR, wire check .. e.g. no resistor e.t.c
651 */
652 tdr_cmd = (struct tdr_cmd_struct *) ptr;
653
654 tdr_cmd->cmd_status = 0;
655 tdr_cmd->cmd_cmd = CMD_TDR | CMD_LAST;
656 tdr_cmd->cmd_link = 0xffff;
657 tdr_cmd->status = 0;
658
659 p->scb->cbl_offset = make16(tdr_cmd);
660
661 p->scb->cmd = CUC_START; /* cmd.-unit start */
662 elmc_attn586();
663
664 s = jiffies;
665 while (!(tdr_cmd->cmd_status & STAT_COMPL)) {
666 if (jiffies - s > 30*HZ/100) {
667 printk(KERN_WARNING "%s: %d Problems while running the TDR.\n", dev->name, __LINE__);
668 result = 1;
669 break;
670 }
671 }
672
673 if (!result) {
674 DELAY(2); /* wait for result */
675 result = tdr_cmd->status;
676
677 p->scb->cmd = p->scb->status & STAT_MASK;
678 elmc_id_attn586(); /* ack the interrupts */
679
680 if (result & TDR_LNK_OK) {
681 /* empty */
682 } else if (result & TDR_XCVR_PRB) {
683 printk(KERN_WARNING "%s: TDR: Transceiver problem!\n", dev->name);
684 } else if (result & TDR_ET_OPN) {
685 printk(KERN_WARNING "%s: TDR: No correct termination %d clocks away.\n", dev->name, result & TDR_TIMEMASK);
686 } else if (result & TDR_ET_SRT) {
687 if (result & TDR_TIMEMASK) /* time == 0 -> strange :-) */
688 printk(KERN_WARNING "%s: TDR: Detected a short circuit %d clocks away.\n", dev->name, result & TDR_TIMEMASK);
689 } else {
690 printk(KERN_WARNING "%s: TDR: Unknown status %04x\n", dev->name, result);
691 }
692 }
693 /*
694 * ack interrupts
695 */
696 p->scb->cmd = p->scb->status & STAT_MASK;
697 elmc_id_attn586();
698
699 /*
700 * alloc nop/xmit-cmds
701 */
702 #if (NUM_XMIT_BUFFS == 1)
703 for (i = 0; i < 2; i++) {
704 p->nop_cmds[i] = (struct nop_cmd_struct *) ptr;
705 p->nop_cmds[i]->cmd_cmd = CMD_NOP;
706 p->nop_cmds[i]->cmd_status = 0;
707 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i]));
708 ptr = (char *) ptr + sizeof(struct nop_cmd_struct);
709 }
710 p->xmit_cmds[0] = (struct transmit_cmd_struct *) ptr; /* transmit cmd/buff 0 */
711 ptr = (char *) ptr + sizeof(struct transmit_cmd_struct);
712 #else
713 for (i = 0; i < NUM_XMIT_BUFFS; i++) {
714 p->nop_cmds[i] = (struct nop_cmd_struct *) ptr;
715 p->nop_cmds[i]->cmd_cmd = CMD_NOP;
716 p->nop_cmds[i]->cmd_status = 0;
717 p->nop_cmds[i]->cmd_link = make16((p->nop_cmds[i]));
718 ptr = (char *) ptr + sizeof(struct nop_cmd_struct);
719 p->xmit_cmds[i] = (struct transmit_cmd_struct *) ptr; /*transmit cmd/buff 0 */
720 ptr = (char *) ptr + sizeof(struct transmit_cmd_struct);
721 }
722 #endif
723
724 ptr = alloc_rfa(dev, (void *) ptr); /* init receive-frame-area */
725
726 /*
727 * Multicast setup
728 */
729
730 if (dev->mc_count) {
731 /* I don't understand this: do we really need memory after the init? */
732 int len = ((char *) p->iscp - (char *) ptr - 8) / 6;
733 if (len <= 0) {
734 printk(KERN_ERR "%s: Ooooops, no memory for MC-Setup!\n", dev->name);
735 } else {
736 if (len < num_addrs) {
737 num_addrs = len;
738 printk(KERN_WARNING "%s: Sorry, can only apply %d MC-Address(es).\n",
739 dev->name, num_addrs);
740 }
741 mc_cmd = (struct mcsetup_cmd_struct *) ptr;
742 mc_cmd->cmd_status = 0;
743 mc_cmd->cmd_cmd = CMD_MCSETUP | CMD_LAST;
744 mc_cmd->cmd_link = 0xffff;
745 mc_cmd->mc_cnt = num_addrs * 6;
746 for (i = 0; i < num_addrs; i++) {
747 memcpy((char *) mc_cmd->mc_list[i], dmi->dmi_addr, 6);
748 dmi = dmi->next;
749 }
750 p->scb->cbl_offset = make16(mc_cmd);
751 p->scb->cmd = CUC_START;
752 elmc_id_attn586();
753 s = jiffies;
754 while (!(mc_cmd->cmd_status & STAT_COMPL)) {
755 if (jiffies - s > 30*HZ/100)
756 break;
757 }
758 if (!(mc_cmd->cmd_status & STAT_COMPL)) {
759 printk(KERN_WARNING "%s: Can't apply multicast-address-list.\n", dev->name);
760 }
761 }
762 }
763 /*
764 * alloc xmit-buffs / init xmit_cmds
765 */
766 for (i = 0; i < NUM_XMIT_BUFFS; i++) {
767 p->xmit_cbuffs[i] = (char *) ptr; /* char-buffs */
768 ptr = (char *) ptr + XMIT_BUFF_SIZE;
769 p->xmit_buffs[i] = (struct tbd_struct *) ptr; /* TBD */
770 ptr = (char *) ptr + sizeof(struct tbd_struct);
771 if ((void *) ptr > (void *) p->iscp) {
772 printk(KERN_ERR "%s: not enough shared-mem for your configuration!\n", dev->name);
773 return 1;
774 }
775 memset((char *) (p->xmit_cmds[i]), 0, sizeof(struct transmit_cmd_struct));
776 memset((char *) (p->xmit_buffs[i]), 0, sizeof(struct tbd_struct));
777 p->xmit_cmds[i]->cmd_status = STAT_COMPL;
778 p->xmit_cmds[i]->cmd_cmd = CMD_XMIT | CMD_INT;
779 p->xmit_cmds[i]->tbd_offset = make16((p->xmit_buffs[i]));
780 p->xmit_buffs[i]->next = 0xffff;
781 p->xmit_buffs[i]->buffer = make24((p->xmit_cbuffs[i]));
782 }
783
784 p->xmit_count = 0;
785 p->xmit_last = 0;
786 #ifndef NO_NOPCOMMANDS
787 p->nop_point = 0;
788 #endif
789
790 /*
791 * 'start transmitter' (nop-loop)
792 */
793 #ifndef NO_NOPCOMMANDS
794 p->scb->cbl_offset = make16(p->nop_cmds[0]);
795 p->scb->cmd = CUC_START;
796 elmc_id_attn586();
797 WAIT_4_SCB_CMD();
798 #else
799 p->xmit_cmds[0]->cmd_link = 0xffff;
800 p->xmit_cmds[0]->cmd_cmd = CMD_XMIT | CMD_LAST | CMD_INT;
801 #endif
802
803 return 0;
804 }
805
806 /******************************************************
807 * This is a helper routine for elmc_rnr_int() and init586().
808 * It sets up the Receive Frame Area (RFA).
809 */
810
811 static void *alloc_rfa(struct net_device *dev, void *ptr)
812 {
813 volatile struct rfd_struct *rfd = (struct rfd_struct *) ptr;
814 volatile struct rbd_struct *rbd;
815 int i;
816 struct priv *p = (struct priv *) dev->priv;
817
818 memset((char *) rfd, 0, sizeof(struct rfd_struct) * p->num_recv_buffs);
819 p->rfd_first = rfd;
820
821 for (i = 0; i < p->num_recv_buffs; i++) {
822 rfd[i].next = make16(rfd + (i + 1) % p->num_recv_buffs);
823 }
824 rfd[p->num_recv_buffs - 1].last = RFD_SUSP; /* RU suspend */
825
826 ptr = (void *) (rfd + p->num_recv_buffs);
827
828 rbd = (struct rbd_struct *) ptr;
829 ptr = (void *) (rbd + p->num_recv_buffs);
830
831 /* clr descriptors */
832 memset((char *) rbd, 0, sizeof(struct rbd_struct) * p->num_recv_buffs);
833
834 for (i = 0; i < p->num_recv_buffs; i++) {
835 rbd[i].next = make16((rbd + (i + 1) % p->num_recv_buffs));
836 rbd[i].size = RECV_BUFF_SIZE;
837 rbd[i].buffer = make24(ptr);
838 ptr = (char *) ptr + RECV_BUFF_SIZE;
839 }
840
841 p->rfd_top = p->rfd_first;
842 p->rfd_last = p->rfd_first + p->num_recv_buffs - 1;
843
844 p->scb->rfa_offset = make16(p->rfd_first);
845 p->rfd_first->rbd_offset = make16(rbd);
846
847 return ptr;
848 }
849
850
851 /**************************************************
852 * Interrupt Handler ...
853 */
854
855 static void elmc_interrupt(int irq, void *dev_id, struct pt_regs *reg_ptr)
856 {
857 struct net_device *dev = (struct net_device *) dev_id;
858 unsigned short stat;
859 struct priv *p;
860
861 if (dev == NULL) {
862 printk(KERN_ERR "elmc-interrupt: irq %d for unknown device.\n", (int) -(((struct pt_regs *) reg_ptr)->orig_eax + 2));
863 return;
864 } else if (!netif_running(dev)) {
865 /* The 3c523 has this habit of generating interrupts during the
866 reset. I'm not sure if the ni52 has this same problem, but it's
867 really annoying if we haven't finished initializing it. I was
868 hoping all the elmc_id_* commands would disable this, but I
869 might have missed a few. */
870
871 elmc_id_attn586(); /* ack inter. and disable any more */
872 return;
873 } else if (!(ELMC_CTRL_INT & inb(dev->base_addr + ELMC_CTRL))) {
874 /* wasn't this device */
875 return;
876 }
877 /* reading ELMC_CTRL also clears the INT bit. */
878
879 p = (struct priv *) dev->priv;
880
881 while ((stat = p->scb->status & STAT_MASK))
882 {
883 p->scb->cmd = stat;
884 elmc_attn586(); /* ack inter. */
885
886 if (stat & STAT_CX) {
887 /* command with I-bit set complete */
888 elmc_xmt_int(dev);
889 }
890 if (stat & STAT_FR) {
891 /* received a frame */
892 elmc_rcv_int(dev);
893 }
894 #ifndef NO_NOPCOMMANDS
895 if (stat & STAT_CNA) {
896 /* CU went 'not ready' */
897 if (netif_running(dev)) {
898 printk(KERN_WARNING "%s: oops! CU has left active state. stat: %04x/%04x.\n", dev->name, (int) stat, (int) p->scb->status);
899 }
900 }
901 #endif
902
903 if (stat & STAT_RNR) {
904 /* RU went 'not ready' */
905
906 if (p->scb->status & RU_SUSPEND) {
907 /* special case: RU_SUSPEND */
908
909 WAIT_4_SCB_CMD();
910 p->scb->cmd = RUC_RESUME;
911 elmc_attn586();
912 } else {
913 printk(KERN_WARNING "%s: Receiver-Unit went 'NOT READY': %04x/%04x.\n", dev->name, (int) stat, (int) p->scb->status);
914 elmc_rnr_int(dev);
915 }
916 }
917 WAIT_4_SCB_CMD(); /* wait for ack. (elmc_xmt_int can be faster than ack!!) */
918 if (p->scb->cmd) { /* timed out? */
919 break;
920 }
921 }
922 }
923
924 /*******************************************************
925 * receive-interrupt
926 */
927
928 static void elmc_rcv_int(struct net_device *dev)
929 {
930 int status;
931 unsigned short totlen;
932 struct sk_buff *skb;
933 struct rbd_struct *rbd;
934 struct priv *p = (struct priv *) dev->priv;
935
936 for (; (status = p->rfd_top->status) & STAT_COMPL;) {
937 rbd = (struct rbd_struct *) make32(p->rfd_top->rbd_offset);
938
939 if (status & STAT_OK) { /* frame received without error? */
940 if ((totlen = rbd->status) & RBD_LAST) { /* the first and the last buffer? */
941 totlen &= RBD_MASK; /* length of this frame */
942 rbd->status = 0;
943 skb = (struct sk_buff *) dev_alloc_skb(totlen + 2);
944 if (skb != NULL) {
945 skb->dev = dev;
946 skb_reserve(skb, 2); /* 16 byte alignment */
947 memcpy(skb_put(skb, totlen), (u8 *)phys_to_virt(p->base) + (unsigned long) rbd->buffer, totlen);
948 skb->protocol = eth_type_trans(skb, dev);
949 netif_rx(skb);
950 p->stats.rx_packets++;
951 p->stats.rx_bytes += totlen;
952 } else {
953 p->stats.rx_dropped++;
954 }
955 } else {
956 printk(KERN_WARNING "%s: received oversized frame.\n", dev->name);
957 p->stats.rx_dropped++;
958 }
959 } else { /* frame !(ok), only with 'save-bad-frames' */
960 printk(KERN_WARNING "%s: oops! rfd-error-status: %04x\n", dev->name, status);
961 p->stats.rx_errors++;
962 }
963 p->rfd_top->status = 0;
964 p->rfd_top->last = RFD_SUSP;
965 p->rfd_last->last = 0; /* delete RU_SUSP */
966 p->rfd_last = p->rfd_top;
967 p->rfd_top = (struct rfd_struct *) make32(p->rfd_top->next); /* step to next RFD */
968 }
969 }
970
971 /**********************************************************
972 * handle 'Receiver went not ready'.
973 */
974
975 static void elmc_rnr_int(struct net_device *dev)
976 {
977 struct priv *p = (struct priv *) dev->priv;
978
979 p->stats.rx_errors++;
980
981 WAIT_4_SCB_CMD(); /* wait for the last cmd */
982 p->scb->cmd = RUC_ABORT; /* usually the RU is in the 'no resource'-state .. abort it now. */
983 elmc_attn586();
984 WAIT_4_SCB_CMD(); /* wait for accept cmd. */
985
986 alloc_rfa(dev, (char *) p->rfd_first);
987 startrecv586(dev); /* restart RU */
988
989 printk(KERN_WARNING "%s: Receive-Unit restarted. Status: %04x\n", dev->name, p->scb->status);
990
991 }
992
993 /**********************************************************
994 * handle xmit - interrupt
995 */
996
997 static void elmc_xmt_int(struct net_device *dev)
998 {
999 int status;
1000 struct priv *p = (struct priv *) dev->priv;
1001
1002 status = p->xmit_cmds[p->xmit_last]->cmd_status;
1003 if (!(status & STAT_COMPL)) {
1004 printk(KERN_WARNING "%s: strange .. xmit-int without a 'COMPLETE'\n", dev->name);
1005 }
1006 if (status & STAT_OK) {
1007 p->stats.tx_packets++;
1008 p->stats.collisions += (status & TCMD_MAXCOLLMASK);
1009 } else {
1010 p->stats.tx_errors++;
1011 if (status & TCMD_LATECOLL) {
1012 printk(KERN_WARNING "%s: late collision detected.\n", dev->name);
1013 p->stats.collisions++;
1014 } else if (status & TCMD_NOCARRIER) {
1015 p->stats.tx_carrier_errors++;
1016 printk(KERN_WARNING "%s: no carrier detected.\n", dev->name);
1017 } else if (status & TCMD_LOSTCTS) {
1018 printk(KERN_WARNING "%s: loss of CTS detected.\n", dev->name);
1019 } else if (status & TCMD_UNDERRUN) {
1020 p->stats.tx_fifo_errors++;
1021 printk(KERN_WARNING "%s: DMA underrun detected.\n", dev->name);
1022 } else if (status & TCMD_MAXCOLL) {
1023 printk(KERN_WARNING "%s: Max. collisions exceeded.\n", dev->name);
1024 p->stats.collisions += 16;
1025 }
1026 }
1027
1028 #if (NUM_XMIT_BUFFS != 1)
1029 if ((++p->xmit_last) == NUM_XMIT_BUFFS) {
1030 p->xmit_last = 0;
1031 }
1032 #endif
1033
1034 netif_wake_queue(dev);
1035 }
1036
1037 /***********************************************************
1038 * (re)start the receiver
1039 */
1040
1041 static void startrecv586(struct net_device *dev)
1042 {
1043 struct priv *p = (struct priv *) dev->priv;
1044
1045 p->scb->rfa_offset = make16(p->rfd_first);
1046 p->scb->cmd = RUC_START;
1047 elmc_attn586(); /* start cmd. */
1048 WAIT_4_SCB_CMD(); /* wait for accept cmd. (no timeout!!) */
1049 }
1050
1051 /******************************************************
1052 * timeout
1053 */
1054
1055 static void elmc_timeout(struct net_device *dev)
1056 {
1057 struct priv *p = (struct priv *) dev->priv;
1058 /* COMMAND-UNIT active? */
1059 if (p->scb->status & CU_ACTIVE) {
1060 #ifdef DEBUG
1061 printk("%s: strange ... timeout with CU active?!?\n", dev->name);
1062 printk("%s: X0: %04x N0: %04x N1: %04x %d\n", dev->name, (int) p->xmit_cmds[0]->cmd_status, (int) p->nop_cmds[0]->cmd_status, (int) p->nop_cmds[1]->cmd_status, (int) p->nop_point);
1063 #endif
1064 p->scb->cmd = CUC_ABORT;
1065 elmc_attn586();
1066 WAIT_4_SCB_CMD();
1067 p->scb->cbl_offset = make16(p->nop_cmds[p->nop_point]);
1068 p->scb->cmd = CUC_START;
1069 elmc_attn586();
1070 WAIT_4_SCB_CMD();
1071 netif_wake_queue(dev);
1072 } else {
1073 #ifdef DEBUG
1074 printk("%s: xmitter timed out, try to restart! stat: %04x\n", dev->name, p->scb->status);
1075 printk("%s: command-stats: %04x %04x\n", dev->name, p->xmit_cmds[0]->cmd_status, p->xmit_cmds[1]->cmd_status);
1076 #endif
1077 elmc_close(dev);
1078 elmc_open(dev);
1079 }
1080 }
1081
1082 /******************************************************
1083 * send frame
1084 */
1085
1086 static int elmc_send_packet(struct sk_buff *skb, struct net_device *dev)
1087 {
1088 int len;
1089 #ifndef NO_NOPCOMMANDS
1090 int next_nop;
1091 #endif
1092 struct priv *p = (struct priv *) dev->priv;
1093
1094 netif_stop_queue(dev);
1095
1096 memcpy((char *) p->xmit_cbuffs[p->xmit_count], (char *) (skb->data), skb->len);
1097 len = (ETH_ZLEN < skb->len) ? skb->len : ETH_ZLEN;
1098
1099 #if (NUM_XMIT_BUFFS == 1)
1100 #ifdef NO_NOPCOMMANDS
1101 p->xmit_buffs[0]->size = TBD_LAST | len;
1102 for (i = 0; i < 16; i++) {
1103 p->scb->cbl_offset = make16(p->xmit_cmds[0]);
1104 p->scb->cmd = CUC_START;
1105 p->xmit_cmds[0]->cmd_status = 0;
1106 elmc_attn586();
1107 dev->trans_start = jiffies;
1108 if (!i) {
1109 dev_kfree_skb(skb);
1110 }
1111 WAIT_4_SCB_CMD();
1112 if ((p->scb->status & CU_ACTIVE)) { /* test it, because CU sometimes doesn't start immediately */
1113 break;
1114 }
1115 if (p->xmit_cmds[0]->cmd_status) {
1116 break;
1117 }
1118 if (i == 15) {
1119 printk(KERN_WARNING "%s: Can't start transmit-command.\n", dev->name);
1120 }
1121 }
1122 #else
1123 next_nop = (p->nop_point + 1) & 0x1;
1124 p->xmit_buffs[0]->size = TBD_LAST | len;
1125
1126 p->xmit_cmds[0]->cmd_link = p->nop_cmds[next_nop]->cmd_link
1127 = make16((p->nop_cmds[next_nop]));
1128 p->xmit_cmds[0]->cmd_status = p->nop_cmds[next_nop]->cmd_status = 0;
1129
1130 p->nop_cmds[p->nop_point]->cmd_link = make16((p->xmit_cmds[0]));
1131 dev->trans_start = jiffies;
1132 p->nop_point = next_nop;
1133 dev_kfree_skb(skb);
1134 #endif
1135 #else
1136 p->xmit_buffs[p->xmit_count]->size = TBD_LAST | len;
1137 if ((next_nop = p->xmit_count + 1) == NUM_XMIT_BUFFS) {
1138 next_nop = 0;
1139 }
1140 p->xmit_cmds[p->xmit_count]->cmd_status = 0;
1141 p->xmit_cmds[p->xmit_count]->cmd_link = p->nop_cmds[next_nop]->cmd_link
1142 = make16((p->nop_cmds[next_nop]));
1143 p->nop_cmds[next_nop]->cmd_status = 0;
1144 p->nop_cmds[p->xmit_count]->cmd_link = make16((p->xmit_cmds[p->xmit_count]));
1145 dev->trans_start = jiffies;
1146 p->xmit_count = next_nop;
1147 if (p->xmit_count != p->xmit_last)
1148 netif_wake_queue(dev);
1149 dev_kfree_skb(skb);
1150 #endif
1151 return 0;
1152 }
1153
1154 /*******************************************
1155 * Someone wanna have the statistics
1156 */
1157
1158 static struct net_device_stats *elmc_get_stats(struct net_device *dev)
1159 {
1160 struct priv *p = (struct priv *) dev->priv;
1161 unsigned short crc, aln, rsc, ovrn;
1162
1163 crc = p->scb->crc_errs; /* get error-statistic from the ni82586 */
1164 p->scb->crc_errs -= crc;
1165 aln = p->scb->aln_errs;
1166 p->scb->aln_errs -= aln;
1167 rsc = p->scb->rsc_errs;
1168 p->scb->rsc_errs -= rsc;
1169 ovrn = p->scb->ovrn_errs;
1170 p->scb->ovrn_errs -= ovrn;
1171
1172 p->stats.rx_crc_errors += crc;
1173 p->stats.rx_fifo_errors += ovrn;
1174 p->stats.rx_frame_errors += aln;
1175 p->stats.rx_dropped += rsc;
1176
1177 return &p->stats;
1178 }
1179
1180 /********************************************************
1181 * Set MC list ..
1182 */
1183
1184 #ifdef ELMC_MULTICAST
1185 static void set_multicast_list(struct net_device *dev)
1186 {
1187 if (!dev->start) {
1188 /* without a running interface, promiscuous doesn't work */
1189 return;
1190 }
1191 dev->start = 0;
1192 alloc586(dev);
1193 init586(dev);
1194 startrecv586(dev);
1195 dev->start = 1;
1196 }
1197 #endif
1198
1199 /*************************************************************************/
1200
1201 #ifdef MODULE
1202
1203 /* Increase if needed ;) */
1204 #define MAX_3C523_CARDS 4
1205
1206 static struct net_device dev_elmc[MAX_3C523_CARDS];
1207 static int irq[MAX_3C523_CARDS];
1208 static int io[MAX_3C523_CARDS];
1209 MODULE_PARM(irq, "1-" __MODULE_STRING(MAX_3C523_CARDS) "i");
1210 MODULE_PARM(io, "1-" __MODULE_STRING(MAX_3C523_CARDS) "i");
1211
1212 int init_module(void)
1213 {
1214 int this_dev,found = 0;
1215
1216 /* Loop until we either can't find any more cards, or we have MAX_3C523_CARDS */
1217 for(this_dev=0; this_dev<MAX_3C523_CARDS; this_dev++)
1218 {
1219 struct net_device *dev = &dev_elmc[this_dev];
1220 dev->irq=irq[this_dev];
1221 dev->base_addr=io[this_dev];
1222 dev->init=elmc_probe;
1223 if(register_netdev(dev)!=0) {
1224 if(io[this_dev]==0) break;
1225 printk(KERN_WARNING "3c523.c: No 3c523 card found at io=%#x\n",io[this_dev]);
1226 } else found++;
1227 }
1228
1229 if(found==0) {
1230 if(io[0]==0) printk(KERN_NOTICE "3c523.c: No 3c523 cards found\n");
1231 return -ENXIO;
1232 } else return 0;
1233 }
1234
1235 void cleanup_module(void)
1236 {
1237 int this_dev;
1238 for(this_dev=0; this_dev<MAX_3C523_CARDS; this_dev++) {
1239
1240 struct net_device *dev = &dev_elmc[this_dev];
1241 if(dev->priv) {
1242 /* shutdown interrupts on the card */
1243 elmc_id_reset586();
1244 if (dev->irq != 0) {
1245 /* this should be done by close, but if we failed to
1246 initialize properly something may have gotten hosed. */
1247 free_irq(dev->irq, dev);
1248 dev->irq = 0;
1249 }
1250 if (dev->base_addr != 0) {
1251 release_region(dev->base_addr, ELMC_IO_EXTENT);
1252 dev->base_addr = 0;
1253 }
1254 irq[this_dev] = 0;
1255 io[this_dev] = 0;
1256 unregister_netdev(dev);
1257
1258 mca_set_adapter_procfn(((struct priv *) (dev->priv))->slot,
1259 NULL, NULL);
1260
1261 kfree(dev->priv);
1262 dev->priv = NULL;
1263 }
1264 }
1265 }
1266
1267 #endif /* MODULE */
1268
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.