Return to depca.c CVS log

Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net

Annotation of Gnu-Mach/linux/src/drivers/net/depca.c, revision 1.1

1.1     ! root        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 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 [email protected]
        !            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:     TO DO:
        !           159:     ------
        !           160: 
        !           161: 
        !           162:     Revision History
        !           163:     ----------------
        !           164: 
        !           165:     Version   Date        Description
        !           166:   
        !           167:       0.1     25-jan-94   Initial writing.
        !           168:       0.2     27-jan-94   Added LANCE TX hardware buffer chaining.
        !           169:       0.3      1-feb-94   Added multiple DEPCA support.
        !           170:       0.31     4-feb-94   Added DE202 recognition.
        !           171:       0.32    19-feb-94   Tidy up. Improve multi-DEPCA support.
        !           172:       0.33    25-feb-94   Fix DEPCA ethernet ROM counter enable.
        !           173:                           Add jabber packet fix from [email protected]
        !           174:                          and [email protected]
        !           175:       0.34     7-mar-94   Fix DEPCA max network memory RAM & NICSR access.
        !           176:       0.35     8-mar-94   Added DE201 recognition. Tidied up.
        !           177:       0.351   30-apr-94   Added EISA support. Added DE422 recognition.
        !           178:       0.36    16-may-94   DE422 fix released.
        !           179:       0.37    22-jul-94   Added MODULE support
        !           180:       0.38    15-aug-94   Added DBR ROM switch in depca_close(). 
        !           181:                           Multi DEPCA bug fix.
        !           182:       0.38axp 15-sep-94   Special version for Alpha AXP Linux V1.0.
        !           183:       0.381   12-dec-94   Added DE101 recognition, fix multicast bug.
        !           184:       0.382    9-feb-95   Fix recognition bug reported by <[email protected]>.
        !           185:       0.383   22-feb-95   Fix for conflict with VESA SCSI reported by
        !           186:                           <[email protected]>
        !           187:       0.384   17-mar-95   Fix a ring full bug reported by <[email protected]>
        !           188:       0.385    3-apr-95   Fix a recognition bug reported by 
        !           189:                                                 <[email protected]>
        !           190:       0.386   21-apr-95   Fix the last fix...sorry, must be galloping senility
        !           191:       0.40    25-May-95   Rewrite for portability & updated.
        !           192:                           ALPHA support from <[email protected]>
        !           193:       0.41    26-Jun-95   Added verify_area() calls in depca_ioctl() from
        !           194:                           suggestion by <[email protected]>
        !           195:       0.42    27-Dec-95   Add 'mem' shared memory assignment for loadable 
        !           196:                           modules.
        !           197:                           Add 'adapter_name' for loadable modules when no PROM.
        !           198:                          Both above from a suggestion by 
        !           199:                          <[email protected]>.
        !           200:                          Add new multicasting code.
        !           201:       0.421   22-Apr-96          Fix alloc_device() bug <[email protected]>
        !           202:       0.422   29-Apr-96          Fix depca_hw_init() bug <[email protected]>
        !           203:       0.423    7-Jun-96   Fix module load bug <[email protected]>
        !           204:       0.43    16-Aug-96   Update alloc_device() to conform to de4x5.c
        !           205: 
        !           206:     =========================================================================
        !           207: */
        !           208: 
        !           209: static const char *version = "depca.c:v0.43 96/8/16 [email protected]\n";
        !           210: 
        !           211: #include <linux/module.h>
        !           212: 
        !           213: #include <linux/kernel.h>
        !           214: #include <linux/sched.h>
        !           215: #include <linux/string.h>
        !           216: #include <linux/ptrace.h>
        !           217: #include <linux/errno.h>
        !           218: #include <linux/ioport.h>
        !           219: #include <linux/malloc.h>
        !           220: #include <linux/interrupt.h>
        !           221: #include <linux/delay.h>
        !           222: #include <asm/segment.h>
        !           223: #include <asm/bitops.h>
        !           224: #include <asm/io.h>
        !           225: #include <asm/dma.h>
        !           226: 
        !           227: #include <linux/netdevice.h>
        !           228: #include <linux/etherdevice.h>
        !           229: #include <linux/skbuff.h>
        !           230: 
        !           231: #include <linux/time.h>
        !           232: #include <linux/types.h>
        !           233: #include <linux/unistd.h>
        !           234: #include <linux/ctype.h>
        !           235: 
        !           236: #include "depca.h"
        !           237: 
        !           238: #ifdef DEPCA_DEBUG
        !           239: static int depca_debug = DEPCA_DEBUG;
        !           240: #else
        !           241: static int depca_debug = 1;
        !           242: #endif
        !           243: 
        !           244: #define DEPCA_NDA 0xffe0            /* No Device Address */
        !           245: 
        !           246: /*
        !           247: ** Ethernet PROM defines
        !           248: */
        !           249: #define PROBE_LENGTH    32
        !           250: #define ETH_PROM_SIG    0xAA5500FFUL
        !           251: 
        !           252: /*
        !           253: ** Set the number of Tx and Rx buffers. Ensure that the memory requested
        !           254: ** here is <= to the amount of shared memory set up by the board switches.
        !           255: ** The number of descriptors MUST BE A POWER OF 2.
        !           256: **
        !           257: ** total_memory = NUM_RX_DESC*(8+RX_BUFF_SZ) + NUM_TX_DESC*(8+TX_BUFF_SZ)
        !           258: */
        !           259: #define NUM_RX_DESC     8               /* Number of RX descriptors */
        !           260: #define NUM_TX_DESC     8               /* Number of TX descriptors */
        !           261: #define RX_BUFF_SZ     1536            /* Buffer size for each Rx buffer */
        !           262: #define TX_BUFF_SZ     1536            /* Buffer size for each Tx buffer */
        !           263: 
        !           264: #define CRC_POLYNOMIAL_BE 0x04c11db7UL  /* Ethernet CRC, big endian */
        !           265: #define CRC_POLYNOMIAL_LE 0xedb88320UL  /* Ethernet CRC, little endian */
        !           266: 
        !           267: /*
        !           268: ** EISA bus defines
        !           269: */
        !           270: #define DEPCA_EISA_IO_PORTS 0x0c00       /* I/O port base address, slot 0 */
        !           271: #define MAX_EISA_SLOTS 16
        !           272: #define EISA_SLOT_INC 0x1000
        !           273: 
        !           274: /*
        !           275: ** ISA Bus defines
        !           276: */
        !           277: #define DEPCA_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0xe0000,0x00000}
        !           278: #define DEPCA_IO_PORTS {0x300, 0x200, 0}
        !           279: #define DEPCA_TOTAL_SIZE 0x10
        !           280: static short mem_chkd = 0;
        !           281: 
        !           282: /*
        !           283: ** Name <-> Adapter mapping
        !           284: */
        !           285: #define DEPCA_SIGNATURE {"DEPCA",\
        !           286:                         "DE100","DE101",\
        !           287:                          "DE200","DE201","DE202",\
        !           288:                         "DE210",\
        !           289:                          "DE422",\
        !           290:                          ""}
        !           291: static enum {DEPCA, de100, de101, de200, de201, de202, de210, de422, unknown} adapter;
        !           292: 
        !           293: /*
        !           294: ** Miscellaneous info...
        !           295: */
        !           296: #define DEPCA_STRLEN 16
        !           297: #define MAX_NUM_DEPCAS 2
        !           298: 
        !           299: /*
        !           300: ** Memory Alignment. Each descriptor is 4 longwords long. To force a
        !           301: ** particular alignment on the TX descriptor, adjust DESC_SKIP_LEN and
        !           302: ** DESC_ALIGN. ALIGN aligns the start address of the private memory area
        !           303: ** and hence the RX descriptor ring's first entry. 
        !           304: */
        !           305: #define ALIGN4      ((u_long)4 - 1)       /* 1 longword align */
        !           306: #define ALIGN8      ((u_long)8 - 1)       /* 2 longword (quadword) align */
        !           307: #define ALIGN         ALIGN8              /* Keep the LANCE happy... */
        !           308: 
        !           309: /*
        !           310: ** The DEPCA Rx and Tx ring descriptors. 
        !           311: */
        !           312: struct depca_rx_desc {
        !           313:     volatile s32 base;
        !           314:     s16 buf_length;            /* This length is negative 2's complement! */
        !           315:     s16 msg_length;            /* This length is "normal". */
        !           316: };
        !           317: 
        !           318: struct depca_tx_desc {
        !           319:     volatile s32 base;
        !           320:     s16 length;                        /* This length is negative 2's complement! */
        !           321:     s16 misc;                   /* Errors and TDR info */
        !           322: };
        !           323: 
        !           324: #define LA_MASK 0x0000ffff      /* LANCE address mask for mapping network RAM
        !           325:                                   to LANCE memory address space */
        !           326: 
        !           327: /*
        !           328: ** The Lance initialization block, described in databook, in common memory.
        !           329: */
        !           330: struct depca_init {
        !           331:     u16 mode;                  /* Mode register */
        !           332:     u8  phys_addr[ETH_ALEN];   /* Physical ethernet address */
        !           333:     u8  mcast_table[8];                /* Multicast Hash Table. */
        !           334:     u32 rx_ring;               /* Rx ring base pointer & ring length */
        !           335:     u32 tx_ring;               /* Tx ring base pointer & ring length */
        !           336: };
        !           337: 
        !           338: #define DEPCA_PKT_STAT_SZ 16
        !           339: #define DEPCA_PKT_BIN_SZ  128                /* Should be >=100 unless you
        !           340:                                                 increase DEPCA_PKT_STAT_SZ */
        !           341: struct depca_private {
        !           342:     char devname[DEPCA_STRLEN];    /* Device Product String                  */
        !           343:     char adapter_name[DEPCA_STRLEN];/* /proc/ioports string                  */
        !           344:     char adapter;                  /* Adapter type                           */
        !           345:     struct depca_rx_desc *rx_ring; /* Pointer to start of RX descriptor ring */
        !           346:     struct depca_tx_desc *tx_ring; /* Pointer to start of TX descriptor ring */
        !           347:     struct depca_init  init_block;/* Shadow Initialization block            */
        !           348:     char *rx_memcpy[NUM_RX_DESC];  /* CPU virt address of sh'd memory buffs  */
        !           349:     char *tx_memcpy[NUM_TX_DESC];  /* CPU virt address of sh'd memory buffs  */
        !           350:     u_long bus_offset;             /* (E)ISA bus address offset vs LANCE     */
        !           351:     u_long sh_mem;                /* Physical start addr of shared mem area */
        !           352:     u_long dma_buffs;             /* LANCE Rx and Tx buffers start address. */
        !           353:     int        rx_new, tx_new;            /* The next free ring entry               */
        !           354:     int rx_old, tx_old;                   /* The ring entries to be free()ed.       */
        !           355:     struct enet_statistics stats;
        !           356:     struct {                       /* Private stats counters                 */
        !           357:        u32 bins[DEPCA_PKT_STAT_SZ];
        !           358:        u32 unicast;
        !           359:        u32 multicast;
        !           360:        u32 broadcast;
        !           361:        u32 excessive_collisions;
        !           362:        u32 tx_underruns;
        !           363:        u32 excessive_underruns;
        !           364:     } pktStats;
        !           365:     int txRingMask;                /* TX ring mask                           */
        !           366:     int rxRingMask;                /* RX ring mask                           */
        !           367:     s32 rx_rlen;                   /* log2(rxRingMask+1) for the descriptors */
        !           368:     s32 tx_rlen;                   /* log2(txRingMask+1) for the descriptors */
        !           369: };
        !           370: 
        !           371: /*
        !           372: ** The transmit ring full condition is described by the tx_old and tx_new
        !           373: ** pointers by:
        !           374: **    tx_old            = tx_new    Empty ring
        !           375: **    tx_old            = tx_new+1  Full ring
        !           376: **    tx_old+txRingMask = tx_new    Full ring  (wrapped condition)
        !           377: */
        !           378: #define TX_BUFFS_AVAIL ((lp->tx_old<=lp->tx_new)?\
        !           379:                         lp->tx_old+lp->txRingMask-lp->tx_new:\
        !           380:                          lp->tx_old               -lp->tx_new-1)
        !           381: 
        !           382: /*
        !           383: ** Public Functions
        !           384: */
        !           385: static int    depca_open(struct device *dev);
        !           386: static int    depca_start_xmit(struct sk_buff *skb, struct device *dev);
        !           387: static void   depca_interrupt(int irq, void *dev_id, struct pt_regs * regs);
        !           388: static int    depca_close(struct device *dev);
        !           389: static int    depca_ioctl(struct device *dev, struct ifreq *rq, int cmd);
        !           390: static struct enet_statistics *depca_get_stats(struct device *dev);
        !           391: static void   set_multicast_list(struct device *dev);
        !           392: 
        !           393: /*
        !           394: ** Private functions
        !           395: */
        !           396: static int    depca_hw_init(struct device *dev, u_long ioaddr);
        !           397: static void   depca_init_ring(struct device *dev);
        !           398: static int    depca_rx(struct device *dev);
        !           399: static int    depca_tx(struct device *dev);
        !           400: 
        !           401: static void   LoadCSRs(struct device *dev);
        !           402: static int    InitRestartDepca(struct device *dev);
        !           403: static void   DepcaSignature(char *name, u_long paddr);
        !           404: static int    DevicePresent(u_long ioaddr);
        !           405: static int    get_hw_addr(struct device *dev);
        !           406: static int    EISA_signature(char *name, s32 eisa_id);
        !           407: static void   SetMulticastFilter(struct device *dev);
        !           408: static void   isa_probe(struct device *dev, u_long iobase);
        !           409: static void   eisa_probe(struct device *dev, u_long iobase);
        !           410: static struct device *alloc_device(struct device *dev, u_long iobase);
        !           411: static int    depca_dev_index(char *s);
        !           412: static struct device *insert_device(struct device *dev, u_long iobase, int (*init)(struct device *));
        !           413: static int    load_packet(struct device *dev, struct sk_buff *skb);
        !           414: static void   depca_dbg_open(struct device *dev);
        !           415: 
        !           416: #ifdef MODULE
        !           417: int           init_module(void);
        !           418: void          cleanup_module(void);
        !           419: static int    autoprobed = 1, loading_module = 1;
        !           420: # else
        !           421: static u_char de1xx_irq[] = {2,3,4,5,7,9,0};
        !           422: static u_char de2xx_irq[] = {5,9,10,11,15,0};
        !           423: static u_char de422_irq[] = {5,9,10,11,0};
        !           424: static u_char *depca_irq;
        !           425: static int    autoprobed = 0, loading_module = 0;
        !           426: #endif /* MODULE */
        !           427: 
        !           428: static char   name[DEPCA_STRLEN];
        !           429: static int    num_depcas = 0, num_eth = 0;
        !           430: static int    mem=0;                       /* For loadable module assignment
        !           431:                                               use insmod mem=0x????? .... */
        !           432: static char   *adapter_name = '\0';        /* If no PROM when loadable module
        !           433:                                              use insmod adapter_name=DE??? ...
        !           434:                                           */
        !           435: /*
        !           436: ** Miscellaneous defines...
        !           437: */
        !           438: #define STOP_DEPCA \
        !           439:     outw(CSR0, DEPCA_ADDR);\
        !           440:     outw(STOP, DEPCA_DATA)
        !           441: 
        !           442: 
        !           443: 
        !           444: int depca_probe(struct device *dev)
        !           445: {
        !           446:   int tmp = num_depcas, status = -ENODEV;
        !           447:   u_long iobase = dev->base_addr;
        !           448: 
        !           449:   if ((iobase == 0) && loading_module){
        !           450:     printk("Autoprobing is not supported when loading a module based driver.\n");
        !           451:     status = -EIO;
        !           452:   } else {
        !           453:     isa_probe(dev, iobase);
        !           454:     eisa_probe(dev, iobase);
        !           455: 
        !           456:     if ((tmp == num_depcas) && (iobase != 0) && loading_module) {
        !           457:       printk("%s: depca_probe() cannot find device at 0x%04lx.\n", dev->name, 
        !           458:                                                                       iobase);
        !           459:     }
        !           460: 
        !           461:     /*
        !           462:     ** Walk the device list to check that at least one device
        !           463:     ** initialised OK
        !           464:     */
        !           465:     for (; (dev->priv == NULL) && (dev->next != NULL); dev = dev->next);
        !           466: 
        !           467:     if (dev->priv) status = 0;
        !           468:     if (iobase == 0) autoprobed = 1;
        !           469:   }
        !           470: 
        !           471:   return status;
        !           472: }
        !           473: 
        !           474: static int
        !           475: depca_hw_init(struct device *dev, u_long ioaddr)
        !           476: {
        !           477:   struct depca_private *lp;
        !           478:   int i, j, offset, netRAM, mem_len, status=0;
        !           479:   s16 nicsr;
        !           480:   u_long mem_start=0, mem_base[] = DEPCA_RAM_BASE_ADDRESSES;
        !           481: 
        !           482:   STOP_DEPCA;
        !           483: 
        !           484:   nicsr = inb(DEPCA_NICSR);
        !           485:   nicsr = ((nicsr & ~SHE & ~RBE & ~IEN) | IM);
        !           486:   outb(nicsr, DEPCA_NICSR);
        !           487: 
        !           488:   if (inw(DEPCA_DATA) == STOP) {
        !           489:     do {
        !           490:       strcpy(name, (adapter_name ? adapter_name : ""));
        !           491:       mem_start = (mem ? mem & 0xf0000 : mem_base[mem_chkd++]);
        !           492:       DepcaSignature(name, mem_start);
        !           493:     } while (!mem && mem_base[mem_chkd] && (adapter == unknown));
        !           494: 
        !           495:     if ((adapter != unknown) && mem_start) {        /* found a DEPCA device */
        !           496:       dev->base_addr = ioaddr;
        !           497: 
        !           498:       if ((ioaddr&0x0fff)==DEPCA_EISA_IO_PORTS) {/* EISA slot address */
        !           499:        printk("%s: %s at 0x%04lx (EISA slot %d)", 
        !           500:                            dev->name, name, ioaddr, (int)((ioaddr>>12)&0x0f));
        !           501:       } else {                             /* ISA port address */
        !           502:        printk("%s: %s at 0x%04lx", dev->name, name, ioaddr);
        !           503:       }
        !           504: 
        !           505:       printk(", h/w address ");
        !           506:       status = get_hw_addr(dev);
        !           507:       for (i=0; i<ETH_ALEN - 1; i++) { /* get the ethernet address */
        !           508:        printk("%2.2x:", dev->dev_addr[i]);
        !           509:       }
        !           510:       printk("%2.2x", dev->dev_addr[i]);
        !           511: 
        !           512:       if (status == 0) {
        !           513:        /* Set up the maximum amount of network RAM(kB) */
        !           514:        netRAM = ((adapter != DEPCA) ? 64 : 48);
        !           515:        if ((nicsr & _128KB) && (adapter == de422)) netRAM = 128;
        !           516:        offset = 0x0000;
        !           517: 
        !           518:        /* Shared Memory Base Address */ 
        !           519:        if (nicsr & BUF) {
        !           520:          offset = 0x8000;              /* 32kbyte RAM offset*/
        !           521:          nicsr &= ~BS;                 /* DEPCA RAM in top 32k */
        !           522:          netRAM -= 32;
        !           523:        }
        !           524:        mem_start += offset;            /* (E)ISA start address */
        !           525:        if ((mem_len = (NUM_RX_DESC*(sizeof(struct depca_rx_desc)+RX_BUFF_SZ) +
        !           526:                        NUM_TX_DESC*(sizeof(struct depca_tx_desc)+TX_BUFF_SZ) +
        !           527:                        sizeof(struct depca_init))) <=
        !           528:            (netRAM<<10)) {
        !           529:          printk(",\n      has %dkB RAM at 0x%.5lx", netRAM, mem_start);
        !           530: 
        !           531:          /* Enable the shadow RAM. */
        !           532:          if (adapter != DEPCA) {
        !           533:            nicsr |= SHE;
        !           534:            outb(nicsr, DEPCA_NICSR);
        !           535:          }
        !           536:  
        !           537:          /* Define the device private memory */
        !           538:          dev->priv = (void *) kmalloc(sizeof(struct depca_private), GFP_KERNEL);
        !           539:          if (dev->priv == NULL)
        !           540:            return -ENOMEM;
        !           541:          lp = (struct depca_private *)dev->priv;
        !           542:          memset((char *)dev->priv, 0, sizeof(struct depca_private));
        !           543:          lp->adapter = adapter;
        !           544:          sprintf(lp->adapter_name,"%s (%s)", name, dev->name);
        !           545:          request_region(ioaddr, DEPCA_TOTAL_SIZE, lp->adapter_name);
        !           546: 
        !           547:          /* Initialisation Block */
        !           548:          lp->sh_mem = mem_start;
        !           549:          mem_start += sizeof(struct depca_init);
        !           550: 
        !           551:          /* Tx & Rx descriptors (aligned to a quadword boundary) */
        !           552:          mem_start = (mem_start + ALIGN) & ~ALIGN;
        !           553:          lp->rx_ring = (struct depca_rx_desc *)mem_start;
        !           554: 
        !           555:          mem_start += (sizeof(struct depca_rx_desc) * NUM_RX_DESC);
        !           556:          lp->tx_ring = (struct depca_tx_desc *)mem_start;
        !           557: 
        !           558:          mem_start += (sizeof(struct depca_tx_desc) * NUM_TX_DESC);
        !           559:          lp->bus_offset = mem_start & 0x00ff0000;
        !           560:          mem_start &= LA_MASK;           /* LANCE re-mapped start address */
        !           561: 
        !           562:          lp->dma_buffs = mem_start;
        !           563: 
        !           564:          /* Finish initialising the ring information. */
        !           565:          lp->rxRingMask = NUM_RX_DESC - 1;
        !           566:          lp->txRingMask = NUM_TX_DESC - 1;
        !           567: 
        !           568:          /* Calculate Tx/Rx RLEN size for the descriptors. */
        !           569:          for (i=0, j = lp->rxRingMask; j>0; i++) {
        !           570:            j >>= 1;
        !           571:          }
        !           572:          lp->rx_rlen = (s32)(i << 29);
        !           573:          for (i=0, j = lp->txRingMask; j>0; i++) {
        !           574:            j >>= 1;
        !           575:          }
        !           576:          lp->tx_rlen = (s32)(i << 29);
        !           577: 
        !           578:          /* Load the initialisation block */
        !           579:          depca_init_ring(dev);
        !           580: 
        !           581:          /* Initialise the control and status registers */
        !           582:          LoadCSRs(dev);
        !           583: 
        !           584:          /* Enable DEPCA board interrupts for autoprobing */
        !           585:          nicsr = ((nicsr & ~IM)|IEN);
        !           586:          outb(nicsr, DEPCA_NICSR);
        !           587: 
        !           588:          /* To auto-IRQ we enable the initialization-done and DMA err,
        !           589:             interrupts. For now we will always get a DMA error. */
        !           590:          if (dev->irq < 2) {
        !           591: #ifndef MODULE
        !           592:            unsigned char irqnum;
        !           593:            autoirq_setup(0);
        !           594:            
        !           595:            /* Assign the correct irq list */
        !           596:            switch (lp->adapter) {
        !           597:            case DEPCA:
        !           598:            case de100:
        !           599:            case de101:
        !           600:              depca_irq = de1xx_irq;
        !           601:              break;
        !           602:            case de200:
        !           603:            case de201:
        !           604:            case de202:
        !           605:            case de210:
        !           606:              depca_irq = de2xx_irq;
        !           607:              break;
        !           608:            case de422:
        !           609:              depca_irq = de422_irq;
        !           610:              break;
        !           611:            }
        !           612: 
        !           613:            /* Trigger an initialization just for the interrupt. */
        !           614:            outw(INEA | INIT, DEPCA_DATA);
        !           615:          
        !           616:            irqnum = autoirq_report(1);
        !           617:            if (!irqnum) {
        !           618:              printk(" and failed to detect IRQ line.\n");
        !           619:              status = -ENXIO;
        !           620:            } else {
        !           621:              for (dev->irq=0,i=0; (depca_irq[i]) && (!dev->irq); i++) {
        !           622:                if (irqnum == depca_irq[i]) {
        !           623:                  dev->irq = irqnum;
        !           624:                  printk(" and uses IRQ%d.\n", dev->irq);
        !           625:                }
        !           626:              }
        !           627:              
        !           628:              if (!dev->irq) {
        !           629:                printk(" but incorrect IRQ line detected.\n");
        !           630:                status = -ENXIO;
        !           631:              }
        !           632:            }
        !           633: #endif /* MODULE */
        !           634:          } else {
        !           635:            printk(" and assigned IRQ%d.\n", dev->irq);
        !           636:          }
        !           637:          if (status) release_region(ioaddr, DEPCA_TOTAL_SIZE);
        !           638:        } else {
        !           639:          printk(",\n      requests %dkB RAM: only %dkB is available!\n", 
        !           640:                                                        (mem_len>>10), netRAM);
        !           641:          status = -ENXIO;
        !           642:        }
        !           643:       } else {
        !           644:        printk("      which has an Ethernet PROM CRC error.\n");
        !           645:        status = -ENXIO;
        !           646:       }
        !           647:     } else {
        !           648:       status = -ENXIO;
        !           649:     }
        !           650:     if (!status) {
        !           651:       if (depca_debug > 1) {
        !           652:        printk(version);
        !           653:       }
        !           654: 
        !           655:       /* The DEPCA-specific entries in the device structure. */
        !           656:       dev->open = &depca_open;
        !           657:       dev->hard_start_xmit = &depca_start_xmit;
        !           658:       dev->stop = &depca_close;
        !           659:       dev->get_stats = &depca_get_stats;
        !           660:       dev->set_multicast_list = &set_multicast_list;
        !           661:       dev->do_ioctl = &depca_ioctl;
        !           662: 
        !           663:       dev->mem_start = 0;
        !           664:        
        !           665:       /* Fill in the generic field of the device structure. */
        !           666:       ether_setup(dev);
        !           667:     } else {                           /* Incorrectly initialised hardware */
        !           668:       if (dev->priv) {
        !           669:        kfree_s(dev->priv, sizeof(struct depca_private));
        !           670:        dev->priv = NULL;
        !           671:       }
        !           672:     }
        !           673:   } else {
        !           674:     status = -ENXIO;
        !           675:   }
        !           676: 
        !           677:   return status;
        !           678: }
        !           679: 
        !           680: 
        !           681: static int
        !           682: depca_open(struct device *dev)
        !           683: {
        !           684:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !           685:   u_long ioaddr = dev->base_addr;
        !           686:   s16 nicsr;
        !           687:   int status = 0;
        !           688: 
        !           689:   irq2dev_map[dev->irq] = dev;
        !           690:   STOP_DEPCA;
        !           691:   nicsr = inb(DEPCA_NICSR);
        !           692: 
        !           693:   /* Make sure the shadow RAM is enabled */
        !           694:   if (adapter != DEPCA) {
        !           695:     nicsr |= SHE;
        !           696:     outb(nicsr, DEPCA_NICSR);
        !           697:   }
        !           698: 
        !           699:   /* Re-initialize the DEPCA... */
        !           700:   depca_init_ring(dev);
        !           701:   LoadCSRs(dev);
        !           702: 
        !           703:   depca_dbg_open(dev);
        !           704: 
        !           705:   if (request_irq(dev->irq, &depca_interrupt, 0, lp->adapter_name, NULL)) {
        !           706:     printk("depca_open(): Requested IRQ%d is busy\n",dev->irq);
        !           707:     status = -EAGAIN;
        !           708:   } else {
        !           709: 
        !           710:     /* Enable DEPCA board interrupts and turn off LED */
        !           711:     nicsr = ((nicsr & ~IM & ~LED)|IEN);
        !           712:     outb(nicsr, DEPCA_NICSR);
        !           713:     outw(CSR0,DEPCA_ADDR);
        !           714:     
        !           715:     dev->tbusy = 0;                         
        !           716:     dev->interrupt = 0;
        !           717:     dev->start = 1;
        !           718:     
        !           719:     status = InitRestartDepca(dev);
        !           720: 
        !           721:     if (depca_debug > 1){
        !           722:       printk("CSR0: 0x%4.4x\n",inw(DEPCA_DATA));
        !           723:       printk("nicsr: 0x%02x\n",inb(DEPCA_NICSR));
        !           724:     }
        !           725:   }
        !           726: 
        !           727:   MOD_INC_USE_COUNT;
        !           728:   
        !           729:   return status;
        !           730: }
        !           731: 
        !           732: /* Initialize the lance Rx and Tx descriptor rings. */
        !           733: static void
        !           734: depca_init_ring(struct device *dev)
        !           735: {
        !           736:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !           737:   u_int i;
        !           738:   u_long p;
        !           739: 
        !           740:   /* Lock out other processes whilst setting up the hardware */
        !           741:   set_bit(0, (void *)&dev->tbusy);
        !           742: 
        !           743:   lp->rx_new = lp->tx_new = 0;
        !           744:   lp->rx_old = lp->tx_old = 0;
        !           745: 
        !           746:   /* Initialize the base addresses and length of each buffer in the ring */
        !           747:   for (i = 0; i <= lp->rxRingMask; i++) {
        !           748:     writel((p=lp->dma_buffs+i*RX_BUFF_SZ) | R_OWN, &lp->rx_ring[i].base);
        !           749:     writew(-RX_BUFF_SZ, &lp->rx_ring[i].buf_length);
        !           750:     lp->rx_memcpy[i]=(char *)(p+lp->bus_offset);
        !           751:   }
        !           752:   for (i = 0; i <= lp->txRingMask; i++) {
        !           753:     writel((p=lp->dma_buffs+(i+lp->txRingMask+1)*TX_BUFF_SZ) & 0x00ffffff,
        !           754:                                                         &lp->tx_ring[i].base);
        !           755:     lp->tx_memcpy[i]=(char *)(p+lp->bus_offset);
        !           756:   }
        !           757: 
        !           758:   /* Set up the initialization block */
        !           759:   lp->init_block.rx_ring = ((u32)((u_long)lp->rx_ring)&LA_MASK) | lp->rx_rlen;
        !           760:   lp->init_block.tx_ring = ((u32)((u_long)lp->tx_ring)&LA_MASK) | lp->tx_rlen;
        !           761: 
        !           762:   SetMulticastFilter(dev);
        !           763: 
        !           764:   for (i = 0; i < ETH_ALEN; i++) {
        !           765:     lp->init_block.phys_addr[i] = dev->dev_addr[i];
        !           766:   }
        !           767: 
        !           768:   lp->init_block.mode = 0x0000;            /* Enable the Tx and Rx */
        !           769: 
        !           770:   return;
        !           771: }
        !           772: 
        !           773: /* 
        !           774: ** Writes a socket buffer to TX descriptor ring and starts transmission 
        !           775: */
        !           776: static int
        !           777: depca_start_xmit(struct sk_buff *skb, struct device *dev)
        !           778: {
        !           779:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !           780:   u_long ioaddr = dev->base_addr;
        !           781:   int status = 0;
        !           782: 
        !           783:   /* Transmitter timeout, serious problems. */
        !           784:   if (dev->tbusy) {
        !           785:     int tickssofar = jiffies - dev->trans_start;
        !           786:     if (tickssofar < 1*HZ) {
        !           787:       status = -1;
        !           788:     } else {
        !           789:       printk("%s: transmit timed out, status %04x, resetting.\n",
        !           790:             dev->name, inw(DEPCA_DATA));
        !           791:        
        !           792:       STOP_DEPCA;
        !           793:       depca_init_ring(dev);
        !           794:       LoadCSRs(dev);
        !           795:       dev->interrupt = UNMASK_INTERRUPTS;
        !           796:       dev->start = 1;
        !           797:       dev->tbusy=0;
        !           798:       dev->trans_start = jiffies;
        !           799:       InitRestartDepca(dev);
        !           800:       dev_kfree_skb(skb, FREE_WRITE);
        !           801:     }
        !           802:     return status;
        !           803:   } else if (skb == NULL) {
        !           804:     dev_tint(dev);
        !           805:   } else if (skb->len > 0) {
        !           806:     /* Enforce 1 process per h/w access */
        !           807:     if (set_bit(0, (void*)&dev->tbusy) != 0) {
        !           808:       printk("%s: Transmitter access conflict.\n", dev->name);
        !           809:       status = -1;
        !           810:     } else {
        !           811:       if (TX_BUFFS_AVAIL) {                    /* Fill in a Tx ring entry */
        !           812:        status = load_packet(dev, skb);
        !           813: 
        !           814:        if (!status) {
        !           815:          /* Trigger an immediate send demand. */
        !           816:          outw(CSR0, DEPCA_ADDR);
        !           817:          outw(INEA | TDMD, DEPCA_DATA);
        !           818:          
        !           819:          dev->trans_start = jiffies;
        !           820:          dev_kfree_skb(skb, FREE_WRITE);
        !           821:        }
        !           822:        if (TX_BUFFS_AVAIL) {
        !           823:          dev->tbusy=0;
        !           824:        }  
        !           825:       } else {
        !           826:        status = -1;
        !           827:       }
        !           828:     }
        !           829:   }
        !           830:   
        !           831:   return status;
        !           832: }
        !           833: 
        !           834: /*
        !           835: ** The DEPCA interrupt handler. 
        !           836: */
        !           837: static void
        !           838: depca_interrupt(int irq, void *dev_id, struct pt_regs * regs)
        !           839: {
        !           840:   struct device *dev = (struct device *)(irq2dev_map[irq]);
        !           841:   struct depca_private *lp;
        !           842:   s16 csr0, nicsr;
        !           843:   u_long ioaddr;
        !           844: 
        !           845:   if (dev == NULL) {
        !           846:     printk ("depca_interrupt(): irq %d for unknown device.\n", irq);
        !           847:   } else {
        !           848:     lp = (struct depca_private *)dev->priv;
        !           849:     ioaddr = dev->base_addr;
        !           850:     
        !           851:     if (dev->interrupt)
        !           852:       printk("%s: Re-entering the interrupt handler.\n", dev->name);
        !           853: 
        !           854:     dev->interrupt = MASK_INTERRUPTS;
        !           855: 
        !           856:     /* mask the DEPCA board interrupts and turn on the LED */
        !           857:     nicsr = inb(DEPCA_NICSR);
        !           858:     nicsr |= (IM|LED);
        !           859:     outb(nicsr, DEPCA_NICSR);
        !           860: 
        !           861:     outw(CSR0, DEPCA_ADDR);
        !           862:     csr0 = inw(DEPCA_DATA);
        !           863: 
        !           864:     /* Acknowledge all of the current interrupt sources ASAP. */
        !           865:     outw(csr0 & INTE, DEPCA_DATA);
        !           866: 
        !           867:     if (csr0 & RINT)                  /* Rx interrupt (packet arrived) */
        !           868:       depca_rx(dev);
        !           869: 
        !           870:     if (csr0 & TINT)                  /* Tx interrupt (packet sent) */
        !           871:       depca_tx(dev);
        !           872: 
        !           873:     if ((TX_BUFFS_AVAIL >= 0) && dev->tbusy) { /* any resources available? */
        !           874:       dev->tbusy = 0;                  /* clear TX busy flag */
        !           875:       mark_bh(NET_BH);
        !           876:     }
        !           877: 
        !           878:     /* Unmask the DEPCA board interrupts and turn off the LED */
        !           879:     nicsr = (nicsr & ~IM & ~LED);
        !           880:     outb(nicsr, DEPCA_NICSR);
        !           881: 
        !           882:     dev->interrupt = UNMASK_INTERRUPTS;
        !           883:   }
        !           884: 
        !           885:   return;
        !           886: }
        !           887: 
        !           888: static int
        !           889: depca_rx(struct device *dev)
        !           890: {
        !           891:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !           892:   int i, entry;
        !           893:   s32 status;
        !           894: 
        !           895:   for (entry=lp->rx_new; 
        !           896:        !(readl(&lp->rx_ring[entry].base) & R_OWN);
        !           897:        entry=lp->rx_new){
        !           898:     status = readl(&lp->rx_ring[entry].base) >> 16 ;
        !           899:     if (status & R_STP) {                      /* Remember start of frame */
        !           900:       lp->rx_old = entry;
        !           901:     }
        !           902:     if (status & R_ENP) {                      /* Valid frame status */
        !           903:       if (status & R_ERR) {                   /* There was an error. */
        !           904:        lp->stats.rx_errors++;                 /* Update the error stats. */
        !           905:        if (status & R_FRAM) lp->stats.rx_frame_errors++;
        !           906:        if (status & R_OFLO) lp->stats.rx_over_errors++;
        !           907:        if (status & R_CRC)  lp->stats.rx_crc_errors++;
        !           908:        if (status & R_BUFF) lp->stats.rx_fifo_errors++;
        !           909:       } else { 
        !           910:        short len, pkt_len = readw(&lp->rx_ring[entry].msg_length);
        !           911:        struct sk_buff *skb;
        !           912: 
        !           913:        skb = dev_alloc_skb(pkt_len+2);
        !           914:        if (skb != NULL) {
        !           915:          unsigned char *buf;
        !           916:          skb_reserve(skb,2);               /* 16 byte align the IP header */
        !           917:          buf = skb_put(skb,pkt_len);
        !           918:          skb->dev = dev;
        !           919:          if (entry < lp->rx_old) {         /* Wrapped buffer */
        !           920:            len = (lp->rxRingMask - lp->rx_old + 1) * RX_BUFF_SZ;
        !           921:            memcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], len);
        !           922:            memcpy_fromio(buf + len, lp->rx_memcpy[0], pkt_len-len);
        !           923:          } else {                          /* Linear buffer */
        !           924:            memcpy_fromio(buf, lp->rx_memcpy[lp->rx_old], pkt_len);
        !           925:          }
        !           926: 
        !           927:          /* 
        !           928:          ** Notify the upper protocol layers that there is another 
        !           929:          ** packet to handle
        !           930:          */
        !           931:          skb->protocol=eth_type_trans(skb,dev);
        !           932:          netif_rx(skb);
        !           933:  
        !           934:          /*
        !           935:          ** Update stats
        !           936:          */
        !           937:          lp->stats.rx_packets++;
        !           938:          for (i=1; i<DEPCA_PKT_STAT_SZ-1; i++) {
        !           939:            if (pkt_len < (i*DEPCA_PKT_BIN_SZ)) {
        !           940:              lp->pktStats.bins[i]++;
        !           941:              i = DEPCA_PKT_STAT_SZ;
        !           942:            }
        !           943:          }
        !           944:          if (buf[0] & 0x01) {              /* Multicast/Broadcast */
        !           945:            if ((*(s16 *)&buf[0] == -1) &&
        !           946:                (*(s16 *)&buf[2] == -1) &&
        !           947:                (*(s16 *)&buf[4] == -1)) {
        !           948:              lp->pktStats.broadcast++;
        !           949:            } else {
        !           950:              lp->pktStats.multicast++;
        !           951:            }
        !           952:          } else if ((*(s16 *)&buf[0] == *(s16 *)&dev->dev_addr[0]) &&
        !           953:                     (*(s16 *)&buf[2] == *(s16 *)&dev->dev_addr[2]) &&
        !           954:                     (*(s16 *)&buf[4] == *(s16 *)&dev->dev_addr[4])) {
        !           955:            lp->pktStats.unicast++;
        !           956:          }
        !           957:          
        !           958:          lp->pktStats.bins[0]++;           /* Duplicates stats.rx_packets */
        !           959:          if (lp->pktStats.bins[0] == 0) {  /* Reset counters */
        !           960:            memset((char *)&lp->pktStats, 0, sizeof(lp->pktStats));
        !           961:          }
        !           962:        } else {
        !           963:          printk("%s: Memory squeeze, deferring packet.\n", dev->name);
        !           964:          lp->stats.rx_dropped++;       /* Really, deferred. */
        !           965:          break;
        !           966:        }
        !           967:       }
        !           968:       /* Change buffer ownership for this last frame, back to the adapter */
        !           969:       for (; lp->rx_old!=entry; lp->rx_old=(++lp->rx_old)&lp->rxRingMask) {
        !           970:        writel(readl(&lp->rx_ring[lp->rx_old].base) | R_OWN, 
        !           971:                                                &lp->rx_ring[lp->rx_old].base);
        !           972:       }
        !           973:       writel(readl(&lp->rx_ring[entry].base) | R_OWN, &lp->rx_ring[entry].base);
        !           974:     }
        !           975: 
        !           976:     /*
        !           977:     ** Update entry information
        !           978:     */
        !           979:     lp->rx_new = (++lp->rx_new) & lp->rxRingMask;
        !           980:     }
        !           981: 
        !           982:     return 0;
        !           983: }
        !           984: 
        !           985: /*
        !           986: ** Buffer sent - check for buffer errors.
        !           987: */
        !           988: static int
        !           989: depca_tx(struct device *dev)
        !           990: {
        !           991:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !           992:   int entry;
        !           993:   s32 status;
        !           994:   u_long ioaddr = dev->base_addr;
        !           995: 
        !           996:   for (entry = lp->tx_old; entry != lp->tx_new; entry = lp->tx_old) {
        !           997:     status = readl(&lp->tx_ring[entry].base) >> 16 ;
        !           998: 
        !           999:     if (status < 0) {                          /* Packet not yet sent! */
        !          1000:       break;
        !          1001:     } else if (status & T_ERR) {               /* An error occurred. */
        !          1002:       status = readl(&lp->tx_ring[entry].misc);
        !          1003:       lp->stats.tx_errors++;
        !          1004:       if (status & TMD3_RTRY) lp->stats.tx_aborted_errors++;
        !          1005:       if (status & TMD3_LCAR) lp->stats.tx_carrier_errors++;
        !          1006:       if (status & TMD3_LCOL) lp->stats.tx_window_errors++;
        !          1007:       if (status & TMD3_UFLO) lp->stats.tx_fifo_errors++;
        !          1008:       if (status & (TMD3_BUFF | TMD3_UFLO)) {
        !          1009:        /* Trigger an immediate send demand. */
        !          1010:        outw(CSR0, DEPCA_ADDR);
        !          1011:        outw(INEA | TDMD, DEPCA_DATA);
        !          1012:       }
        !          1013:     } else if (status & (T_MORE | T_ONE)) {
        !          1014:       lp->stats.collisions++;
        !          1015:     } else {
        !          1016:       lp->stats.tx_packets++;
        !          1017:     }
        !          1018: 
        !          1019:     /* Update all the pointers */
        !          1020:     lp->tx_old = (++lp->tx_old) & lp->txRingMask;
        !          1021:   }
        !          1022: 
        !          1023:   return 0;
        !          1024: }
        !          1025: 
        !          1026: static int
        !          1027: depca_close(struct device *dev)
        !          1028: {
        !          1029:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !          1030:   s16 nicsr;
        !          1031:   u_long ioaddr = dev->base_addr;
        !          1032: 
        !          1033:   dev->start = 0;
        !          1034:   dev->tbusy = 1;
        !          1035: 
        !          1036:   outw(CSR0, DEPCA_ADDR);
        !          1037: 
        !          1038:   if (depca_debug > 1) {
        !          1039:     printk("%s: Shutting down ethercard, status was %2.2x.\n",
        !          1040:           dev->name, inw(DEPCA_DATA));
        !          1041:   }
        !          1042: 
        !          1043:   /* 
        !          1044:   ** We stop the DEPCA here -- it occasionally polls
        !          1045:   ** memory if we don't. 
        !          1046:   */
        !          1047:   outw(STOP, DEPCA_DATA);
        !          1048: 
        !          1049:   /*
        !          1050:   ** Give back the ROM in case the user wants to go to DOS
        !          1051:   */
        !          1052:   if (lp->adapter != DEPCA) {
        !          1053:     nicsr = inb(DEPCA_NICSR);
        !          1054:     nicsr &= ~SHE;
        !          1055:     outb(nicsr, DEPCA_NICSR);
        !          1056:   }
        !          1057: 
        !          1058:   /*
        !          1059:   ** Free the associated irq
        !          1060:   */
        !          1061:   free_irq(dev->irq, NULL);
        !          1062:   irq2dev_map[dev->irq] = NULL;
        !          1063: 
        !          1064:   MOD_DEC_USE_COUNT;
        !          1065: 
        !          1066:   return 0;
        !          1067: }
        !          1068: 
        !          1069: static void LoadCSRs(struct device *dev)
        !          1070: {
        !          1071:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !          1072:   u_long ioaddr = dev->base_addr;
        !          1073: 
        !          1074:   outw(CSR1, DEPCA_ADDR);                /* initialisation block address LSW */
        !          1075:   outw((u16)(lp->sh_mem & LA_MASK), DEPCA_DATA);
        !          1076:   outw(CSR2, DEPCA_ADDR);                /* initialisation block address MSW */
        !          1077:   outw((u16)((lp->sh_mem & LA_MASK) >> 16), DEPCA_DATA);
        !          1078:   outw(CSR3, DEPCA_ADDR);                /* ALE control */
        !          1079:   outw(ACON, DEPCA_DATA);
        !          1080: 
        !          1081:   outw(CSR0, DEPCA_ADDR);                /* Point back to CSR0 */
        !          1082: 
        !          1083:   return;
        !          1084: }
        !          1085: 
        !          1086: static int InitRestartDepca(struct device *dev)
        !          1087: {
        !          1088:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !          1089:   u_long ioaddr = dev->base_addr;
        !          1090:   int i, status=0;
        !          1091: 
        !          1092:   /* Copy the shadow init_block to shared memory */
        !          1093:   memcpy_toio((char *)lp->sh_mem, &lp->init_block, sizeof(struct depca_init));
        !          1094: 
        !          1095:   outw(CSR0, DEPCA_ADDR);                /* point back to CSR0 */
        !          1096:   outw(INIT, DEPCA_DATA);                /* initialize DEPCA */
        !          1097: 
        !          1098:   /* wait for lance to complete initialisation */
        !          1099:   for (i=0;(i<100) && !(inw(DEPCA_DATA) & IDON); i++); 
        !          1100: 
        !          1101:   if (i!=100) {
        !          1102:     /* clear IDON by writing a "1", enable interrupts and start lance */
        !          1103:     outw(IDON | INEA | STRT, DEPCA_DATA);
        !          1104:     if (depca_debug > 2) {
        !          1105:       printk("%s: DEPCA open after %d ticks, init block 0x%08lx csr0 %4.4x.\n",
        !          1106:             dev->name, i, lp->sh_mem, inw(DEPCA_DATA));
        !          1107:     }
        !          1108:   } else {
        !          1109:     printk("%s: DEPCA unopen after %d ticks, init block 0x%08lx csr0 %4.4x.\n",
        !          1110:             dev->name, i, lp->sh_mem, inw(DEPCA_DATA));
        !          1111:     status = -1;
        !          1112:   }
        !          1113: 
        !          1114:   return status;
        !          1115: }
        !          1116: 
        !          1117: static struct enet_statistics *
        !          1118: depca_get_stats(struct device *dev)
        !          1119: {
        !          1120:     struct depca_private *lp = (struct depca_private *)dev->priv;
        !          1121: 
        !          1122:     /* Null body since there is no framing error counter */
        !          1123: 
        !          1124:     return &lp->stats;
        !          1125: }
        !          1126: 
        !          1127: /*
        !          1128: ** Set or clear the multicast filter for this adaptor.
        !          1129: */
        !          1130: static void
        !          1131: set_multicast_list(struct device *dev)
        !          1132: {
        !          1133:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !          1134:   u_long ioaddr = dev->base_addr;
        !          1135:   
        !          1136:   if (irq2dev_map[dev->irq] != NULL) {
        !          1137:     while(dev->tbusy);                /* Stop ring access */
        !          1138:     set_bit(0, (void*)&dev->tbusy);
        !          1139:     while(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
        !          1140: 
        !          1141:     STOP_DEPCA;                       /* Temporarily stop the depca.  */
        !          1142:     depca_init_ring(dev);             /* Initialize the descriptor rings */
        !          1143: 
        !          1144:     if (dev->flags & IFF_PROMISC) {   /* Set promiscuous mode */
        !          1145:       lp->init_block.mode |= PROM;
        !          1146:     } else {
        !          1147:       SetMulticastFilter(dev);
        !          1148:       lp->init_block.mode &= ~PROM;   /* Unset promiscuous mode */
        !          1149:     }
        !          1150: 
        !          1151:     LoadCSRs(dev);                    /* Reload CSR3 */
        !          1152:     InitRestartDepca(dev);            /* Resume normal operation. */
        !          1153:     dev->tbusy = 0;                   /* Unlock the TX ring */
        !          1154:   }
        !          1155: }
        !          1156: 
        !          1157: /*
        !          1158: ** Calculate the hash code and update the logical address filter
        !          1159: ** from a list of ethernet multicast addresses.
        !          1160: ** Big endian crc one liner is mine, all mine, ha ha ha ha!
        !          1161: ** LANCE calculates its hash codes big endian.
        !          1162: */
        !          1163: static void SetMulticastFilter(struct device *dev)
        !          1164: {
        !          1165:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !          1166:   struct dev_mc_list *dmi=dev->mc_list;
        !          1167:   char *addrs;
        !          1168:   int i, j, bit, byte;
        !          1169:   u16 hashcode;
        !          1170:   s32 crc, poly = CRC_POLYNOMIAL_BE;
        !          1171: 
        !          1172:   if (dev->flags & IFF_ALLMULTI) {         /* Set all multicast bits */
        !          1173:     for (i=0; i<(HASH_TABLE_LEN>>3); i++) {
        !          1174:       lp->init_block.mcast_table[i] = (char)0xff;
        !          1175:     }
        !          1176:   } else {
        !          1177:     for (i=0; i<(HASH_TABLE_LEN>>3); i++){ /* Clear the multicast table */
        !          1178:       lp->init_block.mcast_table[i]=0;
        !          1179:     }
        !          1180:                                            /* Add multicast addresses */
        !          1181:     for (i=0;i<dev->mc_count;i++) {        /* for each address in the list */
        !          1182:       addrs=dmi->dmi_addr;
        !          1183:       dmi=dmi->next;
        !          1184:       if ((*addrs & 0x01) == 1) {          /* multicast address? */ 
        !          1185:        crc = 0xffffffff;                  /* init CRC for each address */
        !          1186:        for (byte=0;byte<ETH_ALEN;byte++) {/* for each address byte */
        !          1187:                                           /* process each address bit */ 
        !          1188:          for (bit = *addrs++,j=0;j<8;j++, bit>>=1) {
        !          1189:            crc = (crc << 1) ^ ((((crc<0?1:0) ^ bit) & 0x01) ? poly : 0);
        !          1190:          }
        !          1191:        }
        !          1192:        hashcode = (crc & 1);              /* hashcode is 6 LSb of CRC ... */
        !          1193:        for (j=0;j<5;j++) {                /* ... in reverse order. */
        !          1194:          hashcode = (hashcode << 1) | ((crc>>=1) & 1);
        !          1195:        }                                      
        !          1196:        
        !          1197:        
        !          1198:        byte = hashcode >> 3;              /* bit[3-5] -> byte in filter */
        !          1199:        bit = 1 << (hashcode & 0x07);      /* bit[0-2] -> bit in byte */
        !          1200:        lp->init_block.mcast_table[byte] |= bit;
        !          1201:       }
        !          1202:     }
        !          1203:   }
        !          1204: 
        !          1205:   return;
        !          1206: }
        !          1207: 
        !          1208: /*
        !          1209: ** ISA bus I/O device probe
        !          1210: */
        !          1211: static void isa_probe(struct device *dev, u_long ioaddr)
        !          1212: {
        !          1213:   int i = num_depcas, maxSlots;
        !          1214:   s32 ports[] = DEPCA_IO_PORTS;
        !          1215: 
        !          1216:   if (!ioaddr && autoprobed) return ;          /* Been here before ! */
        !          1217:   if (ioaddr > 0x400) return;                  /* EISA Address */
        !          1218:   if (i >= MAX_NUM_DEPCAS) return;             /* Too many ISA adapters */
        !          1219: 
        !          1220:   if (ioaddr == 0) {                           /* Autoprobing */
        !          1221:     maxSlots = MAX_NUM_DEPCAS;
        !          1222:   } else {                                     /* Probe a specific location */
        !          1223:     ports[i] = ioaddr;
        !          1224:     maxSlots = i + 1;
        !          1225:   }
        !          1226: 
        !          1227:   for (; (i<maxSlots) && (dev!=NULL) && ports[i]; i++) {
        !          1228:     if (DevicePresent(ports[i]) == 0) { 
        !          1229:       if (check_region(ports[i], DEPCA_TOTAL_SIZE) == 0) {
        !          1230:        if ((dev = alloc_device(dev, ports[i])) != NULL) {
        !          1231:          if (depca_hw_init(dev, ports[i]) == 0) {
        !          1232:            num_depcas++;
        !          1233:          }
        !          1234:          num_eth++;
        !          1235:        }
        !          1236:       } else if (autoprobed) {
        !          1237:        printk("%s: region already allocated at 0x%04x.\n", dev->name,ports[i]);
        !          1238:       }
        !          1239:     }
        !          1240:   }
        !          1241: 
        !          1242:   return;
        !          1243: }
        !          1244: 
        !          1245: /*
        !          1246: ** EISA bus I/O device probe. Probe from slot 1 since slot 0 is usually
        !          1247: ** the motherboard. Upto 15 EISA devices are supported.
        !          1248: */
        !          1249: static void eisa_probe(struct device *dev, u_long ioaddr)
        !          1250: {
        !          1251:   int i, maxSlots;
        !          1252:   u_long iobase;
        !          1253:   char name[DEPCA_STRLEN];
        !          1254: 
        !          1255:   if (!ioaddr && autoprobed) return ;            /* Been here before ! */
        !          1256:   if ((ioaddr < 0x400) && (ioaddr > 0)) return;  /* ISA Address */
        !          1257: 
        !          1258:   if (ioaddr == 0) {                           /* Autoprobing */
        !          1259:     iobase = EISA_SLOT_INC;                    /* Get the first slot address */
        !          1260:     i = 1;
        !          1261:     maxSlots = MAX_EISA_SLOTS;
        !          1262:   } else {                                     /* Probe a specific location */
        !          1263:     iobase = ioaddr;
        !          1264:     i = (ioaddr >> 12);
        !          1265:     maxSlots = i + 1;
        !          1266:   }
        !          1267:   if ((iobase & 0x0fff) == 0) iobase += DEPCA_EISA_IO_PORTS;
        !          1268: 
        !          1269:   for (; (i<maxSlots) && (dev!=NULL); i++, iobase+=EISA_SLOT_INC) {
        !          1270:     if (EISA_signature(name, EISA_ID)) {
        !          1271:       if (DevicePresent(iobase) == 0) { 
        !          1272:        if (check_region(iobase, DEPCA_TOTAL_SIZE) == 0) {
        !          1273:          if ((dev = alloc_device(dev, iobase)) != NULL) {
        !          1274:            if (depca_hw_init(dev, iobase) == 0) {
        !          1275:              num_depcas++;
        !          1276:            }
        !          1277:            num_eth++;
        !          1278:          }
        !          1279:        } else if (autoprobed) {
        !          1280:          printk("%s: region already allocated at 0x%04lx.\n",dev->name,iobase);
        !          1281:        }
        !          1282:       }
        !          1283:     }
        !          1284:   }
        !          1285: 
        !          1286:   return;
        !          1287: }
        !          1288: 
        !          1289: /*
        !          1290: ** Search the entire 'eth' device list for a fixed probe. If a match isn't
        !          1291: ** found then check for an autoprobe or unused device location. If they
        !          1292: ** are not available then insert a new device structure at the end of
        !          1293: ** the current list.
        !          1294: */
        !          1295: static struct device *
        !          1296: alloc_device(struct device *dev, u_long iobase)
        !          1297: {
        !          1298:     struct device *adev = NULL;
        !          1299:     int fixed = 0, new_dev = 0;
        !          1300: 
        !          1301:     num_eth = depca_dev_index(dev->name);
        !          1302:     if (loading_module) return dev;
        !          1303:     
        !          1304:     while (1) {
        !          1305:        if (((dev->base_addr == DEPCA_NDA) || (dev->base_addr==0)) && !adev) {
        !          1306:            adev=dev;
        !          1307:        } else if ((dev->priv == NULL) && (dev->base_addr==iobase)) {
        !          1308:            fixed = 1;
        !          1309:        } else {
        !          1310:            if (dev->next == NULL) {
        !          1311:                new_dev = 1;
        !          1312:            } else if (strncmp(dev->next->name, "eth", 3) != 0) {
        !          1313:                new_dev = 1;
        !          1314:            }
        !          1315:        }
        !          1316:        if ((dev->next == NULL) || new_dev || fixed) break;
        !          1317:        dev = dev->next;
        !          1318:        num_eth++;
        !          1319:     }
        !          1320:     if (adev && !fixed) {
        !          1321:        dev = adev;
        !          1322:        num_eth = depca_dev_index(dev->name);
        !          1323:        new_dev = 0;
        !          1324:     }
        !          1325: 
        !          1326:     if (((dev->next == NULL) &&  
        !          1327:        ((dev->base_addr != DEPCA_NDA) && (dev->base_addr != 0)) && !fixed) ||
        !          1328:        new_dev) {
        !          1329:        num_eth++;                         /* New device */
        !          1330:        dev = insert_device(dev, iobase, depca_probe);
        !          1331:     }
        !          1332:     
        !          1333:     return dev;
        !          1334: }
        !          1335: 
        !          1336: /*
        !          1337: ** If at end of eth device list and can't use current entry, malloc
        !          1338: ** one up. If memory could not be allocated, print an error message.
        !          1339: */
        !          1340: static struct device *
        !          1341: insert_device(struct device *dev, u_long iobase, int (*init)(struct device *))
        !          1342: {
        !          1343:     struct device *new;
        !          1344: 
        !          1345:     new = (struct device *)kmalloc(sizeof(struct device)+8, GFP_KERNEL);
        !          1346:     if (new == NULL) {
        !          1347:        printk("eth%d: Device not initialised, insufficient memory\n",num_eth);
        !          1348:        return NULL;
        !          1349:     } else {
        !          1350:        new->next = dev->next;
        !          1351:        dev->next = new;
        !          1352:        dev = dev->next;               /* point to the new device */
        !          1353:        dev->name = (char *)(dev + 1);
        !          1354:        if (num_eth > 9999) {
        !          1355:            sprintf(dev->name,"eth????");/* New device name */
        !          1356:        } else {
        !          1357:            sprintf(dev->name,"eth%d", num_eth);/* New device name */
        !          1358:        }
        !          1359:        dev->base_addr = iobase;       /* assign the io address */
        !          1360:        dev->init = init;              /* initialisation routine */
        !          1361:     }
        !          1362: 
        !          1363:     return dev;
        !          1364: }
        !          1365: 
        !          1366: static int
        !          1367: depca_dev_index(char *s)
        !          1368: {
        !          1369:     int i=0, j=0;
        !          1370: 
        !          1371:     for (;*s; s++) {
        !          1372:        if (isdigit(*s)) {
        !          1373:            j=1;
        !          1374:            i = (i * 10) + (*s - '0');
        !          1375:        } else if (j) break;
        !          1376:     }
        !          1377: 
        !          1378:     return i;
        !          1379: }
        !          1380: 
        !          1381: /*
        !          1382: ** Look for a particular board name in the on-board Remote Diagnostics
        !          1383: ** and Boot (readb) ROM. This will also give us a clue to the network RAM
        !          1384: ** base address.
        !          1385: */
        !          1386: static void DepcaSignature(char *name, u_long paddr)
        !          1387: {
        !          1388:   u_int i,j,k;
        !          1389:   const char *signatures[] = DEPCA_SIGNATURE;
        !          1390:   char tmpstr[16];
        !          1391: 
        !          1392:   /* Copy the first 16 bytes of ROM */
        !          1393:   for (i=0;i<16;i++) {
        !          1394:     tmpstr[i] = readb(paddr+0xc000+i);
        !          1395:   }
        !          1396: 
        !          1397:   /* Check if PROM contains a valid string */
        !          1398:   for (i=0;*signatures[i]!='\0';i++) {
        !          1399:     for (j=0,k=0;j<16 && k<strlen(signatures[i]);j++) {
        !          1400:       if (signatures[i][k] == tmpstr[j]) {              /* track signature */
        !          1401:        k++;
        !          1402:       } else {                     /* lost signature; begin search again */
        !          1403:        k=0;
        !          1404:       }
        !          1405:     }
        !          1406:     if (k == strlen(signatures[i])) break;
        !          1407:   }
        !          1408: 
        !          1409:   /* Check if name string is valid, provided there's no PROM */
        !          1410:   if (*name && (i == unknown)) {
        !          1411:     for (i=0;*signatures[i]!='\0';i++) {
        !          1412:       if (strcmp(name,signatures[i]) == 0) break;
        !          1413:     }
        !          1414:   }
        !          1415: 
        !          1416:   /* Update search results */
        !          1417:   strcpy(name,signatures[i]);
        !          1418:   adapter = i;
        !          1419: 
        !          1420:   return;
        !          1421: }
        !          1422: 
        !          1423: /*
        !          1424: ** Look for a special sequence in the Ethernet station address PROM that
        !          1425: ** is common across all DEPCA products. Note that the original DEPCA needs
        !          1426: ** its ROM address counter to be initialized and enabled. Only enable
        !          1427: ** if the first address octet is a 0x08 - this minimises the chances of
        !          1428: ** messing around with some other hardware, but it assumes that this DEPCA
        !          1429: ** card initialized itself correctly.
        !          1430: ** 
        !          1431: ** Search the Ethernet address ROM for the signature. Since the ROM address
        !          1432: ** counter can start at an arbitrary point, the search must include the entire
        !          1433: ** probe sequence length plus the (length_of_the_signature - 1).
        !          1434: ** Stop the search IMMEDIATELY after the signature is found so that the
        !          1435: ** PROM address counter is correctly positioned at the start of the
        !          1436: ** ethernet address for later read out.
        !          1437: */
        !          1438: static int DevicePresent(u_long ioaddr)
        !          1439: {
        !          1440:   union {
        !          1441:     struct {
        !          1442:       u32 a;
        !          1443:       u32 b;
        !          1444:     } llsig;
        !          1445:     char Sig[sizeof(u32) << 1];
        !          1446:   } dev;
        !          1447:   short sigLength=0;
        !          1448:   s8 data;
        !          1449:   s16 nicsr;
        !          1450:   int i, j, status = 0;
        !          1451: 
        !          1452:   data = inb(DEPCA_PROM);                /* clear counter on DEPCA */
        !          1453:   data = inb(DEPCA_PROM);                /* read data */
        !          1454: 
        !          1455:   if (data == 0x08) {                    /* Enable counter on DEPCA */
        !          1456:     nicsr = inb(DEPCA_NICSR);
        !          1457:     nicsr |= AAC;
        !          1458:     outb(nicsr, DEPCA_NICSR);
        !          1459:   }
        !          1460:   
        !          1461:   dev.llsig.a = ETH_PROM_SIG;
        !          1462:   dev.llsig.b = ETH_PROM_SIG;
        !          1463:   sigLength = sizeof(u32) << 1;
        !          1464: 
        !          1465:   for (i=0,j=0;j<sigLength && i<PROBE_LENGTH+sigLength-1;i++) {
        !          1466:     data = inb(DEPCA_PROM);
        !          1467:     if (dev.Sig[j] == data) {    /* track signature */
        !          1468:       j++;
        !          1469:     } else {                     /* lost signature; begin search again */
        !          1470:       if (data == dev.Sig[0]) {  /* rare case.... */
        !          1471:        j=1;
        !          1472:       } else {
        !          1473:        j=0;
        !          1474:       }
        !          1475:     }
        !          1476:   }
        !          1477: 
        !          1478:   if (j!=sigLength) {
        !          1479:     status = -ENODEV;           /* search failed */
        !          1480:   }
        !          1481: 
        !          1482:   return status;
        !          1483: }
        !          1484: 
        !          1485: /*
        !          1486: ** The DE100 and DE101 PROM accesses were made non-standard for some bizarre
        !          1487: ** reason: access the upper half of the PROM with x=0; access the lower half
        !          1488: ** with x=1.
        !          1489: */
        !          1490: static int get_hw_addr(struct device *dev)
        !          1491: {
        !          1492:   u_long ioaddr = dev->base_addr;
        !          1493:   int i, k, tmp, status = 0;
        !          1494:   u_short j, x, chksum;
        !          1495: 
        !          1496:   x = (((adapter == de100) || (adapter == de101)) ? 1 : 0);
        !          1497: 
        !          1498:   for (i=0,k=0,j=0;j<3;j++) {
        !          1499:     k <<= 1 ;
        !          1500:     if (k > 0xffff) k-=0xffff;
        !          1501: 
        !          1502:     k += (u_char) (tmp = inb(DEPCA_PROM + x));
        !          1503:     dev->dev_addr[i++] = (u_char) tmp;
        !          1504:     k += (u_short) ((tmp = inb(DEPCA_PROM + x)) << 8);
        !          1505:     dev->dev_addr[i++] = (u_char) tmp;
        !          1506: 
        !          1507:     if (k > 0xffff) k-=0xffff;
        !          1508:   }
        !          1509:   if (k == 0xffff) k=0;
        !          1510: 
        !          1511:   chksum = (u_char) inb(DEPCA_PROM + x);
        !          1512:   chksum |= (u_short) (inb(DEPCA_PROM + x) << 8);
        !          1513:   if (k != chksum) status = -1;
        !          1514: 
        !          1515:   return status;
        !          1516: }
        !          1517: 
        !          1518: /*
        !          1519: ** Load a packet into the shared memory
        !          1520: */
        !          1521: static int load_packet(struct device *dev, struct sk_buff *skb)
        !          1522: {
        !          1523:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !          1524:   int i, entry, end, len, status = 0;
        !          1525: 
        !          1526:   entry = lp->tx_new;                                 /* Ring around buffer number. */
        !          1527:   end = (entry + (skb->len - 1) / TX_BUFF_SZ) & lp->txRingMask;
        !          1528:   if (!(readl(&lp->tx_ring[end].base) & T_OWN)) {/* Enough room? */
        !          1529:     /* 
        !          1530:     ** Caution: the write order is important here... don't set up the
        !          1531:     ** ownership rights until all the other information is in place.
        !          1532:     */
        !          1533:     if (end < entry) {                         /* wrapped buffer */
        !          1534:       len = (lp->txRingMask - entry + 1) * TX_BUFF_SZ;
        !          1535:       memcpy_toio(lp->tx_memcpy[entry], skb->data, len);
        !          1536:       memcpy_toio(lp->tx_memcpy[0], skb->data + len, skb->len - len);
        !          1537:     } else {                                   /* linear buffer */
        !          1538:       memcpy_toio(lp->tx_memcpy[entry], skb->data, skb->len);
        !          1539:     }
        !          1540: 
        !          1541:     /* set up the buffer descriptors */
        !          1542:     len = (skb->len < ETH_ZLEN) ? ETH_ZLEN : skb->len;
        !          1543:     for (i = entry; i != end; i = (++i) & lp->txRingMask) {
        !          1544:                                                /* clean out flags */
        !          1545:       writel(readl(&lp->tx_ring[i].base) & ~T_FLAGS, &lp->tx_ring[i].base);
        !          1546:       writew(0x0000, &lp->tx_ring[i].misc);    /* clears other error flags */
        !          1547:       writew(-TX_BUFF_SZ, &lp->tx_ring[i].length);/* packet length in buffer */
        !          1548:       len -= TX_BUFF_SZ;
        !          1549:     }
        !          1550:                                                /* clean out flags */
        !          1551:     writel(readl(&lp->tx_ring[end].base) & ~T_FLAGS, &lp->tx_ring[end].base);
        !          1552:     writew(0x0000, &lp->tx_ring[end].misc);    /* clears other error flags */
        !          1553:     writew(-len, &lp->tx_ring[end].length);    /* packet length in last buff */
        !          1554: 
        !          1555:                                                /* start of packet */
        !          1556:     writel(readl(&lp->tx_ring[entry].base) | T_STP, &lp->tx_ring[entry].base);
        !          1557:                                                /* end of packet */
        !          1558:     writel(readl(&lp->tx_ring[end].base) | T_ENP, &lp->tx_ring[end].base);
        !          1559: 
        !          1560:     for (i=end; i!=entry; --i) {
        !          1561:                                                /* ownership of packet */
        !          1562:       writel(readl(&lp->tx_ring[i].base) | T_OWN, &lp->tx_ring[i].base);
        !          1563:       if (i == 0) i=lp->txRingMask+1;
        !          1564:     }   
        !          1565:     writel(readl(&lp->tx_ring[entry].base) | T_OWN, &lp->tx_ring[entry].base);
        !          1566:  
        !          1567:     lp->tx_new = (++end) & lp->txRingMask;     /* update current pointers */
        !          1568:   } else {
        !          1569:     status = -1;
        !          1570:   }
        !          1571: 
        !          1572:   return status;
        !          1573: }
        !          1574: 
        !          1575: /*
        !          1576: ** Look for a particular board name in the EISA configuration space
        !          1577: */
        !          1578: static int EISA_signature(char *name, s32 eisa_id)
        !          1579: {
        !          1580:   u_int i;
        !          1581:   const char *signatures[] = DEPCA_SIGNATURE;
        !          1582:   char ManCode[DEPCA_STRLEN];
        !          1583:   union {
        !          1584:     s32 ID;
        !          1585:     char Id[4];
        !          1586:   } Eisa;
        !          1587:   int status = 0;
        !          1588: 
        !          1589:   *name = '\0';
        !          1590:   Eisa.ID = inl(eisa_id);
        !          1591: 
        !          1592:   ManCode[0]=(((Eisa.Id[0]>>2)&0x1f)+0x40);
        !          1593:   ManCode[1]=(((Eisa.Id[1]&0xe0)>>5)+((Eisa.Id[0]&0x03)<<3)+0x40);
        !          1594:   ManCode[2]=(((Eisa.Id[2]>>4)&0x0f)+0x30);
        !          1595:   ManCode[3]=(( Eisa.Id[2]&0x0f)+0x30);
        !          1596:   ManCode[4]=(((Eisa.Id[3]>>4)&0x0f)+0x30);
        !          1597:   ManCode[5]='\0';
        !          1598: 
        !          1599:   for (i=0;(*signatures[i] != '\0') && (*name == '\0');i++) {
        !          1600:     if (strstr(ManCode, signatures[i]) != NULL) {
        !          1601:       strcpy(name,ManCode);
        !          1602:       status = 1;
        !          1603:     }
        !          1604:   }
        !          1605: 
        !          1606:   return status;
        !          1607: }
        !          1608: 
        !          1609: static void depca_dbg_open(struct device *dev)
        !          1610: {
        !          1611:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !          1612:   u_long ioaddr = dev->base_addr;
        !          1613:   struct depca_init *p = (struct depca_init *)lp->sh_mem;
        !          1614:   int i; 
        !          1615: 
        !          1616:   if (depca_debug > 1){
        !          1617:     /* Copy the shadow init_block to shared memory */
        !          1618:     memcpy_toio((char *)lp->sh_mem,&lp->init_block,sizeof(struct depca_init));
        !          1619: 
        !          1620:     printk("%s: depca open with irq %d\n",dev->name,dev->irq);
        !          1621:     printk("Descriptor head addresses:\n");
        !          1622:     printk("\t0x%lx  0x%lx\n",(u_long)lp->rx_ring, (u_long)lp->tx_ring);
        !          1623:     printk("Descriptor addresses:\nRX: ");
        !          1624:     for (i=0;i<lp->rxRingMask;i++){
        !          1625:       if (i < 3) {
        !          1626:        printk("0x%8.8lx ", (long) &lp->rx_ring[i].base);
        !          1627:       }
        !          1628:     }
        !          1629:     printk("...0x%8.8lx\n", (long) &lp->rx_ring[i].base);
        !          1630:     printk("TX: ");
        !          1631:     for (i=0;i<lp->txRingMask;i++){
        !          1632:       if (i < 3) {
        !          1633:        printk("0x%8.8lx ", (long) &lp->tx_ring[i].base);
        !          1634:       }
        !          1635:     }
        !          1636:     printk("...0x%8.8lx\n", (long) &lp->tx_ring[i].base);
        !          1637:     printk("\nDescriptor buffers:\nRX: ");
        !          1638:     for (i=0;i<lp->rxRingMask;i++){
        !          1639:       if (i < 3) {
        !          1640:        printk("0x%8.8x  ", readl(&lp->rx_ring[i].base));
        !          1641:       }
        !          1642:     }
        !          1643:     printk("...0x%8.8x\n", readl(&lp->rx_ring[i].base));
        !          1644:     printk("TX: ");
        !          1645:     for (i=0;i<lp->txRingMask;i++){
        !          1646:       if (i < 3) {
        !          1647:        printk("0x%8.8x  ", readl(&lp->tx_ring[i].base));
        !          1648:       }
        !          1649:     }
        !          1650:     printk("...0x%8.8x\n", readl(&lp->tx_ring[i].base));
        !          1651:     printk("Initialisation block at 0x%8.8lx\n",lp->sh_mem);
        !          1652:     printk("\tmode: 0x%4.4x\n",readw(&p->mode));
        !          1653:     printk("\tphysical address: ");
        !          1654:     for (i=0;i<ETH_ALEN-1;i++){
        !          1655:       printk("%2.2x:",(u_char)readb(&p->phys_addr[i]));
        !          1656:     }
        !          1657:     printk("%2.2x\n",(u_char)readb(&p->phys_addr[i]));
        !          1658:     printk("\tmulticast hash table: ");
        !          1659:     for (i=0;i<(HASH_TABLE_LEN >> 3)-1;i++){
        !          1660:       printk("%2.2x:",(u_char)readb(&p->mcast_table[i]));
        !          1661:     }
        !          1662:     printk("%2.2x\n",(u_char)readb(&p->mcast_table[i]));
        !          1663:     printk("\trx_ring at: 0x%8.8x\n",readl(&p->rx_ring));
        !          1664:     printk("\ttx_ring at: 0x%8.8x\n",readl(&p->tx_ring));
        !          1665:     printk("dma_buffs: 0x%8.8lx\n",lp->dma_buffs);
        !          1666:     printk("Ring size:\nRX: %d  Log2(rxRingMask): 0x%8.8x\n", 
        !          1667:           (int)lp->rxRingMask + 1, 
        !          1668:           lp->rx_rlen);
        !          1669:     printk("TX: %d  Log2(txRingMask): 0x%8.8x\n", 
        !          1670:           (int)lp->txRingMask + 1, 
        !          1671:           lp->tx_rlen);
        !          1672:     outw(CSR2,DEPCA_ADDR);
        !          1673:     printk("CSR2&1: 0x%4.4x",inw(DEPCA_DATA));
        !          1674:     outw(CSR1,DEPCA_ADDR);
        !          1675:     printk("%4.4x\n",inw(DEPCA_DATA));
        !          1676:     outw(CSR3,DEPCA_ADDR);
        !          1677:     printk("CSR3: 0x%4.4x\n",inw(DEPCA_DATA));
        !          1678:   }
        !          1679: 
        !          1680:   return;
        !          1681: }
        !          1682: 
        !          1683: /*
        !          1684: ** Perform IOCTL call functions here. Some are privileged operations and the
        !          1685: ** effective uid is checked in those cases.
        !          1686: ** All MCA IOCTLs will not work here and are for testing purposes only.
        !          1687: */
        !          1688: static int depca_ioctl(struct device *dev, struct ifreq *rq, int cmd)
        !          1689: {
        !          1690:   struct depca_private *lp = (struct depca_private *)dev->priv;
        !          1691:   struct depca_ioctl *ioc = (struct depca_ioctl *) &rq->ifr_data;
        !          1692:   int i, status = 0;
        !          1693:   u_long ioaddr = dev->base_addr;
        !          1694:   union {
        !          1695:     u8  addr[(HASH_TABLE_LEN * ETH_ALEN)];
        !          1696:     u16 sval[(HASH_TABLE_LEN * ETH_ALEN) >> 1];
        !          1697:     u32 lval[(HASH_TABLE_LEN * ETH_ALEN) >> 2];
        !          1698:   } tmp;
        !          1699: 
        !          1700:   switch(ioc->cmd) {
        !          1701:   case DEPCA_GET_HWADDR:             /* Get the hardware address */
        !          1702:     for (i=0; i<ETH_ALEN; i++) {
        !          1703:       tmp.addr[i] = dev->dev_addr[i];
        !          1704:     }
        !          1705:     ioc->len = ETH_ALEN;
        !          1706:     if (!(status = verify_area(VERIFY_WRITE, (void *)ioc->data, ioc->len))) {
        !          1707:       memcpy_tofs(ioc->data, tmp.addr, ioc->len);
        !          1708:     }
        !          1709: 
        !          1710:     break;
        !          1711:   case DEPCA_SET_HWADDR:             /* Set the hardware address */
        !          1712:     if (suser()) {
        !          1713:       if (!(status = verify_area(VERIFY_READ, (void *)ioc->data, ETH_ALEN))) {
        !          1714:        memcpy_fromfs(tmp.addr,ioc->data,ETH_ALEN);
        !          1715:        for (i=0; i<ETH_ALEN; i++) {
        !          1716:          dev->dev_addr[i] = tmp.addr[i];
        !          1717:        }
        !          1718:        while(dev->tbusy);              /* Stop ring access */
        !          1719:        set_bit(0, (void*)&dev->tbusy);
        !          1720:        while(lp->tx_old != lp->tx_new);/* Wait for the ring to empty */
        !          1721: 
        !          1722:        STOP_DEPCA;                     /* Temporarily stop the depca.  */
        !          1723:        depca_init_ring(dev);           /* Initialize the descriptor rings */
        !          1724:        LoadCSRs(dev);                  /* Reload CSR3 */
        !          1725:        InitRestartDepca(dev);          /* Resume normal operation. */
        !          1726:        dev->tbusy = 0;                 /* Unlock the TX ring */
        !          1727:       }
        !          1728:     } else {
        !          1729:       status = -EPERM;
        !          1730:     }
        !          1731: 
        !          1732:     break;
        !          1733:   case DEPCA_SET_PROM:               /* Set Promiscuous Mode */
        !          1734:     if (suser()) {
        !          1735:       while(dev->tbusy);                /* Stop ring access */
        !          1736:       set_bit(0, (void*)&dev->tbusy);
        !          1737:       while(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
        !          1738: 
        !          1739:       STOP_DEPCA;                       /* Temporarily stop the depca.  */
        !          1740:       depca_init_ring(dev);             /* Initialize the descriptor rings */
        !          1741:       lp->init_block.mode |= PROM;      /* Set promiscuous mode */
        !          1742: 
        !          1743:       LoadCSRs(dev);                    /* Reload CSR3 */
        !          1744:       InitRestartDepca(dev);            /* Resume normal operation. */
        !          1745:       dev->tbusy = 0;                   /* Unlock the TX ring */
        !          1746:     } else {
        !          1747:       status = -EPERM;
        !          1748:     }
        !          1749: 
        !          1750:     break;
        !          1751:   case DEPCA_CLR_PROM:               /* Clear Promiscuous Mode */
        !          1752:     if (suser()) {
        !          1753:       while(dev->tbusy);                /* Stop ring access */
        !          1754:       set_bit(0, (void*)&dev->tbusy);
        !          1755:       while(lp->tx_old != lp->tx_new);  /* Wait for the ring to empty */
        !          1756: 
        !          1757:       STOP_DEPCA;                       /* Temporarily stop the depca.  */
        !          1758:       depca_init_ring(dev);             /* Initialize the descriptor rings */
        !          1759:       lp->init_block.mode &= ~PROM;     /* Clear promiscuous mode */
        !          1760: 
        !          1761:       LoadCSRs(dev);                    /* Reload CSR3 */
        !          1762:       InitRestartDepca(dev);            /* Resume normal operation. */
        !          1763:       dev->tbusy = 0;                   /* Unlock the TX ring */
        !          1764:     } else {
        !          1765:       status = -EPERM;
        !          1766:     }
        !          1767: 
        !          1768:     break;
        !          1769:   case DEPCA_SAY_BOO:                /* Say "Boo!" to the kernel log file */
        !          1770:     printk("%s: Boo!\n", dev->name);
        !          1771: 
        !          1772:     break;
        !          1773:   case DEPCA_GET_MCA:                /* Get the multicast address table */
        !          1774:     ioc->len = (HASH_TABLE_LEN >> 3);
        !          1775:     if (!(status = verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
        !          1776:       memcpy_tofs(ioc->data, lp->init_block.mcast_table, ioc->len); 
        !          1777:     }
        !          1778: 
        !          1779:     break;
        !          1780:   case DEPCA_SET_MCA:                /* Set a multicast address */
        !          1781:     if (suser()) {
        !          1782:       if (!(status=verify_area(VERIFY_READ, ioc->data, ETH_ALEN*ioc->len))) {
        !          1783:        memcpy_fromfs(tmp.addr, ioc->data, ETH_ALEN * ioc->len);
        !          1784:        set_multicast_list(dev);
        !          1785:       }
        !          1786:     } else {
        !          1787:       status = -EPERM;
        !          1788:     }
        !          1789: 
        !          1790:     break;
        !          1791:   case DEPCA_CLR_MCA:                /* Clear all multicast addresses */
        !          1792:     if (suser()) {
        !          1793:       set_multicast_list(dev);
        !          1794:     } else {
        !          1795:       status = -EPERM;
        !          1796:     }
        !          1797: 
        !          1798:     break;
        !          1799:   case DEPCA_MCA_EN:                 /* Enable pass all multicast addressing */
        !          1800:     if (suser()) {
        !          1801:       set_multicast_list(dev);
        !          1802:     } else {
        !          1803:       status = -EPERM;
        !          1804:     }
        !          1805: 
        !          1806:     break;
        !          1807:   case DEPCA_GET_STATS:              /* Get the driver statistics */
        !          1808:     cli();
        !          1809:     ioc->len = sizeof(lp->pktStats);
        !          1810:     if (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
        !          1811:       memcpy_tofs(ioc->data, &lp->pktStats, ioc->len); 
        !          1812:     }
        !          1813:     sti();
        !          1814: 
        !          1815:     break;
        !          1816:   case DEPCA_CLR_STATS:              /* Zero out the driver statistics */
        !          1817:     if (suser()) {
        !          1818:       cli();
        !          1819:       memset(&lp->pktStats, 0, sizeof(lp->pktStats));
        !          1820:       sti();
        !          1821:     } else {
        !          1822:       status = -EPERM;
        !          1823:     }
        !          1824: 
        !          1825:     break;
        !          1826:   case DEPCA_GET_REG:                /* Get the DEPCA Registers */
        !          1827:     i=0;
        !          1828:     tmp.sval[i++] = inw(DEPCA_NICSR);
        !          1829:     outw(CSR0, DEPCA_ADDR);              /* status register */
        !          1830:     tmp.sval[i++] = inw(DEPCA_DATA);
        !          1831:     memcpy(&tmp.sval[i], &lp->init_block, sizeof(struct depca_init));
        !          1832:     ioc->len = i+sizeof(struct depca_init);
        !          1833:     if (!(status=verify_area(VERIFY_WRITE, ioc->data, ioc->len))) {
        !          1834:       memcpy_tofs(ioc->data, tmp.addr, ioc->len);
        !          1835:     }
        !          1836: 
        !          1837:     break;
        !          1838:   default:
        !          1839:     status = -EOPNOTSUPP;
        !          1840:   }
        !          1841: 
        !          1842:   return status;
        !          1843: }
        !          1844: 
        !          1845: #ifdef MODULE
        !          1846: static char devicename[9] = { 0, };
        !          1847: static struct device thisDepca = {
        !          1848:   devicename,  /* device name is inserted by /linux/drivers/net/net_init.c */
        !          1849:   0, 0, 0, 0,
        !          1850:   0x200, 7,    /* I/O address, IRQ */
        !          1851:   0, 0, 0, NULL, depca_probe };
        !          1852: 
        !          1853: static int irq=7;      /* EDIT THESE LINE FOR YOUR CONFIGURATION */
        !          1854: static int io=0x200;    /* Or use the irq= io= options to insmod */
        !          1855: 
        !          1856: /* See depca_probe() for autoprobe messages when a module */   
        !          1857: int
        !          1858: init_module(void)
        !          1859: {
        !          1860:   thisDepca.irq=irq;
        !          1861:   thisDepca.base_addr=io;
        !          1862: 
        !          1863:   if (register_netdev(&thisDepca) != 0)
        !          1864:     return -EIO;
        !          1865: 
        !          1866:   return 0;
        !          1867: }
        !          1868: 
        !          1869: void
        !          1870: cleanup_module(void)
        !          1871: {
        !          1872:   if (thisDepca.priv) {
        !          1873:     kfree(thisDepca.priv);
        !          1874:     thisDepca.priv = NULL;
        !          1875:   }
        !          1876:   thisDepca.irq=0;
        !          1877: 
        !          1878:   unregister_netdev(&thisDepca);
        !          1879:   release_region(thisDepca.base_addr, DEPCA_TOTAL_SIZE);
        !          1880: }
        !          1881: #endif /* MODULE */
        !          1882: 
        !          1883: 
        !          1884: /*
        !          1885:  * Local variables:
        !          1886:  *  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"
        !          1887:  *
        !          1888:  *  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"
        !          1889:  * End:
        !          1890:  */

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.