v2.4.8 -> v2.4.8.1
[opensuse:kernel.git] / drivers / net / depca.c
1 /*  depca.c: A DIGITAL DEPCA  & EtherWORKS ethernet driver for linux.
2
3     Written 1994, 1995 by David C. Davies.
4
5
6                       Copyright 1994 David C. Davies
7                                    and 
8                          United States Government
9          (as represented by the Director, National Security Agency).  
10
11                Copyright 1995  Digital Equipment Corporation.
12
13
14     This software may be used and distributed according to the terms of
15     the GNU General Public License, incorporated herein by reference.
16
17     This driver is written for the Digital Equipment Corporation series
18     of DEPCA and EtherWORKS ethernet cards:
19
20         DEPCA       (the original)
21         DE100
22         DE101
23         DE200 Turbo
24         DE201 Turbo
25         DE202 Turbo (TP BNC)
26         DE210
27         DE422       (EISA)
28
29     The  driver has been tested on DE100, DE200 and DE202 cards  in  a
30     relatively busy network. The DE422 has been tested a little.
31
32     This  driver will NOT work   for the DE203,  DE204  and DE205 series  of
33     cards,  since they have  a  new custom ASIC in   place of the AMD  LANCE
34     chip.  See the 'ewrk3.c'   driver in the  Linux  source tree for running
35     those cards.
36
37     I have benchmarked the driver with a  DE100 at 595kB/s to (542kB/s from)
38     a DECstation 5000/200.
39
40     The author may be reached at davies@maniac.ultranet.com
41
42     =========================================================================
43
44     The  driver was originally based  on   the 'lance.c' driver from  Donald
45     Becker   which  is included with  the  standard  driver distribution for
46     linux.  V0.4  is  a complete  re-write  with only  the kernel  interface
47     remaining from the original code.
48
49     1) Lance.c code in /linux/drivers/net/
50     2) "Ethernet/IEEE 802.3 Family. 1992 World Network Data Book/Handbook",
51        AMD, 1992 [(800) 222-9323].
52     3) "Am79C90 CMOS Local Area Network Controller for Ethernet (C-LANCE)",
53        AMD, Pub. #17881, May 1993.
54     4) "Am79C960 PCnet-ISA(tm), Single-Chip Ethernet Controller for ISA",
55        AMD, Pub. #16907, May 1992
56     5) "DEC EtherWORKS LC Ethernet Controller Owners Manual",
57        Digital Equipment corporation, 1990, Pub. #EK-DE100-OM.003
58     6) "DEC EtherWORKS Turbo Ethernet Controller Owners Manual",
59        Digital Equipment corporation, 1990, Pub. #EK-DE200-OM.003
60     7) "DEPCA Hardware Reference Manual", Pub. #EK-DEPCA-PR
61        Digital Equipment Corporation, 1989
62     8) "DEC EtherWORKS Turbo_(TP BNC) Ethernet Controller Owners Manual",
63        Digital Equipment corporation, 1991, Pub. #EK-DE202-OM.001
64     
65
66     Peter Bauer's depca.c (V0.5) was referred to when debugging V0.1 of this
67     driver.
68
69     The original DEPCA  card requires that the  ethernet ROM address counter
70     be enabled to count and has an 8 bit NICSR.  The ROM counter enabling is
71     only  done when a  0x08 is read as the  first address octet (to minimise
72     the chances  of writing over some  other hardware's  I/O register).  The
73     NICSR accesses   have been changed  to  byte accesses  for all the cards
74     supported by this driver, since there is only one  useful bit in the MSB
75     (remote boot timeout) and it  is not used.  Also, there  is a maximum of
76     only 48kB network  RAM for this  card.  My thanks  to Torbjorn Lindh for
77     help debugging all this (and holding my feet to  the fire until I got it
78     right).
79
80     The DE200  series  boards have  on-board 64kB  RAM for  use  as a shared
81     memory network  buffer. Only the DE100  cards make use  of a  2kB buffer
82     mode which has not  been implemented in  this driver (only the 32kB  and
83     64kB modes are supported [16kB/48kB for the original DEPCA]).
84
85     At the most only 2 DEPCA cards can  be supported on  the ISA bus because
86     there is only provision  for two I/O base addresses  on each card (0x300
87     and 0x200). The I/O address is detected by searching for a byte sequence
88     in the Ethernet station address PROM at the expected I/O address for the
89     Ethernet  PROM.   The shared memory  base   address  is 'autoprobed'  by
90     looking  for the self  test PROM  and detecting the  card name.   When a
91     second  DEPCA is  detected,  information  is   placed in the   base_addr
92     variable of the  next device structure (which  is created if necessary),
93     thus  enabling ethif_probe  initialization  for the device.  More than 2
94     EISA cards can  be  supported, but  care will  be  needed assigning  the
95     shared memory to ensure that each slot has the  correct IRQ, I/O address
96     and shared memory address assigned.
97
98     ************************************************************************
99
100     NOTE: If you are using two  ISA DEPCAs, it is  important that you assign
101     the base memory addresses correctly.   The  driver autoprobes I/O  0x300
102     then 0x200.  The  base memory address for  the first device must be less
103     than that of the second so that the auto probe will correctly assign the
104     I/O and memory addresses on the same card.  I can't think of a way to do
105     this unambiguously at the moment, since there is nothing on the cards to
106     tie I/O and memory information together.
107
108     I am unable  to  test  2 cards   together for now,    so this  code   is
109     unchecked. All reports, good or bad, are welcome.
110
111     ************************************************************************
112
113     The board IRQ   setting must be  at an  unused IRQ which  is auto-probed
114     using Donald Becker's autoprobe routines. DEPCA and DE100 board IRQs are
115     {2,3,4,5,7}, whereas the  DE200 is at {5,9,10,11,15}.  Note that IRQ2 is
116     really IRQ9 in machines with 16 IRQ lines.
117
118     No 16MB memory  limitation should exist with this  driver as DMA is  not
119     used and the common memory area is in low memory on the network card (my
120     current system has 20MB and I've not had problems yet).
121
122     The ability to load this driver as a loadable module has been added. To
123     utilise this ability, you have to do <8 things:
124
125     0) have a copy of the loadable modules code installed on your system.
126     1) copy depca.c from the  /linux/drivers/net directory to your favourite
127     temporary directory.
128     2) if you wish, edit the  source code near  line 1530 to reflect the I/O
129     address and IRQ you're using (see also 5).
130     3) compile  depca.c, but include -DMODULE in  the command line to ensure
131     that the correct bits are compiled (see end of source code).
132     4) if you are wanting to add a new  card, goto 5. Otherwise, recompile a
133     kernel with the depca configuration turned off and reboot.
134     5) insmod depca.o [irq=7] [io=0x200] [mem=0xd0000] [adapter_name=DE100]
135        [Alan Cox: Changed the code to allow command line irq/io assignments]
136        [Dave Davies: Changed the code to allow command line mem/name
137                                                                 assignments]
138     6) run the net startup bits for your eth?? interface manually 
139     (usually /etc/rc.inet[12] at boot time). 
140     7) enjoy!
141
142     Note that autoprobing is not allowed in loadable modules - the system is
143     already up and running and you're messing with interrupts.
144
145     To unload a module, turn off the associated interface 
146     'ifconfig eth?? down' then 'rmmod depca'.
147
148     To assign a base memory address for the shared memory  when running as a
149     loadable module, see 5 above.  To include the adapter  name (if you have
150     no PROM  but know the card name)  also see 5  above. Note that this last
151     option  will not work  with kernel  built-in  depca's. 
152
153     The shared memory assignment for a loadable module  makes sense to avoid
154     the 'memory autoprobe' picking the wrong shared memory  (for the case of
155     2 depca's in a PC).
156
157     ************************************************************************
158     Support for MCA EtherWORKS cards added 11-3-98.
159     Verified to work with up to 2 DE212 cards in a system (although not
160       fully stress-tested).  
161
162     Currently known bugs/limitations:
163
164     Note:  with the MCA stuff as a module, it trusts the MCA configuration,
165            not the command line for IRQ and memory address.  You can
166            specify them if you want, but it will throw your values out.
167            You still have to pass the IO address it was configured as
168            though.
169
170     ************************************************************************
171     TO DO:
172     ------
173
174
175     Revision History
176     ----------------
177
178     Version   Date        Description
179   
180       0.1     25-jan-94   Initial writing.
181       0.2     27-jan-94   Added LANCE TX hardware buffer chaining.
182       0.3      1-feb-94   Added multiple DEPCA support.
183       0.31     4-feb-94   Added DE202 recognition.
184       0.32    19-feb-94   Tidy up. Improve multi-DEPCA support.
185       0.33    25-feb-94   Fix DEPCA ethernet ROM counter enable.
186                           Add jabber packet fix from murf@perftech.com
187                           and becker@super.org
188       0.34     7-mar-94   Fix DEPCA max network memory RAM & NICSR access.
189       0.35     8-mar-94   Added DE201 recognition. Tidied up.
190       0.351   30-apr-94   Added EISA support. Added DE422 recognition.
191       0.36    16-may-94   DE422 fix released.
192       0.37    22-jul-94   Added MODULE support
193       0.38    15-aug-94   Added DBR ROM switch in depca_close(). 
194                           Multi DEPCA bug fix.
195       0.38axp 15-sep-94   Special version for Alpha AXP Linux V1.0.
196       0.381   12-dec-94   Added DE101 recognition, fix multicast bug.
197       0.382    9-feb-95   Fix recognition bug reported by <bkm@star.rl.ac.uk>.
198       0.383   22-feb-95   Fix for conflict with VESA SCSI reported by
199                           <stromain@alf.dec.com>
200       0.384   17-mar-95   Fix a ring full bug reported by <bkm@star.rl.ac.uk>
201       0.385    3-apr-95   Fix a recognition bug reported by 
202                                                 <ryan.niemi@lastfrontier.com>
203       0.386   21-apr-95   Fix the last fix...sorry, must be galloping senility
204       0.40    25-May-95   Rewrite for portability & updated.
205                           ALPHA support from <jestabro@amt.tay1.dec.com>
206       0.41    26-Jun-95   Added verify_area() calls in depca_ioctl() from
207                           suggestion by <heiko@colossus.escape.de>
208       0.42    27-Dec-95   Add 'mem' shared memory assignment for loadable 
209                           modules.
210                           Add 'adapter_name' for loadable modules when no PROM.
211                           Both above from a suggestion by 
212                           <pchen@woodruffs121.residence.gatech.edu>.
213                           Add new multicasting code.
214       0.421   22-Apr-96   Fix alloc_device() bug <jari@markkus2.fimr.fi>
215       0.422   29-Apr-96   Fix depca_hw_init() bug <jari@markkus2.fimr.fi>
216       0.423    7-Jun-96   Fix module load bug <kmg@barco.be>
217       0.43    16-Aug-96   Update alloc_device() to conform to de4x5.c
218       0.44     1-Sep-97   Fix *_probe() to test check_region() first - bug
219                            reported by <mmogilvi@elbert.uccs.edu>
220       0.45     3-Nov-98   Added support for MCA EtherWORKS (DE210/DE212) cards
221                            by <tymm@computer.org> 
222       0.451    5-Nov-98   Fixed mca stuff cuz I'm a dummy. <tymm@computer.org>
223       0.5     14-Nov-98   Re-spin for 2.1.x kernels.
224       0.51    27-Jun-99   Correct received packet length for CRC from
225                            report by <worm@dkik.dk>
226       0.52    16-Oct-00   Fixes for 2.3 io memory accesses
227                           Fix show-stopper (ints left masked) in depca_interrupt
228                            by <peterd@pnd-pc.demon.co.uk>
229       0.53    12-Jan-01   Release resources on failure, bss tidbits
230                            by acme@conectiva.com.br
231
232     =========================================================================
233 */
234
235 #include <linux/config.h>
236 #include <linux/module.h>
237
238 #include <linux/kernel.h>
239 #include <linux/sched.h>
240 #include <linux/string.h>
241 #include <linux/ptrace.h>
242 #include <linux/errno.h>
243 #include <linux/ioport.h>
244 #include <linux/slab.h>
245 #include <linux/interrupt.h>
246 #include <linux/delay.h>
247 #include <linux/init.h>
248 #include <asm/uaccess.h>
249 #include <asm/bitops.h>
250 #include <asm/io.h>
251 #include <asm/dma.h>
252
253 #include <linux/netdevice.h>
254 #include <linux/etherdevice.h>
255 #include <linux/skbuff.h>
256
257 #include <linux/time.h>
258 #include <linux/types.h>
259 #include <linux/unistd.h>
260 #include <linux/ctype.h>
261
262 #ifdef CONFIG_MCA
263 #include <linux/mca.h>
264 #endif
265
266 #include "depca.h"
267
268 static char version[] __initdata =
269         "depca.c:v0.53 2001/1/12 davies@maniac.ultranet.com\n";
270
271 #ifdef DEPCA_DEBUG
272 static int depca_debug = DEPCA_DEBUG;
273 #else
274 static int depca_debug = 1;
275 #endif
276
277 #define DEPCA_NDA 0xffe0            /* No Device Address */
278
279 #define TX_TIMEOUT (1*HZ)
280
281 /*
282 ** Ethernet PROM defines
283 */
284 #define PROBE_LENGTH    32
285 #define ETH_PROM_SIG    0xAA5500FFUL
286
287 /*
288 ** Set the number of Tx and Rx buffers. Ensure that the memory requested
289 ** here is <= to the amount of shared memory set up by the board switches.
290 ** The number of descriptors MUST BE A POWER OF 2.
291 **
292 ** total_memory = NUM_RX_DESC*(8+RX_BUFF_SZ) + NUM_TX_DESC*(8+TX_BUFF_SZ)
293 */
294 #define NUM_RX_DESC     8               /* Number of RX descriptors */
295 #define NUM_TX_DESC     8               /* Number of TX descriptors */
296 #define RX_BUFF_SZ      1536            /* Buffer size for each Rx buffer */
297 #define TX_BUFF_SZ      1536            /* Buffer size for each Tx buffer */
298
299 #define CRC_POLYNOMIAL_BE 0x04c11db7UL  /* Ethernet CRC, big endian */
300 #define CRC_POLYNOMIAL_LE 0xedb88320UL  /* Ethernet CRC, little endian */
301
302 /*
303 ** EISA bus defines
304 */
305 #define DEPCA_EISA_IO_PORTS 0x0c00       /* I/O port base address, slot 0 */
306 #define MAX_EISA_SLOTS 16
307 #define EISA_SLOT_INC 0x1000
308
309 /*
310 ** ISA Bus defines
311 */
312 #define DEPCA_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0xe0000,0x00000}
313 #define DEPCA_IO_PORTS {0x300, 0x200, 0}
314 #define DEPCA_TOTAL_SIZE 0x10
315 static short mem_chkd;
316
317 /*
318 ** Adapter ID for the MCA EtherWORKS DE210/212 adapter
319 */
320 #define DE212_ID 0x6def
321
322 /*
323 ** Name <-> Adapter mapping
324 */
325 #define DEPCA_SIGNATURE {"DEPCA",\
326                          "DE100","DE101",\
327                          "DE200","DE201","DE202",\
328                          "DE210","DE212",\
329                          "DE422",\
330                          ""}
331 static enum {
332   DEPCA, de100, de101, de200, de201, de202, de210, de212, de422, unknown
333 } adapter;
334
335 /*
336 ** Miscellaneous info...
337 */
338 #define DEPCA_STRLEN 16
339 #define MAX_NUM_DEPCAS 2
340
341 /*
342 ** Memory Alignment. Each descriptor is 4 longwords long. To force a
343 ** particular alignment on the TX descriptor, adjust DESC_SKIP_LEN and
344 ** DESC_ALIGN. ALIGN aligns the start address of the private memory area
345 ** and hence the RX descriptor ring's first entry. 
346 */
347 #define ALIGN4      ((u_long)4 - 1)       /* 1 longword align */
348 #define ALIGN8      ((u_long)8 - 1)       /* 2 longword (quadword) align */
349 #define ALIGN         ALIGN8              /* Keep the LANCE happy... */
350
351 /*
352 ** The DEPCA Rx and Tx ring descriptors. 
353 */
354 struct depca_rx_desc {
355     volatile s32 base;
356     s16 buf_length;             /* This length is negative 2's complement! */
357     s16 msg_length;             /* This length is "normal". */
358 };
359
360 struct depca_tx_desc {
361     volatile s32 base;
362     s16 length;                 /* This length is negative 2's complement! */
363     s16 misc;                   /* Errors and TDR info */
364 };
365
366 #define LA_MASK 0x0000ffff      /* LANCE address mask for mapping network RAM
367                                    to LANCE memory address space */
368
369 /*
370 ** The Lance initialization block, described in databook, in common memory.
371 */
372 struct depca_init {
373     u16 mode;                   /* Mode register */
374     u8  phys_addr[ETH_ALEN];    /* Physical ethernet address */
375     u8  mcast_table[8];         /* Multicast Hash Table. */
376     u32 rx_ring;                /* Rx ring base pointer & ring length */
377     u32 tx_ring;                /* Tx ring base pointer & ring length */
378 };
379
380 #define DEPCA_PKT_STAT_SZ 16
381 #define DEPCA_PKT_BIN_SZ  128                /* Should be >=100 unless you
382                                                 increase DEPCA_PKT_STAT_SZ */
383 struct depca_private {
384     char devname[DEPCA_STRLEN];    /* Device Product String                  */
385     char adapter_name[DEPCA_STRLEN];/* /proc/ioports string                  */
386     char adapter;                  /* Adapter type                           */
387     char mca_slot;                 /* MCA slot, if MCA else -1               */
388     struct depca_init   init_block;/* Shadow Initialization block            */
389 /* CPU address space fields */
390     struct depca_rx_desc *rx_ring; /* Pointer to start of RX descriptor ring */
391     struct depca_tx_desc *tx_ring; /* Pointer to start of TX descriptor ring */
392     void *rx_buff[NUM_RX_DESC];    /* CPU virt address of sh'd memory buffs  */
393     void *tx_buff[NUM_TX_DESC];    /* CPU virt address of sh'd memory buffs  */
394     void *sh_mem;                  /* CPU mapped virt address of device RAM  */
395 /* Device address space fields */
396     u_long device_ram_start;       /* Start of RAM in device addr space      */
397 /* Offsets used in both address spaces */
398     u_long rx_ring_offset;         /* Offset from start of RAM to rx_ring    */
399     u_long tx_ring_offset;         /* Offset from start of RAM to tx_ring    */
400     u_long buffs_offset;           /* LANCE Rx and Tx buffers start address. */
401 /* Kernel-only (not device) fields */
402     int rx_new, tx_new;            /* The next free ring entry               */
403     int rx_old, tx_old;            /* The ring entries to be free()ed.       */
404     struct net_device_stats stats;
405     spinlock_t lock;
406     struct {                       /* Private stats counters                 */
407         u32 bins[DEPCA_PKT_STAT_SZ];
408         u32 unicast;
409         u32 multicast;
410         u32 broadcast;
411         u32 excessive_collisions;
412         u32 tx_underruns;
413         u32 excessive_underruns;
414     } pktStats;
415     int txRingMask;                /* TX ring mask                           */
416     int rxRingMask;                /* RX ring mask                           */
417     s32 rx_rlen;                   /* log2(rxRingMask+1) for the descriptors */
418     s32 tx_rlen;                   /* log2(txRingMask+1) for the descriptors */
419 };
420
421 /*
422 ** The transmit ring full condition is described by the tx_old and tx_new
423 ** pointers by:
424 **    tx_old            = tx_new    Empty ring
425 **    tx_old            = tx_new+1  Full ring
426 **    tx_old+txRingMask = tx_new    Full ring  (wrapped condition)
427 */
428 #define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
429                          lp->tx_old+lp->txRingMask-lp->tx_new:\
430                          lp->tx_old               -lp->tx_new-1)
431
432 /*
433 ** Public Functions
434 */
435 static int    depca_open(struct net_device *dev);
436 static int    depca_start_xmit(struct sk_buff *skb, struct net_device *dev);
437 static void   depca_interrupt(int irq, void *dev_id, struct pt_regs *regs);
438 static int    depca_close(struct net_device *dev);
439 static int    depca_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
440 static void   depca_tx_timeout (struct net_device *dev);
441 static struct net_device_stats *depca_get_stats(struct net_device *dev);
442 static void   set_multicast_list(struct net_device *dev);
443
444 /*
445 ** Private functions
446 */
447 static int    depca_hw_init(struct net_device *dev, u_long ioaddr, int mca_slot);
448 static void   depca_init_ring(struct net_device *dev);
449 static int    depca_rx(struct net_device *dev);
450 static int    depca_tx(struct net_device *dev);
451
452 static void   LoadCSRs(struct net_device *dev);
453 static int    InitRestartDepca(struct net_device *dev);
454 static void   DepcaSignature(char *name, u_long paddr);
455 static int    DevicePresent(u_long ioaddr);
456 static int    get_hw_addr(struct net_device *dev);
457 static int    EISA_signature(char *name, s32 eisa_id);
458 static void   SetMulticastFilter(struct net_device *dev);
459 static void   isa_probe(struct net_device *dev, u_long iobase);
460 static void   eisa_probe(struct net_device *dev, u_long iobase);
461 #ifdef CONFIG_MCA      
462 static void   mca_probe(struct net_device *dev, u_long iobase);
463 #endif
464 static struct net_device *alloc_device(struct net_device *dev, u_long iobase);
465 static int    depca_dev_index(char *s);
466 static struct net_device *insert_device(struct net_device *dev, u_long iobase, int (*init)(struct net_device *));
467 static int    load_packet(struct net_device *dev, struct sk_buff *skb);
468 static void   depca_dbg_open(struct net_device *dev);
469
470 #ifdef MODULE
471 int           init_module(void);
472 void          cleanup_module(void);
473 static int    autoprobed = 1, loading_module = 1;
474 # else
475 static u_char de1xx_irq[] __initdata = {2,3,4,5,7,9,0};
476 static u_char de2xx_irq[] __initdata = {5,9,10,11,15,0};
477 static u_char de422_irq[] __initdata = {5,9,10,11,0};
478 static u_char *depca_irq;
479 static int    autoprobed, loading_module;
480 #endif /* MODULE */
481
482 static char   name[DEPCA_STRLEN];
483 static int    num_depcas, num_eth;
484 static int    mem;                       /* For loadable module assignment
485                                               use insmod mem=0x????? .... */
486 static char   *adapter_name; /* = '\0';     If no PROM when loadable module
487                                               use insmod adapter_name=DE??? ...
488                                               bss initializes this to zero
489                                            */
490 /*
491 ** Miscellaneous defines...
492 */
493 #define STOP_DEPCA \
494     outw(CSR0, DEPCA_ADDR);\
495     outw(STOP, DEPCA_DATA)
496
497 int __init 
498 depca_probe(struct net_device *dev)
499 {
500   int tmp = num_depcas, status = -ENODEV;
501   u_long iobase = dev->base_addr;
502
503   SET_MODULE_OWNER(dev);
504
505   if ((iobase == 0) && loading_module){
506     printk("Autoprobing is not supported when loading a module based driver.\n");
507     status = -EIO;
508   } else {
509 #ifdef CONFIG_MCA      
510     mca_probe(dev, iobase);
511 #endif
512     isa_probe(dev, iobase);
513     eisa_probe(dev, iobase);
514
515     if ((tmp == num_depcas) && (iobase != 0) && loading_module) {
516       printk("%s: depca_probe() cannot find device at 0x%04lx.\n", dev->name, 
517                                                                        iobase);
518     }
519
520     /*
521     ** Walk the device list to check that at least one device
522     ** initialised OK
523     */
524     for (; (dev->priv == NULL) && (dev->next != NULL); dev = dev->next);
525
526     if (dev->priv) status = 0;
527     if (iobase == 0) autoprobed = 1;
528   }
529
530   return status;
531 }
532
533 static int __init 
534 depca_hw_init(struct net_device *dev, u_long ioaddr, int mca_slot)
535 {
536         struct depca_private *lp;
537         int i, j, offset, netRAM, mem_len, status=0;
538         s16 nicsr;
539         u_long mem_start=0, mem_base[] = DEPCA_RAM_BASE_ADDRESSES;
540
541         STOP_DEPCA;
542
543         nicsr = inb(DEPCA_NICSR);
544         nicsr = ((nicsr & ~SHE & ~RBE & ~IEN) | IM);
545         outb(nicsr, DEPCA_NICSR);
546
547         if (inw(DEPCA_DATA) != STOP) {
548                 return -ENXIO;
549         }
550
551         do {
552                 strcpy(name, (adapter_name ? adapter_name : ""));
553                 mem_start = (mem ? mem & 0xf0000 : mem_base[mem_chkd++]);
554                 DepcaSignature(name, mem_start);
555         } while (!mem && mem_base[mem_chkd] && (adapter == unknown));
556
557         if ((adapter == unknown) || !mem_start) { /* DEPCA device not found */
558                 return -ENXIO;
559         }
560
561         dev->base_addr = ioaddr;
562
563         if (mca_slot != -1) {
564                 printk("%s: %s at 0x%04lx (MCA slot %d)", dev->name, name, 
565                                                           ioaddr, mca_slot);
566         } else if ((ioaddr & 0x0fff) == DEPCA_EISA_IO_PORTS) { /* EISA slot address */
567                 printk("%s: %s at 0x%04lx (EISA slot %d)", 
568                        dev->name, name, ioaddr, (int)((ioaddr>>12)&0x0f));
569         } else {                             /* ISA port address */
570                 printk("%s: %s at 0x%04lx", dev->name, name, ioaddr);
571         }
572
573         printk(", h/w address ");
574         status = get_hw_addr(dev);
575         if (status != 0) {
576                 printk("      which has an Ethernet PROM CRC error.\n");
577                 return -ENXIO;
578         }
579         for (i=0; i<ETH_ALEN - 1; i++) { /* get the ethernet address */
580                 printk("%2.2x:", dev->dev_addr[i]);
581         }
582         printk("%2.2x", dev->dev_addr[i]);
583
584         /* Set up the maximum amount of network RAM(kB) */
585         netRAM = ((adapter != DEPCA) ? 64 : 48);
586         if ((nicsr & _128KB) && (adapter == de422))
587                 netRAM = 128;
588         offset = 0x0000;
589
590         /* Shared Memory Base Address */ 
591         if (nicsr & BUF) {
592                 offset = 0x8000;        /* 32kbyte RAM offset*/
593                 nicsr &= ~BS;           /* DEPCA RAM in top 32k */
594                 netRAM -= 32;
595         }
596         mem_start += offset;            /* (E)ISA start address */
597         if ((mem_len = (NUM_RX_DESC*(sizeof(struct depca_rx_desc)+RX_BUFF_SZ) +
598                         NUM_TX_DESC*(sizeof(struct depca_tx_desc)+TX_BUFF_SZ) +
599                         sizeof(struct depca_init)))
600             > (netRAM<<10)) {
601                 printk(",\n       requests %dkB RAM: only %dkB is available!\n",
602                         (mem_len >> 10), netRAM);
603                 return -ENXIO;
604         }
605
606         printk(",\n      has %dkB RAM at 0x%.5lx", netRAM, mem_start);
607
608         /* Enable the shadow RAM. */
609         if (adapter != DEPCA) {
610                 nicsr |= SHE;
611                 outb(nicsr, DEPCA_NICSR);
612         }
613  
614         /* Define the device private memory */
615         dev->priv = (void *) kmalloc(sizeof(struct depca_private), GFP_KERNEL);
616         if (dev->priv == NULL)
617                 return -ENOMEM;
618         lp = (struct depca_private *)dev->priv;
619         memset((char *)dev->priv, 0, sizeof(struct depca_private));
620         lp->adapter = adapter;
621         lp->mca_slot = mca_slot;
622         lp->lock = SPIN_LOCK_UNLOCKED;
623         sprintf(lp->adapter_name,"%s (%s)", name, dev->name);
624         status = -EBUSY;
625         if (!request_region(ioaddr, DEPCA_TOTAL_SIZE, lp->adapter_name)) {
626                 printk(KERN_ERR "depca: I/O resource 0x%x @ 0x%lx busy\n",
627                        DEPCA_TOTAL_SIZE, ioaddr);
628                 goto out_priv;
629         }
630
631         /* Initialisation Block */
632         lp->sh_mem = ioremap(mem_start, mem_len);
633         status = -EIO;
634         if (lp->sh_mem == NULL) {
635                 printk(KERN_ERR "depca: cannot remap ISA memory, aborting\n");
636                 goto out_region;
637         }
638         lp->device_ram_start = mem_start & LA_MASK;
639         
640         offset = 0;
641         offset += sizeof(struct depca_init);
642
643         /* Tx & Rx descriptors (aligned to a quadword boundary) */
644         offset = (offset + ALIGN) & ~ALIGN;
645         lp->rx_ring = (struct depca_rx_desc *)(lp->sh_mem + offset);
646         lp->rx_ring_offset = offset;
647
648         offset += (sizeof(struct depca_rx_desc) * NUM_RX_DESC);
649         lp->tx_ring = (struct depca_tx_desc *)(lp->sh_mem + offset);
650         lp->tx_ring_offset = offset;
651
652         offset += (sizeof(struct depca_tx_desc) * NUM_TX_DESC);
653
654         lp->buffs_offset = offset;
655
656         /* Finish initialising the ring information. */
657         lp->rxRingMask = NUM_RX_DESC - 1;
658         lp->txRingMask = NUM_TX_DESC - 1;
659
660         /* Calculate Tx/Rx RLEN size for the descriptors. */
661         for (i=0, j = lp->rxRingMask; j>0; i++) {
662                 j >>= 1;
663         }
664         lp->rx_rlen = (s32)(i << 29);
665         for (i=0, j = lp->txRingMask; j>0; i++) {
666                 j >>= 1;
667         }
668         lp->tx_rlen = (s32)(i << 29);
669
670         /* Load the initialisation block */
671         depca_init_ring(dev);
672
673         /* Initialise the control and status registers */
674         LoadCSRs(dev);
675
676         /* Enable DEPCA board interrupts for autoprobing */
677         nicsr = ((nicsr & ~IM)|IEN);
678         outb(nicsr, DEPCA_NICSR);
679
680         /* To auto-IRQ we enable the initialization-done and DMA err,
681            interrupts. For now we will always get a DMA error. */
682         if (dev->irq < 2) {
683 #ifndef MODULE
684                 unsigned char irqnum;
685                 autoirq_setup(0);
686
687                 /* Assign the correct irq list */
688                 switch (lp->adapter) {
689                 case DEPCA:
690                 case de100:
691                 case de101:
692                         depca_irq = de1xx_irq;
693                         break;
694                 case de200:
695                 case de201:
696                 case de202:
697                 case de210:
698                 case de212:
699                         depca_irq = de2xx_irq;
700                         break;
701                 case de422:
702                         depca_irq = de422_irq;
703                         break;
704                 }
705
706                 /* Trigger an initialization just for the interrupt. */
707                 outw(INEA | INIT, DEPCA_DATA);
708           
709                 irqnum = autoirq_report(1);
710                 status = -ENXIO;
711                 if (!irqnum) {
712                         printk(" and failed to detect IRQ line.\n");
713                         goto out_region;
714                 } else {
715                         for (dev->irq=0,i=0; (depca_irq[i]) && (!dev->irq); i++)
716                                 if (irqnum == depca_irq[i]) {
717                                         dev->irq = irqnum;
718                                         printk(" and uses IRQ%d.\n", dev->irq);
719                                 }
720               
721                         status = -ENXIO;
722                         if (!dev->irq) {
723                                 printk(" but incorrect IRQ line detected.\n");
724                                 goto out_region;
725                         }
726                 }
727 #endif /* MODULE */
728         } else {
729                 printk(" and assigned IRQ%d.\n", dev->irq);
730         }
731
732         if (depca_debug > 1) {
733                 printk(version);
734         }
735
736         /* The DEPCA-specific entries in the device structure. */
737         dev->open = &depca_open;
738         dev->hard_start_xmit = &depca_start_xmit;
739         dev->stop = &depca_close;
740         dev->get_stats = &depca_get_stats;
741         dev->set_multicast_list = &set_multicast_list;
742         dev->do_ioctl = &depca_ioctl;
743         dev->tx_timeout = depca_tx_timeout;
744         dev->watchdog_timeo = TX_TIMEOUT;
745
746         dev->mem_start = 0;
747
748         /* Fill in the generic field of the device structure. */
749         ether_setup(dev);
750         return 0;
751 out_region:
752         release_region(ioaddr, DEPCA_TOTAL_SIZE);
753 out_priv:
754         kfree(dev->priv);
755         dev->priv = NULL;
756         return status;
757 }
758
759 \f
760 static int
761 depca_open(struct net_device *dev)
762 {
763   struct depca_private *lp = (struct depca_private *)dev->priv;
764   u_long ioaddr = dev->base_addr;
765   s16 nicsr;
766   int status = 0;
767
768   STOP_DEPCA;
769   nicsr = inb(DEPCA_NICSR);
770
771   /* Make sure the shadow RAM is enabled */
772   if (lp->adapter != DEPCA) {
773     nicsr |= SHE;
774     outb(nicsr, DEPCA_NICSR);
775   }
776
777   /* Re-initialize the DEPCA... */
778   depca_init_ring(dev);
779   LoadCSRs(dev);
780
781   depca_dbg_open(dev);
782
783   if (request_irq(dev->irq, &depca_interrupt, 0, lp->adapter_name, dev)) {
784     printk("depca_open(): Requested IRQ%d is busy\n",dev->irq);
785     status = -EAGAIN;
786   } else {
787
788     /* Enable DEPCA board interrupts and turn off LED */
789     nicsr = ((nicsr & ~IM & ~LED)|IEN);
790     outb(nicsr, DEPCA_NICSR);
791     outw(CSR0,DEPCA_ADDR);
792     
793     netif_start_queue(dev);
794     
795     status = InitRestartDepca(dev);
796
797     if (depca_debug > 1){
798       printk("CSR0: 0x%4.4x\n",inw(DEPCA_DATA));
799       printk("nicsr: 0x%02x\n",inb(DEPCA_NICSR));
800     }
801   }
802   return status;
803 }
804
805 /* Initialize the lance Rx and Tx descriptor rings. */
806 static void
807 depca_init_ring(struct net_device *dev)
808 {
809         struct depca_private *lp = (struct depca_private *)dev->priv;
810         u_int i;
811         u_long offset;
812
813         /* Lock out other processes whilst setting up the hardware */
814         netif_stop_queue(dev);
815
816         lp->rx_new = lp->tx_new = 0;
817         lp->rx_old = lp->tx_old = 0;
818
819         /* Initialize the base address and length of each buffer in the ring */
820         for (i = 0; i <= lp->rxRingMask; i++) {
821                 offset = lp->buffs_offset + i*RX_BUFF_SZ;
822                 writel((lp->device_ram_start + offset) | R_OWN,
823                        &lp->rx_ring[i].base);
824                 writew(-RX_BUFF_SZ, &lp->rx_ring[i].buf_length);
825                 lp->rx_buff[i] = lp->sh_mem + offset;
826         }
827
828         for (i = 0; i <= lp->txRingMask; i++) {
829                 offset = lp->buffs_offset + (i + lp->rxRingMask+1)*TX_BUFF_SZ;
830                 writel((lp->device_ram_start + offset) & 0x00ffffff,
831                        &lp->tx_ring[i].base);
832                 lp->tx_buff[i] = lp->sh_mem + offset;
833         }
834
835         /* Set up the initialization block */
836         lp->init_block.rx_ring = (lp->device_ram_start + lp->rx_ring_offset) | lp->rx_rlen;
837         lp->init_block.tx_ring = (lp->device_ram_start + lp->tx_ring_offset) | lp->tx_rlen;
838
839         SetMulticastFilter(dev);
840
841         for (i = 0; i < ETH_ALEN; i++) {
842                 lp->init_block.phys_addr[i] = dev->dev_addr[i];
843         }
844
845         lp->init_block.mode = 0x0000;            /* Enable the Tx and Rx */
846 }
847
848
849 static void depca_tx_timeout (struct net_device *dev)
850 {
851         u_long ioaddr = dev->base_addr;
852
853         printk ("%s: transmit timed out, status %04x, resetting.\n",
854                 dev->name, inw (DEPCA_DATA));
855
856         STOP_DEPCA;
857         depca_init_ring (dev);
858         LoadCSRs (dev);
859         dev->trans_start = jiffies;
860         netif_wake_queue (dev);
861         InitRestartDepca (dev);
862 }
863
864
865 /* 
866 ** Writes a socket buffer to TX descriptor ring and starts transmission 
867 */
868 static int depca_start_xmit (struct sk_buff *skb, struct net_device *dev)
869 {
870         struct depca_private *lp = (struct depca_private *) dev->priv;
871         u_long ioaddr = dev->base_addr;
872         int status = 0;
873
874         /* Transmitter timeout, serious problems. */
875         if (skb->len < 1)
876                 goto out;
877
878         netif_stop_queue (dev);
879
880         if (TX_BUFFS_AVAIL) {   /* Fill in a Tx ring entry */
881                 status = load_packet (dev, skb);
882
883                 if (!status) {
884                         /* Trigger an immediate send demand. */
885                         outw (CSR0, DEPCA_ADDR);
886                         outw (INEA | TDMD, DEPCA_DATA);
887
888                         dev->trans_start = jiffies;
889                         dev_kfree_skb (skb);
890                 }
891                 if (TX_BUFFS_AVAIL)
892                         netif_start_queue (dev);
893         } else
894                 status = -1;
895
896 out:
897         return status;
898 }
899
900 /*
901 ** The DEPCA interrupt handler. 
902 */
903 static void depca_interrupt (int irq, void *dev_id, struct pt_regs *regs)
904 {
905         struct net_device *dev = dev_id;
906         struct depca_private *lp;
907         s16 csr0, nicsr;
908         u_long ioaddr;
909
910         if (dev == NULL) {
911                 printk ("depca_interrupt(): irq %d for unknown device.\n", irq);
912                 return;
913         }
914
915         lp = (struct depca_private *) dev->priv;
916         ioaddr = dev->base_addr;
917
918         spin_lock (&lp->lock);
919
920         /* mask the DEPCA board interrupts and turn on the LED */
921         nicsr = inb (DEPCA_NICSR);
922         nicsr |= (IM | LED);
923         outb (nicsr, DEPCA_NICSR);
924
925         outw (CSR0, DEPCA_ADDR);
926         csr0 = inw (DEPCA_DATA);
927
928         /* Acknowledge all of the current interrupt sources ASAP. */
929         outw (csr0 & INTE, DEPCA_DATA);
930
931         if (csr0 & RINT)        /* Rx interrupt (packet arrived) */
932                 depca_rx (dev);
933
934         if (csr0 & TINT)        /* Tx interrupt (packet sent) */
935                 depca_tx (dev);
936
937         /* Any resources available? */
938         if ((TX_BUFFS_AVAIL >= 0) && netif_queue_stopped(dev)) {
939                 netif_wake_queue (dev);
940         }
941
942         /* Unmask the DEPCA board interrupts and turn off the LED */
943         nicsr = (nicsr & ~IM & ~LED);
944         outb (nicsr, DEPCA_NICSR);
945
946         spin_unlock (&lp->lock);
947 }
948
949
950 static int
951 depca_rx(struct net_device *dev)
952 {
953   struct depca_private *lp = (struct depca_private *)dev->priv;
954   int i, entry;
955   s32 status;
956
957   for (entry=lp->rx_new; 
958        !(readl(&lp->rx_ring[entry].base) & R_OWN);
959        entry=lp->rx_new){
960     status = readl(&lp->rx_ring[entry].base) >> 16 ;
961     if (status & R_STP) {                      /* Remember start of frame */
962       lp->rx_old = entry;
963     }
964     if (status & R_ENP) {                      /* Valid frame status */
965       if (status & R_ERR) {                    /* There was an error. */
966         lp->stats.rx_errors++;                 /* Update the error stats. */
967         if (status & R_FRAM) lp->stats.rx_frame_errors++;
968         if (status & R_OFLO) lp->stats.rx_over_errors++;
969         if (status & R_CRC)  lp->stats.rx_crc_errors++;
970         if (status & R_BUFF) lp->stats.rx_fifo_errors++;
971       } else {  
972         short len, pkt_len = readw(&lp->rx_ring[entry].msg_length) - 4;
973         struct sk_buff *skb;
974
975         skb = dev_alloc_skb(pkt_len+2);
976         if (skb != NULL) {
977           unsigned char *buf;
978           skb_reserve(skb,2);               /* 16 byte align the IP header */
979           buf = skb_put(skb,pkt_len);
980           skb->dev = dev;
981           if (entry < lp->rx_old) {         /* Wrapped buffer */
982             len = (lp->rxRingMask - lp->rx_old + 1) * RX_BUFF_SZ;
983             memcpy_fromio(buf, lp->rx_buff[lp->rx_old], len);
984             memcpy_fromio(buf + len, lp->rx_buff[0], pkt_len-len);
985           } else {                          /* Linear buffer */
986             memcpy_fromio(buf, lp->rx_buff[lp->rx_old], pkt_len);
987           }
988
989           /* 
990           ** Notify the upper protocol layers that there is another 
991           ** packet to handle
992           */
993           skb->protocol=eth_type_trans(skb,dev);
994           netif_rx(skb);
995
996           /*
997           ** Update stats
998           */
999           dev->last_rx = jiffies;
1000           lp->stats.rx_packets++;
1001           lp->stats.rx_bytes += pkt_len;
1002           for (i=1; i<DEPCA_PKT_STAT_SZ-1; i++) {
1003             if (pkt_len < (i*DEPCA_PKT_BIN_SZ)) {
1004               lp->pktStats.bins[i]++;
1005               i = DEPCA_PKT_STAT_SZ;
1006             }
1007           }
1008           if (buf[0] & 0x01) {              /* Multicast/Broadcast */
1009             if ((*(s16 *)&buf[0] == -1) &&
1010                 (*(s16 *)&buf[2] == -1) &&
1011                 (*(s16 *)&buf[4] == -1)) {
1012               lp->pktStats.broadcast++;
1013             } else {
1014               lp->pktStats.multicast++;
1015             }
1016           } else if ((*(s16 *)&buf[0] == *(s16 *)&dev->dev_addr[0]) &&
1017                      (*(s16 *)&buf[2] == *(s16 *)&dev->dev_addr[2]) &&
1018                      (*(s16 *)&buf[4] == *(s16 *)&dev->dev_addr[4])) {
1019             lp->pktStats.unicast++;
1020           }
1021           
1022           lp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
1023           if (lp->pktStats.bins[0] == 0) {  /* Reset counters */
1024             memset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
1025           }
1026         } else {
1027           printk("%s: Memory squeeze, deferring packet.\n", dev->name);
1028           lp->stats.rx_dropped++;       /* Really, deferred. */
1029           break;
1030         }
1031       }
1032       /* Change buffer ownership for this last frame, back to the adapter */
1033       for (; lp->rx_old!=entry; lp->rx_old=(++lp->rx_old)&lp->rxRingMask) {
1034         writel(readl(&lp->rx_ring[lp->rx_old].base) | R_OWN, 
1035                                                 &lp->rx_ring[lp->rx_old].base);
1036       }
1037       writel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base);
1038     }
1039
1040     /*
1041     ** Update entry information
1042     */
1043     lp->rx_new = (++lp->rx_new) & lp->rxRingMask;
1044     }
1045
1046     return 0;
1047 }
1048
1049 /*
1050 ** Buffer sent - check for buffer errors.
1051 */
1052 static int
1053 depca_tx(struct net_device *dev)
1054 {
1055   struct depca_private *lp = (struct depca_private *)dev->priv;
1056   int entry;
1057   s32 status;
1058   u_long ioaddr = dev->base_addr;
1059
1060   for (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
1061     status = readl(&lp->tx_ring[entry].base) >> 16 ;
1062
1063     if (status < 0) {                          /* Packet not yet sent! */
1064       break;
1065     } else if (status & T_ERR) {               /* An error occurred. */
1066       status = readl(&lp->tx_ring[entry].misc);
1067       lp->stats.tx_errors++;
1068       if (status & TMD3_RTRY) lp->stats.tx_aborted_errors++;
1069       if (status & TMD3_LCAR) lp->stats.tx_carrier_errors++;
1070       if (status & TMD3_LCOL) lp->stats.tx_window_errors++;
1071       if (status & TMD3_UFLO) lp->stats.tx_fifo_errors++;
1072       if (status & (TMD3_BUFF | TMD3_UFLO)) {
1073         /* Trigger an immediate send demand. */
1074         outw(CSR0, DEPCA_ADDR);
1075         outw(INEA | TDMD, DEPCA_DATA);
1076       }
1077     } else if (status & (T_MORE | T_ONE)) {
1078       lp->stats.collisions++;
1079     } else {
1080       lp->stats.tx_packets++;
1081     }
1082
1083     /* Update all the pointers */
1084     lp->tx_old = (++lp->tx_old) & lp->txRingMask;
1085   }
1086
1087   return 0;
1088 }
1089
1090 static int
1091 depca_close(struct net_device *dev)
1092 {
1093   struct depca_private *lp = (struct depca_private *)dev->priv;
1094   s16 nicsr;
1095   u_long ioaddr = dev->base_addr;
1096
1097   netif_stop_queue(dev);
1098
1099   outw(CSR0, DEPCA_ADDR);
1100
1101   if (depca_debug > 1) {
1102     printk("%s: Shutting down ethercard, status was %2.2x.\n",
1103            dev->name, inw(DEPCA_DATA));
1104   }
1105
1106   /* 
1107   ** We stop the DEPCA here -- it occasionally polls
1108   ** memory if we don't. 
1109   */
1110   outw(STOP, DEPCA_DATA);
1111
1112   /*
1113   ** Give back the ROM in case the user wants to go to DOS
1114   */
1115   if (lp->adapter != DEPCA) {
1116     nicsr = inb(DEPCA_NICSR);
1117     nicsr &= ~SHE;
1118     outb(nicsr, DEPCA_NICSR);
1119   }
1120
1121   /*
1122   ** Free the associated irq
1123   */
1124   free_irq(dev->irq, dev);
1125   return 0;
1126 }
1127
1128 static void LoadCSRs(struct net_device *dev)
1129 {
1130   struct depca_private *lp = (struct depca_private *)dev->priv;
1131   u_long ioaddr = dev->base_addr;
1132
1133   outw(CSR1, DEPCA_ADDR);                /* initialisation block address LSW */
1134   outw((u16)lp->device_ram_start, DEPCA_DATA);
1135   outw(CSR2, DEPCA_ADDR);                /* initialisation block address MSW */
1136   outw((u16)(lp->device_ram_start >> 16), DEPCA_DATA);
1137   outw(CSR3, DEPCA_ADDR);                /* ALE control */
1138   outw(ACON, DEPCA_DATA);
1139
1140   outw(CSR0, DEPCA_ADDR);                /* Point back to CSR0 */
1141
1142   return;
1143 }
1144
1145 static int InitRestartDepca(struct net_device *dev)
1146 {
1147   struct depca_private *lp = (struct depca_private *)dev->priv;
1148   u_long ioaddr = dev->base_addr;
1149   int i, status=0;
1150
1151   /* Copy the shadow init_block to shared memory */
1152   memcpy_toio(lp->sh_mem, &lp->init_block, sizeof(struct depca_init));
1153
1154   outw(CSR0, DEPCA_ADDR);                /* point back to CSR0 */
1155   outw(INIT, DEPCA_DATA);                /* initialize DEPCA */
1156
1157   /* wait for lance to complete initialisation */
1158   for (i=0;(i<100) && !(inw(DEPCA_DATA) & IDON); i++); 
1159
1160   if (i!=100) {
1161     /* clear IDON by writing a "1", enable interrupts and start lance */
1162     outw(IDON | INEA | STRT, DEPCA_DATA);
1163     if (depca_debug > 2) {
1164       printk("%s: DEPCA open after %d ticks, init block 0x%08lx csr0 %4.4x.\n",
1165              dev->name, i, virt_to_phys(lp->sh_mem), inw(DEPCA_DATA));
1166     }
1167   } else {
1168     printk("%s: DEPCA unopen after %d ticks, init block 0x%08lx csr0 %4.4x.\n",
1169              dev->name, i, virt_to_phys(lp->sh_mem), inw(DEPCA_DATA));
1170     status = -1;
1171   }
1172
1173   return status;
1174 }
1175
1176 static struct net_device_stats *
1177 depca_get_stats(struct net_device *dev)
1178 {
1179     struct depca_private *lp = (struct depca_private *)dev->priv;
1180
1181     /* Null body since there is no framing error counter */
1182
1183     return &lp->stats;
1184 }
1185
1186 /*
1187 ** Set or clear the multicast filter for this adaptor.
1188 */
1189 static void
1190 set_multicast_list(struct net_device *dev)
1191 {
1192   struct depca_private *lp = (struct depca_private *)dev->priv;
1193   u_long ioaddr = dev->base_addr;
1194   
1195   if (dev) {
1196     netif_stop_queue(dev);
1197     while(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
1198
1199     STOP_DEPCA;                       /* Temporarily stop the depca.  */
1200     depca_init_ring(dev);             /* Initialize the descriptor rings */
1201
1202     if (dev->flags & IFF_PROMISC) {   /* Set promiscuous mode */
1203       lp->init_block.mode |= PROM;
1204     } else {
1205       SetMulticastFilter(dev);
1206       lp->init_block.mode &= ~PROM;   /* Unset promiscuous mode */
1207     }
1208
1209     LoadCSRs(dev);                    /* Reload CSR3 */
1210     InitRestartDepca(dev);            /* Resume normal operation. */
1211     netif_start_queue(dev);           /* Unlock the TX ring */
1212   }
1213 }
1214
1215 /*
1216 ** Calculate the hash code and update the logical address filter
1217 ** from a list of ethernet multicast addresses.
1218 ** Big endian crc one liner is mine, all mine, ha ha ha ha!
1219 ** LANCE calculates its hash codes big endian.
1220 */
1221 static void SetMulticastFilter(struct net_device *dev)
1222 {
1223   struct depca_private *lp = (struct depca_private *)dev->priv;
1224   struct dev_mc_list *dmi=dev->mc_list;
1225   char *addrs;
1226   int i, j, bit, byte;
1227   u16 hashcode;
1228   s32 crc, poly = CRC_POLYNOMIAL_BE;
1229
1230   if (dev->flags & IFF_ALLMULTI) {         /* Set all multicast bits */
1231     for (i=0; i<(HASH_TABLE_LEN>>3); i++) {
1232       lp->init_block.mcast_table[i] = (char)0xff;
1233     }
1234   } else {
1235     for (i=0; i<(HASH_TABLE_LEN>>3); i++){ /* Clear the multicast table */
1236       lp->init_block.mcast_table[i]=0;
1237     }
1238                                            /* Add multicast addresses */
1239     for (i=0;i<dev->mc_count;i++) {        /* for each address in the list */
1240       addrs=dmi->dmi_addr;
1241       dmi=dmi->next;
1242       if ((*addrs & 0x01) == 1) {          /* multicast address? */ 
1243         crc = 0xffffffff;                  /* init CRC for each address */
1244         for (byte=0;byte<ETH_ALEN;byte++) {/* for each address byte */
1245                                            /* process each address bit */ 
1246           for (bit = *addrs++,j=0;j<8;j++, bit>>=1) {
1247             crc = (crc << 1) ^ ((((crc<0?1:0) ^ bit) & 0x01) ? poly : 0);
1248           }
1249         }
1250         hashcode = (crc & 1);              /* hashcode is 6 LSb of CRC ... */
1251         for (j=0;j<5;j++) {                /* ... in reverse order. */
1252           hashcode = (hashcode << 1) | ((crc>>=1) & 1);
1253         }                                      
1254         
1255         
1256         byte = hashcode >> 3;              /* bit[3-5] -> byte in filter */
1257         bit = 1 << (hashcode & 0x07);      /* bit[0-2] -> bit in byte */
1258         lp->init_block.mcast_table[byte] |= bit;
1259       }
1260     }
1261   }
1262
1263   return;
1264 }
1265
1266 #ifdef CONFIG_MCA
1267 /*
1268 ** Microchannel bus I/O device probe
1269 */
1270 static void __init 
1271 mca_probe(struct net_device *dev, u_long ioaddr)
1272 {
1273     unsigned char pos[2];
1274     unsigned char where;
1275     unsigned long iobase;
1276     int irq;
1277     int slot = 0;
1278
1279     /*
1280     ** See if we've been here before.
1281     */
1282     if ((!ioaddr && autoprobed) || (ioaddr && !loading_module)) return;   
1283
1284     if (MCA_bus) {
1285         /*
1286         ** Search for the adapter.  If an address has been given, search 
1287         ** specifically for the card at that address.  Otherwise find the
1288         ** first card in the system.
1289         */
1290         while ((dev!=NULL) && 
1291                ((slot=mca_find_adapter(DE212_ID, slot)) != MCA_NOTFOUND)) {
1292             pos[0] = mca_read_stored_pos(slot, 2);
1293             pos[1] = mca_read_stored_pos(slot, 3);
1294
1295             /*
1296             ** IO of card is handled by bits 1 and 2 of pos0.    
1297             **
1298             **    bit2 bit1    IO
1299             **       0    0    0x2c00
1300             **       0    1    0x2c10
1301             **       1    0    0x2c20
1302             **       1    1    0x2c30
1303             */
1304             where = (pos[0] & 6) >> 1;
1305             iobase = 0x2c00 + (0x10 * where);
1306                
1307             if ((ioaddr) && (ioaddr != iobase)) {
1308                 /*
1309                 ** Card was found, but not at the right IO location. Continue 
1310                 ** scanning from the next MCA slot up for another card.
1311                 */
1312                 slot++;
1313                 continue;
1314             }
1315
1316             /*
1317             ** Found the adapter we were looking for. Now start setting it up.
1318             ** 
1319             ** First work on decoding the IRQ.  It's stored in the lower 4 bits
1320             ** of pos1.  Bits are as follows (from the ADF file):
1321             **
1322             **      Bits           
1323             **   3   2   1   0    IRQ 
1324             **   --------------------
1325             **   0   0   1   0     5
1326             **   0   0   0   1     9
1327             **   0   1   0   0    10
1328             **   1   0   0   0    11
1329             **/
1330             where = pos[1] & 0x0f;
1331             switch(where) {       
1332             case 1:
1333                 irq = 9;
1334                 break;
1335             case 2:
1336                 irq = 5;
1337                 break;
1338             case 4:
1339                 irq = 10;
1340                 break;
1341             case 8:
1342                 irq = 11;
1343                 break;
1344             default:
1345                 printk("%s: mca_probe IRQ error.  You should never get here (%d).\n", dev->name, where);
1346                 return;
1347             }  
1348  
1349             /*
1350             ** Shared memory address of adapter is stored in bits 3-5 of pos0.
1351             ** They are mapped as follows:
1352             **
1353             **    Bit
1354             **   5  4  3       Memory Addresses
1355             **   0  0  0       C0000-CFFFF (64K)
1356             **   1  0  0       C8000-CFFFF (32K)
1357             **   0  0  1       D0000-DFFFF (64K)
1358             **   1  0  1       D8000-DFFFF (32K)
1359             **   0  1  0       E0000-EFFFF (64K)
1360             **   1  1  0       E8000-EFFFF (32K)
1361             */ 
1362             where = (pos[0] & 0x18) >> 3; 
1363             mem = 0xc0000 + (where * 0x10000);
1364             if (pos[0] & 0x20) {
1365                 mem += 0x8000;
1366             }
1367        
1368             /*
1369             ** Get everything allocated and initialized...  (almost just
1370             ** like the ISA and EISA probes)
1371             */
1372             if (DevicePresent(iobase) != 0) {
1373                 /*
1374                 ** If the MCA configuration says the card should be here,
1375                 ** it really should be here.
1376                 */
1377                 printk(KERN_ERR "%s: MCA reports card at 0x%lx but it is not
1378 responding.\n", dev->name, iobase);
1379             }
1380        
1381             if (check_region(iobase, DEPCA_TOTAL_SIZE) == 0) {
1382                 if ((dev = alloc_device(dev, iobase)) != NULL) {
1383                     dev->irq = irq;
1384                     if (depca_hw_init(dev, iobase, slot) == 0) {       
1385                         /*
1386                         ** Adapter initialized correctly:  Name it in
1387                         ** /proc/mca.
1388                         */
1389                         mca_set_adapter_name(slot, "DE210/212 Ethernet Adapter");
1390                         mca_mark_as_used(slot);
1391                         num_depcas++;
1392                     }
1393                     num_eth++;
1394                 }
1395             } else if (autoprobed) {
1396                 printk(KERN_WARNING "%s: region already allocated at 0x%04lx.\n", dev->name, iobase);
1397             }
1398        
1399             /*
1400             ** If this is a probe by a module, return after setting up the
1401             ** given card.
1402             */
1403             if (ioaddr) return;
1404        
1405             /*
1406             ** Set up to check the next slot and loop.
1407             */
1408             slot++;
1409         }
1410     }
1411
1412     return;
1413 }
1414 #endif
1415
1416 /*
1417 ** ISA bus I/O device probe
1418 */
1419 static void __init 
1420 isa_probe(struct net_device *dev, u_long ioaddr)
1421 {
1422   int i = num_depcas, maxSlots;
1423   s32 ports[] = DEPCA_IO_PORTS;
1424
1425   if (!ioaddr && autoprobed) return ;          /* Been here before ! */
1426   if (ioaddr > 0x400) return;                  /* EISA Address */
1427   if (i >= MAX_NUM_DEPCAS) return;             /* Too many ISA adapters */
1428
1429   if (ioaddr == 0) {                           /* Autoprobing */
1430     maxSlots = MAX_NUM_DEPCAS;
1431   } else {                                     /* Probe a specific location */
1432     ports[i] = ioaddr;
1433     maxSlots = i + 1;
1434   }
1435
1436   for (; (i<maxSlots) && (dev!=NULL) && ports[i]; i++) {
1437     if (check_region(ports[i], DEPCA_TOTAL_SIZE) == 0) {
1438       if (DevicePresent(ports[i]) == 0) { 
1439         if ((dev = alloc_device(dev, ports[i])) != NULL) {
1440           if (depca_hw_init(dev, ports[i], -1) == 0) {
1441             num_depcas++;
1442           }
1443           num_eth++;
1444         }
1445       }
1446     } else if (autoprobed) {
1447       printk("%s: region already allocated at 0x%04x.\n", dev->name, ports[i]);
1448     }
1449   }
1450
1451   return;
1452 }
1453
1454 /*
1455 ** EISA bus I/O device probe. Probe from slot 1 since slot 0 is usually
1456 ** the motherboard. Upto 15 EISA devices are supported.
1457 */
1458 static void __init 
1459 eisa_probe(struct net_device *dev, u_long ioaddr)
1460 {
1461   int i, maxSlots;
1462   u_long iobase;
1463   char name[DEPCA_STRLEN];
1464
1465   if (!ioaddr && autoprobed) return ;            /* Been here before ! */
1466   if ((ioaddr < 0x400) && (ioaddr > 0)) return;  /* ISA Address */
1467
1468   if (ioaddr == 0) {                           /* Autoprobing */
1469     iobase = EISA_SLOT_INC;                    /* Get the first slot address */
1470     i = 1;
1471     maxSlots = MAX_EISA_SLOTS;
1472   } else {                                     /* Probe a specific location */
1473     iobase = ioaddr;
1474     i = (ioaddr >> 12);
1475     maxSlots = i + 1;
1476   }
1477   if ((iobase & 0x0fff) == 0) iobase += DEPCA_EISA_IO_PORTS;
1478
1479   for (; (i<maxSlots) && (dev!=NULL); i++, iobase+=EISA_SLOT_INC) {
1480     if (check_region(iobase, DEPCA_TOTAL_SIZE) == 0) {
1481       if (EISA_signature(name, EISA_ID)) {
1482         if (DevicePresent(iobase) == 0) { 
1483           if ((dev = alloc_device(dev, iobase)) != NULL) {
1484             if (depca_hw_init(dev, iobase, -1) == 0) {
1485               num_depcas++;
1486             }
1487             num_eth++;
1488           }
1489         }
1490       }
1491     } else if (autoprobed) {
1492       printk("%s: region already allocated at 0x%04lx.\n", dev->name, iobase);
1493     }
1494   }
1495
1496   return;
1497 }
1498
1499 /*
1500 ** Search the entire 'eth' device list for a fixed probe. If a match isn't
1501 ** found then check for an autoprobe or unused device location. If they
1502 ** are not available then insert a new device structure at the end of
1503 ** the current list.
1504 */
1505 static struct net_device * __init 
1506 alloc_device(struct net_device *dev, u_long iobase)
1507 {
1508     struct net_device *adev = NULL;
1509     int fixed = 0, new_dev = 0;
1510
1511     num_eth = depca_dev_index(dev->name);
1512     if (loading_module) return dev;
1513     
1514     while (1) {
1515         if (((dev->base_addr == DEPCA_NDA) || (dev->base_addr==0)) && !adev) {
1516             adev=dev;
1517         } else if ((dev->priv == NULL) && (dev->base_addr==iobase)) {
1518             fixed = 1;
1519         } else {
1520             if (dev->next == NULL) {
1521                 new_dev = 1;
1522             } else if (strncmp(dev->next->name, "eth", 3) != 0) {
1523                 new_dev = 1;
1524             }
1525         }
1526         if ((dev->next == NULL) || new_dev || fixed) break;
1527         dev = dev->next;
1528         num_eth++;
1529     }
1530     if (adev && !fixed) {
1531         dev = adev;
1532         num_eth = depca_dev_index(dev->name);
1533         new_dev = 0;
1534     }
1535
1536     if (((dev->next == NULL) &&  
1537         ((dev->base_addr != DEPCA_NDA) && (dev->base_addr != 0)) && !fixed) ||
1538         new_dev) {
1539         num_eth++;                         /* New device */
1540         dev = insert_device(dev, iobase, depca_probe);
1541     }
1542     
1543     return dev;
1544 }
1545
1546 /*
1547 ** If at end of eth device list and can't use current entry, malloc
1548 ** one up. If memory could not be allocated, print an error message.
1549 */
1550 static struct net_device * __init 
1551 insert_device(struct net_device *dev, u_long iobase, int (*init)(struct net_device *))
1552 {
1553     struct net_device *new;
1554
1555     new = (struct net_device *)kmalloc(sizeof(struct net_device), GFP_KERNEL);
1556     if (new == NULL) {
1557         printk("eth%d: Device not initialised, insufficient memory\n",num_eth);
1558         return NULL;
1559     } else {
1560         new->next = dev->next;
1561         dev->next = new;
1562         dev = dev->next;               /* point to the new device */
1563         if (num_eth > 9999) {
1564             sprintf(dev->name,"eth????");/* New device name */
1565         } else {
1566             sprintf(dev->name,"eth%d", num_eth);/* New device name */
1567         }
1568         dev->base_addr = iobase;       /* assign the io address */
1569         dev->init = init;              /* initialisation routine */
1570     }
1571
1572     return dev;
1573 }
1574
1575 static int __init 
1576 depca_dev_index(char *s)
1577 {
1578     int i=0, j=0;
1579
1580     for (;*s; s++) {
1581         if (isdigit(*s)) {
1582             j=1;
1583             i = (i * 10) + (*s - '0');
1584         } else if (j) break;
1585     }
1586
1587     return i;
1588 }
1589
1590 /*
1591 ** Look for a particular board name in the on-board Remote Diagnostics
1592 ** and Boot (readb) ROM. This will also give us a clue to the network RAM
1593 ** base address.
1594 */
1595 static void __init 
1596 DepcaSignature(char *name, u_long paddr)
1597 {
1598   u_int i,j,k;
1599   const char *signatures[] = DEPCA_SIGNATURE;
1600   void *ptr;
1601   char tmpstr[16];
1602
1603   /* Copy the first 16 bytes of ROM */
1604   ptr = ioremap(paddr + 0xc000, 16);
1605   if (ptr == NULL) {
1606           printk(KERN_ERR "depca: I/O remap failed at %lx\n", paddr+0xc000);
1607           adapter = unknown;
1608           return;
1609   }
1610   for (i=0;i<16;i++) {
1611     tmpstr[i] = readb(ptr + i);
1612   }
1613   iounmap(ptr);
1614
1615   /* Check if PROM contains a valid string */
1616   for (i=0;*signatures[i]!='\0';i++) {
1617     for (j=0,k=0;j<16 && k<strlen(signatures[i]);j++) {
1618       if (signatures[i][k] == tmpstr[j]) {              /* track signature */
1619         k++;
1620       } else {                     /* lost signature; begin search again */
1621         k=0;
1622       }
1623     }
1624     if (k == strlen(signatures[i])) break;
1625   }
1626
1627   /* Check if name string is valid, provided there's no PROM */
1628   if (*name && (i == unknown)) {
1629     for (i=0;*signatures[i]!='\0';i++) {
1630       if (strcmp(name,signatures[i]) == 0) break;
1631     }
1632   }
1633
1634   /* Update search results */
1635   strcpy(name,signatures[i]);
1636   adapter = i;
1637
1638   return;
1639 }
1640
1641 /*
1642 ** Look for a special sequence in the Ethernet station address PROM that
1643 ** is common across all DEPCA products. Note that the original DEPCA needs
1644 ** its ROM address counter to be initialized and enabled. Only enable
1645 ** if the first address octet is a 0x08 - this minimises the chances of
1646 ** messing around with some other hardware, but it assumes that this DEPCA
1647 ** card initialized itself correctly.
1648 ** 
1649 ** Search the Ethernet address ROM for the signature. Since the ROM address
1650 ** counter can start at an arbitrary point, the search must include the entire
1651 ** probe sequence length plus the (length_of_the_signature - 1).
1652 ** Stop the search IMMEDIATELY after the signature is found so that the
1653 ** PROM address counter is correctly positioned at the start of the
1654 ** ethernet address for later read out.
1655 */
1656 static int __init 
1657 DevicePresent(u_long ioaddr)
1658 {
1659   union {
1660     struct {
1661       u32 a;
1662       u32 b;
1663     } llsig;
1664     char Sig[sizeof(u32) << 1];
1665   } dev;
1666   short sigLength=0;
1667   s8 data;
1668   s16 nicsr;
1669   int i, j, status = 0;
1670
1671   data = inb(DEPCA_PROM);                /* clear counter on DEPCA */
1672   data = inb(DEPCA_PROM);                /* read data */
1673
1674   if (data == 0x08) {                    /* Enable counter on DEPCA */
1675     nicsr = inb(DEPCA_NICSR);
1676     nicsr |= AAC;
1677     outb(nicsr, DEPCA_NICSR);
1678   }
1679   
1680   dev.llsig.a = ETH_PROM_SIG;
1681   dev.llsig.b = ETH_PROM_SIG;
1682   sigLength = sizeof(u32) << 1;
1683
1684   for (i=0,j=0;j<sigLength && i<PROBE_LENGTH+sigLength-1;i++) {
1685     data = inb(DEPCA_PROM);
1686     if (dev.Sig[j] == data) {    /* track signature */
1687       j++;
1688     } else {                     /* lost signature; begin search again */
1689       if (data == dev.Sig[0]) {  /* rare case.... */
1690         j=1;
1691       } else {
1692         j=0;
1693       }
1694     }
1695   }
1696
1697   if (j!=sigLength) {
1698     status = -ENODEV;           /* search failed */
1699   }
1700
1701   return status;
1702 }
1703
1704 /*
1705 ** The DE100 and DE101 PROM accesses were made non-standard for some bizarre
1706 ** reason: access the upper half of the PROM with x=0; access the lower half
1707 ** with x=1.
1708 */
1709 static int __init 
1710 get_hw_addr(struct net_device *dev)
1711 {
1712   u_long ioaddr = dev->base_addr;
1713   int i, k, tmp, status = 0;
1714   u_short j, x, chksum;
1715
1716   x = (((adapter == de100) || (adapter == de101)) ? 1 : 0);
1717
1718   for (i=0,k=0,j=0;j<3;j++) {
1719     k <<= 1 ;
1720     if (k > 0xffff) k-=0xffff;
1721
1722     k += (u_char) (tmp = inb(DEPCA_PROM + x));
1723     dev->dev_addr[i++] = (u_char) tmp;
1724     k += (u_short) ((tmp = inb(DEPCA_PROM + x)) << 8);
1725     dev->dev_addr[i++] = (u_char) tmp;
1726
1727     if (k > 0xffff) k-=0xffff;
1728   }
1729   if (k == 0xffff) k=0;
1730
1731   chksum = (u_char) inb(DEPCA_PROM + x);
1732   chksum |= (u_short) (inb(DEPCA_PROM + x) << 8);
1733   if (k != chksum) status = -1;
1734
1735   return status;
1736 }
1737
1738 /*
1739 ** Load a packet into the shared memory
1740 */
1741 static int load_packet(struct net_device *dev, struct sk_buff *skb)
1742 {
1743   struct depca_private *lp = (struct depca_private *)dev->priv;
1744   int i, entry, end, len, status = 0;
1745
1746   entry = lp->tx_new;                          /* Ring around buffer number. */
1747   end = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
1748   if (!(readl(&lp->tx_ring[end].base) & T_OWN)) {/* Enough room? */
1749     /* 
1750     ** Caution: the write order is important here... don't set up the
1751     ** ownership rights until all the other information is in place.
1752     */
1753     if (end < entry) {                         /* wrapped buffer */
1754       len = (lp->txRingMask - entry + 1) * TX_BUFF_SZ;
1755       memcpy_toio(lp->tx_buff[entry], skb->data, len);
1756       memcpy_toio(lp->tx_buff[0], skb->data + len, skb->len - len);
1757     } else {                                   /* linear buffer */
1758       memcpy_toio(lp->tx_buff[entry], skb->data, skb->len);
1759     }
1760
1761     /* set up the buffer descriptors */
1762     len = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
1763     for (i = entry; i != end; i = (++i) & lp->txRingMask) {
1764                                                /* clean out flags */
1765       writel(readl(&lp->tx_ring[i].base) & ~T_FLAGS, &lp->tx_ring[i].base);
1766       writew(0x0000, &lp->tx_ring[i].misc);    /* clears other error flags */
1767       writew(-TX_BUFF_SZ, &lp->tx_ring[i].length);/* packet length in buffer */
1768       len -= TX_BUFF_SZ;
1769     }
1770                                                /* clean out flags */
1771     writel(readl(&lp->tx_ring[end].base) & ~T_FLAGS, &lp->tx_ring[end].base);
1772     writew(0x0000, &lp->tx_ring[end].misc);    /* clears other error flags */
1773     writew(-len, &lp->tx_ring[end].length);    /* packet length in last buff */
1774
1775                                                /* start of packet */
1776     writel(readl(&lp->tx_ring[entry].base) | T_STP, &lp->tx_ring[entry].base);
1777                                                /* end of packet */
1778     writel(readl(&lp->tx_ring[end].base) | T_ENP, &lp->tx_ring[end].base);
1779
1780     for (i=end; i!=entry; --i) {
1781                                                /* ownership of packet */
1782       writel(readl(&lp->tx_ring[i].base) | T_OWN, &lp->tx_ring[i].base);
1783       if (i == 0) i=lp->txRingMask+1;
1784     }   
1785     writel(readl(&lp->tx_ring[entry].base) | T_OWN, &lp->tx_ring[entry].base);
1786  
1787     lp->tx_new = (++end) & lp->txRingMask;     /* update current pointers */
1788   } else {
1789     status = -1;
1790   }
1791
1792   return status;
1793 }
1794
1795 /*
1796 ** Look for a particular board name in the EISA configuration space
1797 */
1798 static int __init 
1799 EISA_signature(char *name, s32 eisa_id)
1800 {
1801   u_int i;
1802   const char *signatures[] = DEPCA_SIGNATURE;
1803   char ManCode[DEPCA_STRLEN];
1804   union {
1805     s32 ID;
1806     char Id[4];
1807   } Eisa;
1808   int status = 0;
1809
1810   *name = '\0';
1811   Eisa.ID = inl(eisa_id);
1812
1813   ManCode[0]=(((Eisa.Id[0]>>2)&0x1f)+0x40);
1814   ManCode[1]=(((Eisa.Id[1]&0xe0)>>5)+((Eisa.Id[0]&0x03)<<3)+0x40);
1815   ManCode[2]=(((Eisa.Id[2]>>4)&0x0f)+0x30);
1816   ManCode[3]=(( Eisa.Id[2]&0x0f)+0x30);
1817   ManCode[4]=(((Eisa.Id[3]>>4)&0x0f)+0x30);
1818   ManCode[5]='\0';
1819
1820   for (i=0;(*signatures[i] != '\0') && (*name == '\0');i++) {
1821     if (strstr(ManCode, signatures[i]) != NULL) {
1822       strcpy(name,ManCode);
1823       status = 1;
1824     }
1825   }
1826
1827   return status;
1828 }
1829
1830 static void depca_dbg_open(struct net_device *dev)
1831 {
1832   struct depca_private *lp = (struct depca_private *)dev->priv;
1833   u_long ioaddr = dev->base_addr;
1834   struct depca_init *p = &lp->init_block;
1835   int i; 
1836
1837   if (depca_debug > 1){
1838     /* Do not copy the shadow init block into shared memory */
1839     /* Debugging should not affect normal operation! */
1840     /* The shadow init block will get copied across during InitRestartDepca */
1841     printk("%s: depca open with irq %d\n",dev->name,dev->irq);
1842     printk("Descriptor head addresses (CPU):\n");
1843     printk("        0x%lx  0x%lx\n",(u_long)lp->rx_ring, (u_long)lp->tx_ring);
1844     printk("Descriptor addresses (CPU):\nRX: ");
1845     for (i=0;i<lp->rxRingMask;i++){
1846       if (i < 3) {
1847         printk("0x%8.8lx ", (long) &lp->rx_ring[i].base);
1848       }
1849     }
1850     printk("...0x%8.8lx\n", (long) &lp->rx_ring[i].base);
1851     printk("TX: ");
1852     for (i=0;i<lp->txRingMask;i++){
1853       if (i < 3) {
1854         printk("0x%8.8lx ", (long) &lp->tx_ring[i].base);
1855       }
1856     }
1857     printk("...0x%8.8lx\n", (long) &lp->tx_ring[i].base);
1858     printk("\nDescriptor buffers (Device):\nRX: ");
1859     for (i=0;i<lp->rxRingMask;i++){
1860       if (i < 3) {
1861         printk("0x%8.8x  ", readl(&lp->rx_ring[i].base));
1862       }
1863     }
1864     printk("...0x%8.8x\n", readl(&lp->rx_ring[i].base));
1865     printk("TX: ");
1866     for (i=0;i<lp->txRingMask;i++){
1867       if (i < 3) {
1868         printk("0x%8.8x  ", readl(&lp->tx_ring[i].base));
1869       }
1870     }
1871     printk("...0x%8.8x\n", readl(&lp->tx_ring[i].base));
1872     printk("Initialisation block at 0x%8.8lx(Phys)\n",virt_to_phys(lp->sh_mem));
1873     printk("        mode: 0x%4.4x\n",p->mode);
1874     printk("        physical address: ");
1875     for (i=0;i<ETH_ALEN-1;i++){
1876       printk("%2.2x:", p->phys_addr[i]);
1877     }
1878     printk("%2.2x\n", p->phys_addr[i]);
1879     printk("        multicast hash table: ");
1880     for (i=0;i<(HASH_TABLE_LEN >> 3)-1;i++){
1881       printk("%2.2x:", p->mcast_table[i]);
1882     }
1883     printk("%2.2x\n", p->mcast_table[i]);
1884     printk("        rx_ring at: 0x%8.8x\n", p->rx_ring);
1885     printk("        tx_ring at: 0x%8.8x\n", p->tx_ring);
1886     printk("buffers (Phys): 0x%8.8lx\n",virt_to_phys(lp->sh_mem)+lp->buffs_offset);
1887     printk("Ring size:\nRX: %d  Log2(rxRingMask): 0x%8.8x\n", 
1888            (int)lp->rxRingMask + 1, 
1889            lp->rx_rlen);
1890     printk("TX: %d  Log2(txRingMask): 0x%8.8x\n", 
1891            (int)lp->txRingMask + 1, 
1892            lp->tx_rlen);
1893     outw(CSR2,DEPCA_ADDR);
1894     printk("CSR2&1: 0x%4.4x",inw(DEPCA_DATA));
1895     outw(CSR1,DEPCA_ADDR);
1896     printk("%4.4x\n",inw(DEPCA_DATA));
1897     outw(CSR3,DEPCA_ADDR);
1898     printk("CSR3: 0x%4.4x\n",inw(DEPCA_DATA));
1899   }
1900
1901   return;
1902 }
1903
1904 /*
1905 ** Perform IOCTL call functions here. Some are privileged operations and the
1906 ** effective uid is checked in those cases.
1907 ** All multicast IOCTLs will not work here and are for testing purposes only.
1908 */
1909 static int depca_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1910 {
1911   struct depca_private *lp = (struct depca_private *)dev->priv;
1912   struct depca_ioctl *ioc = (struct depca_ioctl *) &rq->ifr_data;
1913   int i, status = 0;
1914   u_long ioaddr = dev->base_addr;
1915   union {
1916     u8  addr[(HASH_TABLE_LEN * ETH_ALEN)];
1917     u16 sval[(HASH_TABLE_LEN * ETH_ALEN) >> 1];
1918     u32 lval[(HASH_TABLE_LEN * ETH_ALEN) >> 2];
1919   } tmp;
1920
1921   switch(ioc->cmd) {
1922   case DEPCA_GET_HWADDR:             /* Get the hardware address */
1923     for (i=0; i<ETH_ALEN; i++) {
1924       tmp.addr[i] = dev->dev_addr[i];
1925     }
1926     ioc->len = ETH_ALEN;
1927     if (copy_to_user(ioc->data, tmp.addr, ioc->len))
1928       return -EFAULT;
1929     break;
1930
1931   case DEPCA_SET_HWADDR:             /* Set the hardware address */
1932     if (!capable(CAP_NET_ADMIN)) return -EPERM;
1933     if (copy_from_user(tmp.addr, ioc->data, ETH_ALEN))
1934       return -EFAULT;
1935     for (i=0; i<ETH_ALEN; i++) {
1936       dev->dev_addr[i] = tmp.addr[i];
1937     }
1938     netif_stop_queue(dev);
1939     while(lp->tx_old != lp->tx_new);    /* Wait for the ring to empty */
1940
1941     STOP_DEPCA;                         /* Temporarily stop the depca.  */
1942     depca_init_ring(dev);               /* Initialize the descriptor rings */
1943     LoadCSRs(dev);                      /* Reload CSR3 */
1944     InitRestartDepca(dev);              /* Resume normal operation. */
1945     netif_start_queue(dev);             /* Unlock the TX ring */
1946     break;
1947
1948   case DEPCA_SET_PROM:               /* Set Promiscuous Mode */
1949     if (!capable(CAP_NET_ADMIN)) return -EPERM;
1950     netif_stop_queue(dev);
1951     while(lp->tx_old != lp->tx_new);    /* Wait for the ring to empty */
1952
1953     STOP_DEPCA;                         /* Temporarily stop the depca.  */
1954     depca_init_ring(dev);               /* Initialize the descriptor rings */
1955     lp->init_block.mode |= PROM;        /* Set promiscuous mode */
1956
1957     LoadCSRs(dev);                      /* Reload CSR3 */
1958     InitRestartDepca(dev);              /* Resume normal operation. */
1959     netif_start_queue(dev);             /* Unlock the TX ring */
1960     break;
1961
1962   case DEPCA_CLR_PROM:               /* Clear Promiscuous Mode */
1963     if (!capable(CAP_NET_ADMIN)) return -EPERM;
1964     netif_stop_queue(dev);
1965     while(lp->tx_old != lp->tx_new);    /* Wait for the ring to empty */
1966
1967     STOP_DEPCA;                         /* Temporarily stop the depca.  */
1968     depca_init_ring(dev);               /* Initialize the descriptor rings */
1969     lp->init_block.mode &= ~PROM;       /* Clear promiscuous mode */
1970
1971     LoadCSRs(dev);                      /* Reload CSR3 */
1972     InitRestartDepca(dev);              /* Resume normal operation. */
1973     netif_start_queue(dev);             /* Unlock the TX ring */
1974     break;
1975
1976   case DEPCA_SAY_BOO:                /* Say "Boo!" to the kernel log file */
1977     printk("%s: Boo!\n", dev->name);
1978     break;
1979
1980   case DEPCA_GET_MCA:                /* Get the multicast address table */
1981     ioc->len = (HASH_TABLE_LEN >> 3);
1982     if (copy_to_user(ioc->data, lp->init_block.mcast_table, ioc->len))
1983       return -EFAULT;
1984     break;
1985
1986   case DEPCA_SET_MCA:                /* Set a multicast address */
1987     if (!capable(CAP_NET_ADMIN)) return -EPERM;
1988     if (copy_from_user(tmp.addr, ioc->data, ETH_ALEN * ioc->len))
1989       return -EFAULT;
1990     set_multicast_list(dev);
1991     break;
1992
1993   case DEPCA_CLR_MCA:                /* Clear all multicast addresses */
1994     if (!capable(CAP_NET_ADMIN)) return -EPERM;
1995     set_multicast_list(dev);
1996     break;
1997
1998   case DEPCA_MCA_EN:                 /* Enable pass all multicast addressing */
1999     if (!capable(CAP_NET_ADMIN)) return -EPERM;
2000       set_multicast_list(dev);
2001     break;
2002
2003   case DEPCA_GET_STATS:              /* Get the driver statistics */
2004     cli();
2005     ioc->len = sizeof(lp->pktStats);
2006     if (copy_to_user(ioc->data, &lp->pktStats, ioc->len))
2007       status = -EFAULT;
2008     sti();
2009     break;
2010
2011   case DEPCA_CLR_STATS:              /* Zero out the driver statistics */
2012     if (!capable(CAP_NET_ADMIN)) return -EPERM;
2013     cli();
2014     memset(&lp->pktStats, 0, sizeof(lp->pktStats));
2015     sti();
2016     break;
2017
2018   case DEPCA_GET_REG:                /* Get the DEPCA Registers */
2019     i=0;
2020     tmp.sval[i++] = inw(DEPCA_NICSR);
2021     outw(CSR0, DEPCA_ADDR);              /* status register */
2022     tmp.sval[i++] = inw(DEPCA_DATA);
2023     memcpy(&tmp.sval[i], &lp->init_block, sizeof(struct depca_init));
2024     ioc->len = i+sizeof(struct depca_init);
2025     if (copy_to_user(ioc->data, tmp.addr, ioc->len))
2026       return -EFAULT;
2027     break;
2028
2029   default:
2030     return -EOPNOTSUPP;
2031   }
2032
2033   return status;
2034 }
2035
2036 #ifdef MODULE
2037 static struct net_device thisDepca;
2038 static int irq=7;       /* EDIT THESE LINE FOR YOUR CONFIGURATION */
2039 static int io=0x200;    /* Or use the irq= io= options to insmod */
2040 MODULE_PARM(irq, "i");
2041 MODULE_PARM(io, "i");
2042 MODULE_PARM_DESC(irq, "DEPCA IRQ number");
2043 MODULE_PARM_DESC(io, "DEPCA I/O base address");
2044
2045 /* See depca_probe() for autoprobe messages when a module */    
2046 int
2047 init_module(void)
2048 {
2049   thisDepca.irq=irq;
2050   thisDepca.base_addr=io;
2051   thisDepca.init = depca_probe;
2052
2053   if (register_netdev(&thisDepca) != 0)
2054     return -EIO;
2055
2056   return 0;
2057 }
2058
2059 void
2060 cleanup_module(void)
2061 {
2062   struct depca_private *lp = thisDepca.priv;
2063
2064   unregister_netdev(&thisDepca);
2065   if (lp) {
2066     iounmap(lp->sh_mem);
2067 #ifdef CONFIG_MCA      
2068     if(lp->mca_slot != -1)
2069       mca_mark_as_unused(lp->mca_slot);
2070 #endif                 
2071     kfree(lp);
2072     thisDepca.priv = NULL;
2073   }
2074   thisDepca.irq=0;
2075
2076   release_region(thisDepca.base_addr, DEPCA_TOTAL_SIZE);
2077 }
2078 #endif /* MODULE */
2079
2080 \f
2081 /*
2082  * Local variables:
2083  *  compile-command: "gcc -D__KERNEL__ -I/linux/include -Wall -Wstrict-prototypes -fomit-frame-pointer -fno-strength-reduce -malign-loops=2 -malign-jumps=2 -malign-functions=2 -O2 -m486 -c depca.c"
2084  *
2085  *  compile-command: "gcc -D__KERNEL__ -DMODULE -I/linux/include -Wall -Wstrict-prototypes -fomit-frame-pointer -fno-strength-reduce -malign-loops=2 -malign-jumps=2 -malign-functions=2 -O2 -m486 -c depca.c"
2086  * End:
2087  */