← Back to branch summary

~ubuntu-branches/ubuntu/precise/linux-lowlatency/precise

« back to all changes in this revision

Viewing changes to drivers/net/ethernet/i825xx/3c523.c

  • Committer: Package Import Robot
  • Author(s): Alessio Igor Bogani
  • Date: 2011-10-26 11:13:05 UTC
  • Revision ID: package-import@ubuntu.com-20111026111305-tz023xykf0i6eosh
Tags: upstream-3.2.0
Import upstream version 3.2.0

Show diffs side-by-side

added added

removed removed

Lines of Context:
drivers/net/ethernet/i825xx/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_rx_mode        = 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 */