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