home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.2 / LINUX-1.2 / LINUX-1 / linux / drivers / net / depca.c < prev    next >
Encoding:
Text File  |  1995-02-23  |  48.9 KB  |  1,589 lines

  1. /*  depca.c: A DIGITAL DEPCA  & EtherWORKS ethernet driver for linux.
  2.  
  3.     Written 1994 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.  
  12.     This software may be used and distributed according to the terms of
  13.     the GNU Public License, incorporated herein by reference.
  14.  
  15.     This driver is written for the Digital Equipment Corporation series
  16.     of DEPCA and EtherWORKS ethernet cards:
  17.  
  18.         DEPCA       (the original)
  19.         DE100
  20.         DE101
  21.     DE200 Turbo
  22.     DE201 Turbo
  23.     DE202 Turbo (TP BNC)
  24.     DE210
  25.     DE422       (EISA)
  26.  
  27.     The  driver has been tested on DE100, DE200 and DE202 cards  in  a
  28.     relatively busy network. The DE422 has been tested a little.
  29.  
  30.     This  driver will NOT work   for the DE203,  DE204  and DE205 series  of
  31.     cards,  since they have  a  new custom ASIC in   place of the AMD  LANCE
  32.     chip. 
  33.  
  34.     The author may be reached as davies@wanton.lkg.dec.com or
  35.     Digital Equipment Corporation, 550 King Street, Littleton MA 01460.
  36.  
  37.     =========================================================================
  38.     The driver was based on the 'lance.c' driver from Donald Becker which is
  39.     included with the standard driver distribution for linux. Modifications
  40.     were made to most routines and the hardware recognition routines were
  41.     written from scratch. Primary references used were:
  42.  
  43.     1) Lance.c code in /linux/drivers/net/
  44.     2) "Ethernet/IEEE 802.3 Family. 1992 World Network Data Book/Handbook",
  45.        AMD, 1992 [(800) 222-9323].
  46.     3) "Am79C90 CMOS Local Area Network Controller for Ethernet (C-LANCE)",
  47.        AMD, Pub. #17881, May 1993.
  48.     4) "Am79C960 PCnet-ISA(tm), Single-Chip Ethernet Controller for ISA",
  49.        AMD, Pub. #16907, May 1992
  50.     5) "DEC EtherWORKS LC Ethernet Controller Owners Manual",
  51.        Digital Equipment corporation, 1990, Pub. #EK-DE100-OM.003
  52.     6) "DEC EtherWORKS Turbo Ethernet Controller Owners Manual",
  53.        Digital Equipment corporation, 1990, Pub. #EK-DE200-OM.003
  54.     7) "DEPCA Hardware Reference Manual", Pub. #EK-DEPCA-PR
  55.        Digital Equipment Corporation, 1989
  56.     8) "DEC EtherWORKS Turbo_(TP BNC) Ethernet Controller Owners Manual",
  57.        Digital Equipment corporation, 1991, Pub. #EK-DE202-OM.001
  58.     
  59.     Peter Bauer's depca.c (V0.5) was referred to when debugging this driver.
  60.     The hash filter code was  derived from Reference  3 and has been  tested
  61.     only to the extent that the Table  A-1, page A-7,  was confirmed to fill
  62.     the   filter bit   positions  correctly.  Hash   filtering  is  not  yet
  63.     implemented in the current driver set.
  64.  
  65.     The original DEPCA  card requires that the  ethernet ROM address counter
  66.     be enabled to count and has an 8 bit NICSR.  The ROM counter enabling is
  67.     only  done when a  0x08 is read as the  first address octet (to minimise
  68.     the chances  of writing over some  other hardware's  I/O register).  The
  69.     NICSR accesses   have been changed  to  byte accesses  for all the cards
  70.     supported by this driver, since there is only one  useful bit in the MSB
  71.     (remote boot timeout) and it  is not used.  Also, there  is a maximum of
  72.     only 48kB network  RAM for this  card.  My thanks  to Torbjorn Lindh for
  73.     help debugging all this (and holding my feet to  the fire until I got it
  74.     right).
  75.  
  76.     The DE200  series  boards have  on-board 64kB  RAM for  use  as a shared
  77.     memory network  buffer. Only the DE100  cards make use  of a  2kB buffer
  78.     mode which has not  been implemented in  this driver (only the 32kB  and
  79.     64kB modes are supported [16kB/48kB for the original DEPCA]).
  80.  
  81.     At the most only 2 DEPCA cards can  be supported on  the ISA bus because
  82.     there is only provision  for two I/O base addresses  on each card (0x300
  83.     and 0x200). The I/O address is detected by searching for a byte sequence
  84.     in the Ethernet station address PROM at the expected I/O address for the
  85.     Ethernet  PROM.   The shared memory  base   address  is 'autoprobed'  by
  86.     looking  for the self  test PROM  and detecting the  card name.   When a
  87.     second  DEPCA is  detected,  information  is   placed in the   base_addr
  88.     variable of the  next device structure (which  is created if necessary),
  89.     thus  enabling ethif_probe  initialization  for the device.  More than 2
  90.     EISA cards can  be  supported, but  care will  be  needed assigning  the
  91.     shared memory to ensure that each slot has the  correct IRQ, I/O address
  92.     and shared memory address assigned.
  93.  
  94.     ************************************************************************
  95.  
  96.     NOTE: If you are using two  ISA DEPCAs, it is  important that you assign
  97.     the base memory addresses correctly.   The  driver autoprobes I/O  0x300
  98.     then 0x200.  The  base memory address for  the first device must be less
  99.     than that of the second so that the auto probe will correctly assign the
  100.     I/O and memory addresses on the same card.  I can't think of a way to do
  101.     this unambiguously at the moment, since there is nothing on the cards to
  102.     tie I/O and memory information together.
  103.  
  104.     I am unable  to  test  2 cards   together for now,    so this  code   is
  105.     unchecked. All reports, good or bad, are welcome.
  106.  
  107.     ************************************************************************
  108.  
  109.     The board IRQ   setting must be  at an  unused IRQ which  is auto-probed
  110.     using Donald Becker's autoprobe routines. DEPCA and DE100 board IRQs are
  111.     {2,3,4,5,7}, whereas the  DE200 is at {5,9,10,11,15}.  Note that IRQ2 is
  112.     really IRQ9 in machines with 16 IRQ lines.
  113.  
  114.     No 16MB memory  limitation should exist with this  driver as DMA is  not
  115.     used and the common memory area is in low memory on the network card (my
  116.     current system has 20MB and I've not had problems yet).
  117.  
  118.     The ability to load this driver as a loadable module has been added. To
  119.     utilise this ability, you have to do <8 things:
  120.  
  121.     1) copy depca.c from the  /linux/drivers/net directory to your favourite
  122.     temporary directory.
  123.     2) edit the  source code near  line 1530 to reflect  the I/O address and
  124.     IRQ you're using.
  125.     3) compile  depca.c, but include -DMODULE in  the command line to ensure
  126.     that the correct bits are compiled (see end of source code).
  127.     4) if you are wanting to add a new  card, goto 5. Otherwise, recompile a
  128.     kernel with the depca configuration turned off and reboot.
  129.     5) insmod depca.o
  130.     6) run the net startup bits for your eth?? interface manually 
  131.     (usually /etc/rc.inet[12] at boot time). 
  132.     7) enjoy!
  133.  
  134.     Note that autoprobing is not allowed in loadable modules - the system is
  135.     already up and running and you're messing with interrupts. Also, there
  136.     is no way to check on the number of depcas installed at the moment.
  137.  
  138.     To unload a module, turn off the associated interface 
  139.     'ifconfig eth?? down' then 'rmmod depca'.
  140.  
  141.     [Alan Cox: Changed to split off the module values as ints for insmod
  142.      
  143.      you can now do insmod depca.c irq=7 io=0x200 ]
  144.      
  145.  
  146.     TO DO:
  147.     ------
  148.  
  149.     1. Implement the 2k buffer mode - does anyone need it??
  150.  
  151.     Revision History
  152.     ----------------
  153.  
  154.     Version   Date        Description
  155.   
  156.       0.1     25-jan-94   Initial writing.
  157.       0.2     27-jan-94   Added LANCE TX hardware buffer chaining.
  158.       0.3      1-feb-94   Added multiple DEPCA support.
  159.       0.31     4-feb-94   Added DE202 recognition.
  160.       0.32    19-feb-94   Tidy up. Improve multi-DEPCA support.
  161.       0.33    25-feb-94   Fix DEPCA ethernet ROM counter enable.
  162.                           Add jabber packet fix from murf@perftech.com
  163.               and becker@super.org
  164.       0.34     7-mar-94   Fix DEPCA max network memory RAM & NICSR access.
  165.       0.35     8-mar-94   Added DE201 recognition. Tidied up.
  166.       0.351   30-apr-94   Added EISA support. Added DE422 recognition.
  167.       0.36    16-may-94   DE422 fix released.
  168.       0.37    22-jul-94   Added MODULE support
  169.       0.38    15-aug-94   Added DBR ROM switch in depca_close(). 
  170.                           Multi DEPCA bug fix.
  171.       0.38axp 15-sep-94   Special version for Alpha AXP Linux V1.0.
  172.       0.381   12-dec-94   Added DE101 recognition, fix multicast bug.
  173.       0.382    9-feb-95   Fix recognition bug reported by <bkm@star.rl.ac.uk>.
  174.       0.383   22-feb-95   Fix for conflict with VESA SCSI reported by
  175.                           <stromain@alf.dec.com>
  176.  
  177.     =========================================================================
  178. */
  179.  
  180. static char *version = "depca.c:v0.383 2/22/94 davies@wanton.lkg.dec.com\n";
  181.  
  182. #include <linux/config.h>
  183. #ifdef MODULE
  184. #include <linux/module.h>
  185. #include <linux/version.h>
  186. #else
  187. #define MOD_INC_USE_COUNT
  188. #define MOD_DEC_USE_COUNT
  189. #endif /* MODULE */
  190.  
  191. #include <linux/kernel.h>
  192. #include <linux/sched.h>
  193. #include <linux/string.h>
  194. #include <linux/ptrace.h>
  195. #include <linux/errno.h>
  196. #include <linux/ioport.h>
  197. #include <linux/malloc.h>
  198. #include <linux/interrupt.h>
  199. #include <asm/bitops.h>
  200. #include <asm/io.h>
  201. #include <asm/dma.h>
  202.  
  203. #include <linux/netdevice.h>
  204. #include <linux/etherdevice.h>
  205. #include <linux/skbuff.h>
  206.  
  207. #include "depca.h"
  208.  
  209. #ifdef DEPCA_DEBUG
  210. static int depca_debug = DEPCA_DEBUG;
  211. #else
  212. static int depca_debug = 1;
  213. #endif
  214.  
  215. #ifndef PROBE_LENGTH
  216. #define PROBE_LENGTH    32
  217. #endif
  218.  
  219. #define ETH_PROM_SIG    0xAA5500FFUL
  220.  
  221. #ifndef DEPCA_SIGNATURE
  222. #define DEPCA_SIGNATURE {"DEPCA",\
  223.              "DE100","DE101",\
  224.                          "DE200","DE201","DE202",\
  225.              "DE210",\
  226.                          "DE422",\
  227.                          ""}
  228. #define DEPCA_NAME_LENGTH 8
  229. #endif
  230.  
  231. #ifndef DEPCA_RAM_BASE_ADDRESSES
  232. #define DEPCA_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0xe0000,0x00000}
  233. #endif
  234. static short mem_chkd = 0;               /* holds which base addrs have been */
  235.                      /* checked, for multi-DEPCA case */
  236.  
  237. #ifndef DEPCA_IO_PORTS
  238. #define DEPCA_IO_PORTS {0x300, 0x200, 0}
  239. #endif
  240.  
  241. #ifndef DEPCA_TOTAL_SIZE
  242. #define DEPCA_TOTAL_SIZE 0x10
  243. #endif
  244.  
  245. #ifndef MAX_NUM_DEPCAS
  246. #define MAX_NUM_DEPCAS 2
  247. #endif
  248.  
  249. #ifndef DEPCA_EISA_IO_PORTS 
  250. #define DEPCA_EISA_IO_PORTS 0x0c00       /* I/O port base address, slot 0 */
  251. #endif
  252.  
  253. #ifndef MAX_EISA_SLOTS
  254. #define MAX_EISA_SLOTS 8
  255. #endif
  256.  
  257. /*
  258. ** Set the number of Tx and Rx buffers. 
  259. */
  260. #ifndef DEPCA_BUFFER_LOG_SZ
  261. #define RING_SIZE    16              /* 16 buffers */
  262. #else
  263. #define RING_SIZE    (1 << (DEPCA_BUFFERS_LOG_SZ))
  264. #endif  /* DEPCA_BUFFER_LOG_SZ */
  265.  
  266. #define PKT_BUF_SZ    1544            /* Buffer size for each Tx/Rx buffer */
  267. #define PKT_SZ       1514            /* Maximum ethernet packet length */
  268. #define DAT_SZ       1500            /* Maximum ethernet data length */
  269. #define PKT_HDR_LEN     14              /* Addresses and data length info */
  270.  
  271. #ifdef HAVE_MULTICAST
  272. #ifndef CRC_POLYNOMIAL
  273. #define CRC_POLYNOMIAL 0x04c11db7       /* Ethernet CRC polynomial */
  274. #endif /* CRC_POLYNOMIAL */
  275. #endif /* HAVE_MULTICAST */
  276.  
  277. /*
  278. ** The DEPCA Rx and Tx ring descriptors. 
  279. */
  280. struct depca_rx_head {
  281.     volatile long base;
  282.     short buf_length;        /* This length is negative 2's complement! */
  283.     short msg_length;        /* This length is "normal". */
  284. };
  285.  
  286. struct depca_tx_head {
  287.     volatile long base;
  288.     short length;        /* This length is negative 2's complement! */
  289.     short misc;                 /* Errors and TDR info */
  290. };
  291.  
  292. #define LA_MASK 0x0000ffff      /* LANCE address mask for mapping network RAM
  293.                    to LANCE memory address space */
  294.  
  295. /*
  296. ** The Lance initialization block, described in databook, in common memory.
  297. */
  298. struct depca_init {
  299.     unsigned short mode;    /* Mode register */
  300.     unsigned char phys_addr[ETH_ALEN];    /* Physical ethernet address */
  301.     unsigned short filter[4];    /* Multicast filter. */
  302.     unsigned long rx_ring;         /* Rx ring base pointer & ring length */
  303.     unsigned long tx_ring;    /* Tx ring base pointer & ring length */
  304. };
  305.  
  306. struct depca_private {
  307.     char devname[8];            /* Device Product String */
  308.     struct depca_rx_head *rx_ring; /* Pointer to start of RX descriptor ring */
  309.     struct depca_tx_head *tx_ring; /* Pointer to start of TX descriptor ring */
  310.     struct depca_init    init_block;/* Initialization block */
  311.     long bus_offset;            /* (E)ISA bus address offset vs LANCE */
  312.     long dma_buffs;        /* Start address of Rx and Tx buffers. */
  313.     int    cur_rx, cur_tx;        /* The next free ring entry */
  314.     int dirty_rx, dirty_tx;    /* The ring entries to be free()ed. */
  315.     int dma;
  316.     struct enet_statistics stats;
  317.     char depca_na;              /* NICSR access width: 0=>byte, 1=>word */
  318.     short ringSize;             /* ring size based on available memory */
  319.     short rmask;                /* modulus mask based on ring size */
  320.     long rlen;                  /* log2(ringSize) for the descriptors */
  321. };
  322.  
  323. /*
  324. ** Public Functions
  325. */
  326. static int depca_open(struct device *dev);
  327. static int depca_start_xmit(struct sk_buff *skb, struct device *dev);
  328. static void depca_interrupt(int irq, struct pt_regs * regs);
  329. static int depca_close(struct device *dev);
  330. static struct enet_statistics *depca_get_stats(struct device *dev);
  331. #ifdef HAVE_MULTICAST
  332. static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
  333. #endif
  334.  
  335. /*
  336. ** Private functions
  337. */
  338. static int  depca_probe1(struct device *dev, short ioaddr);
  339. static void depca_init_ring(struct device *dev);
  340. static int  depca_rx(struct device *dev);
  341. static int  depca_tx(struct device *dev);
  342.  
  343. static void LoadCSRs(struct device *dev);
  344. static int  InitRestartDepca(struct device *dev);
  345. static char *DepcaSignature(unsigned long mem_addr);
  346. static int  DevicePresent(short ioaddr);
  347. static int  EISA_signature(short iobase);
  348. #ifdef HAVE_MULTICAST
  349. static void SetMulticastFilter(int num_addrs, char *addrs, char *multicast_table);
  350. #endif
  351.  
  352. #ifndef MODULE
  353. static struct device *isa_probe(struct device *dev);
  354. static struct device *eisa_probe(struct device *dev);
  355. static struct device *alloc_device(struct device *dev, int ioaddr);
  356.  
  357. static int num_depcas = 0, num_eth = 0, autoprobed = 0;
  358.  
  359. #else
  360. int  init_module(void);
  361. void cleanup_module(void);
  362.  
  363. #endif /* MODULE */
  364.  
  365. /*
  366. ** Miscellaneous defines...
  367. */
  368. #define STOP_DEPCA \
  369.     outw(CSR0, DEPCA_ADDR);\
  370.     outw(STOP, DEPCA_DATA)
  371.  
  372.  
  373.  
  374.  
  375. int depca_probe(struct device *dev)
  376. {
  377.     short base_addr = dev->base_addr;
  378.     int status = -ENODEV;
  379. #ifndef MODULE
  380.     struct device *eth0;
  381. #endif
  382.  
  383.     if (base_addr > 0x1ff) {          /* Check a single specified location. */
  384.       if (DevicePresent(base_addr) == 0) { /* Is DEPCA really here? */
  385.     status = depca_probe1(dev, base_addr);
  386.       }
  387.     } else if (base_addr > 0) {          /* Don't probe at all. */
  388.       status = -ENXIO;
  389.  
  390. #ifdef MODULE
  391.     } else {
  392.       printk("Autoprobing is not supported when loading a module based driver.\n");
  393.       status = -EIO;
  394. #else
  395.     } else if (!autoprobed) {         /* First probe for the DEPCA test */
  396.                                       /* pattern in ROM */
  397.       eth0=isa_probe(dev);
  398.       eth0=eisa_probe(eth0);
  399.       if (dev->priv) status=0;
  400.       autoprobed = 1;
  401.     } else {
  402.       status = -ENXIO;
  403. #endif /* MODULE */
  404.  
  405.     }
  406.  
  407.     if (status) dev->base_addr = base_addr;
  408.  
  409.     return status;            /* ENODEV would be more accurate. */
  410. }
  411.  
  412. static int
  413. depca_probe1(struct device *dev, short ioaddr)
  414. {
  415.     struct depca_private *lp;
  416.     int i,j, status=0;
  417.     unsigned long mem_start, mem_base[] = DEPCA_RAM_BASE_ADDRESSES;
  418.     char *name = NULL;
  419.     unsigned int nicsr, offset, netRAM;
  420.  
  421.  
  422.     /*
  423.     ** Stop the DEPCA. Enable the DBR ROM. Disable interrupts and remote boot.
  424.     */
  425.     STOP_DEPCA;
  426.  
  427.     nicsr = inb(DEPCA_NICSR);
  428.     nicsr = ((nicsr & ~SHE & ~RBE & ~IEN) | IM);
  429.     outb(nicsr, DEPCA_NICSR);
  430.  
  431.     if (inw(DEPCA_DATA) == STOP) {
  432.  
  433.     /* Now find out what kind of DEPCA we have. The DE100 uses a different
  434.     ** addressing scheme for some registers compared to the DE2xx series.
  435.     ** Note that a base address location is marked as checked if no DEPCA is
  436.     ** there or one is found (when the search is immediately terminated). This
  437.     ** shortens the search time a little for multiple DEPCAs.
  438.     */
  439.  
  440.       for (j = 0, i = 0; mem_base[i] && (j == 0);i++) {
  441.     if (((mem_chkd >> i) & 0x01) == 0) { /* has the memory been checked? */
  442.       name = DepcaSignature(mem_base[i]);/* check for a DEPCA here */
  443.       mem_chkd |= (0x01 << i);           /* mark location checked */
  444.       if (*name != '\0') {               /* one found? */
  445.         j = 1;                           /* set exit flag */
  446.         --i;
  447.       }
  448.     }
  449.       }
  450.  
  451.       if (*name != '\0') {                   /* found a DEPCA device */
  452.     mem_start = mem_base[i];
  453.     dev->base_addr = ioaddr;
  454.  
  455.     if ((ioaddr&0x0fff)==DEPCA_EISA_IO_PORTS) {/* EISA slot address */
  456.       printk("%s: %s at %#3x (EISA slot %d)", 
  457.                          dev->name, name, ioaddr, ((ioaddr>>12)&0x0f));
  458.     } else {                             /* ISA port address */
  459.       printk("%s: %s at %#3x", dev->name, name, ioaddr);
  460.     }
  461.  
  462.       /* There is a 32 byte station address PROM at DEPCA_PROM address.
  463.      The first six bytes are the station address. They can be read
  464.      directly since the signature search set up the ROM address 
  465.      counter correctly just before this function.
  466.  
  467.      For the DE100 we have to be careful about which port is used to
  468.      read the ROM info.
  469.       */
  470.  
  471.     if (strstr(name,"DE100")!= NULL) {
  472.       j = 1;
  473.     } else {
  474.       j = 0;
  475.     }
  476.  
  477.     printk(", h/w address ");
  478.     for (i = 0; i < ETH_ALEN - 1; i++) { /* get the ethernet address */
  479.       printk("%2.2x:", dev->dev_addr[i] = inb(DEPCA_PROM + j));
  480.     }
  481.     printk("%2.2x", dev->dev_addr[i] = inb(DEPCA_PROM + j));
  482.  
  483.     for (;i<32;i++) {                /* leave ROM counter in known state */
  484.       j=inb(DEPCA_PROM);
  485.     }
  486.  
  487.     request_region(ioaddr, DEPCA_TOTAL_SIZE, dev->name);
  488.  
  489.     /*
  490.     ** Set up the maximum amount of network RAM(kB)
  491.     */
  492.     if (strstr(name,"DEPCA")== NULL) {
  493.       netRAM=64;
  494.     } else {
  495.       netRAM=48;
  496.     }
  497.  
  498.     /* 
  499.     ** Determine the base address for the DEPCA RAM from the NI-CSR
  500.     ** and make up a DEPCA-specific-data structure. 
  501.         */
  502.  
  503.     if (nicsr & BUF) {
  504.       offset = 0x8000;              /* 32kbyte RAM offset*/
  505.       nicsr &= ~BS;                 /* DEPCA RAM in top 32k */
  506.       printk(",\n      has %dkB RAM", netRAM - 32);
  507.     } else     if ((nicsr & _128KB) && (netRAM!=48)) {
  508.       offset = 0x0000;
  509.       printk(",\n      has 128kB RAM");
  510.     } else {
  511.       offset = 0x0000;              /* 64k/48k bytes RAM */
  512.       printk(",\n      has %dkB RAM", netRAM);
  513.     }
  514.  
  515.     mem_start += offset;            /* (E)ISA start address */
  516.     printk(" at 0x%.5lx", mem_start);
  517.  
  518.     /*
  519.     ** Enable the shadow RAM.
  520.     */
  521.     if (strstr(name,"DEPCA") == NULL) {
  522.       nicsr |= SHE;
  523.       outb(nicsr, DEPCA_NICSR);
  524.     }
  525.  
  526.     /*
  527.     ** Calculate the ring size based on the available RAM
  528.     ** found above. Allocate an equal number of buffers, each
  529.     ** of size PKT_BUF_SZ (1544 bytes) to the Tx and Rx, allowing one
  530.     ** descriptor entry (8 bytes) for each buffer. Make sure
  531.     ** that this ring size is <= RING_SIZE. The ring size must be
  532.     ** a power of 2.
  533.     */
  534.  
  535.     j = (((netRAM << 10) - offset - sizeof(struct depca_private)) / 
  536.                                                    (PKT_BUF_SZ + 8)) >> 1;
  537.     for (i=0;j>1;i++) {
  538.       j >>= 1;
  539.     }
  540.  
  541.     /* Hold the ring size information here before the depca
  542.     ** private structure is allocated. Need this for the memory
  543.     ** space calculations.
  544.     */
  545.     j = 1 << i;
  546.  
  547.     /*
  548.     ** Set up memory information in the device structure.
  549.     ** Align the descriptor rings on an 8 byte (quadword) boundary.
  550.     **
  551.     **     depca_private area
  552.     **     rx ring descriptors
  553.     **     tx ring descriptors
  554.     **     rx buffers
  555.     **     tx buffers
  556.     **
  557.     */
  558.  
  559.     /* private area & initialise */
  560.     dev->priv = (void *)((mem_start + 0x07) & ~0x07);      
  561.     lp = (struct depca_private *)dev->priv;
  562.     memset(dev->priv, 0, sizeof(struct depca_private));
  563.     strcpy(lp->devname,name);
  564.  
  565.     /* Tx & Rx descriptors (aligned to a quadword boundary) */
  566.     mem_start = ((((unsigned long)dev->priv + 
  567.                 sizeof(struct depca_private)) +
  568.             (unsigned long)0x07) & (unsigned long)~0x07);
  569.     lp->rx_ring = (struct depca_rx_head *)mem_start;
  570.  
  571.     mem_start += (sizeof(struct depca_rx_head) * j);
  572.     lp->tx_ring = (struct depca_tx_head *)mem_start;
  573.  
  574.     mem_start += (sizeof(struct depca_tx_head) * j);
  575.     lp->bus_offset = mem_start & 0x00ff0000;
  576.     mem_start &= LA_MASK;           /* LANCE re-mapped start address */
  577.  
  578.     lp->dma_buffs = mem_start;
  579.  
  580.     mem_start += (PKT_BUF_SZ * j);
  581.     /* (mem_start now points to the start of the Tx buffers) */
  582.  
  583.     /* Initialise the data structures wrt CPU */
  584.     memset(lp->rx_ring, 0, sizeof(struct depca_rx_head)*j);
  585.     memset(lp->tx_ring, 0, sizeof(struct depca_tx_head)*j);
  586.  
  587.     /* This should never happen. */
  588.     if ((long)(lp->rx_ring) & 0x07) {
  589.       printk("\n **ERROR** DEPCA Rx and Tx descriptor rings not on a quadword boundary.\n");
  590.       return -ENXIO;
  591.     }
  592.  
  593.     /*
  594.     ** Finish initialising the ring information.
  595.     */
  596.     lp->ringSize = j;
  597.     if (lp->ringSize > RING_SIZE) lp->ringSize = RING_SIZE;
  598.     lp->rmask = lp->ringSize - 1;
  599.  
  600.     /*
  601.     ** calculate the real RLEN size for the descriptors. It is
  602.     ** log2(ringSize).
  603.     */
  604.     for (i=0, j = lp->ringSize; j>1; i++) {
  605.       j >>= 1;
  606.     }
  607.     lp->rlen = (unsigned long)(i << 29);
  608.  
  609.     /*
  610.     ** load the initialisation block
  611.     */
  612.     depca_init_ring(dev);
  613.  
  614.     /*
  615.     ** Initialise the control and status registers
  616.     */
  617.     LoadCSRs(dev);
  618.  
  619.     /*
  620.     ** Enable DEPCA board interrupts for autoprobing
  621.     */
  622.     nicsr = ((nicsr & ~IM)|IEN);
  623.     outb(nicsr, DEPCA_NICSR);
  624.  
  625.     /* The DMA channel may be passed in on this parameter. */
  626.     dev->dma = 0;
  627.  
  628.     /* To auto-IRQ we enable the initialization-done and DMA err,
  629.      interrupts. For now we will always get a DMA error. */
  630.     if (dev->irq < 2) {
  631. #ifndef MODULE
  632.       autoirq_setup(0);
  633.  
  634.       /* Trigger an initialization just for the interrupt. */
  635.       outw(INEA | INIT, DEPCA_DATA);
  636.       
  637.       dev->irq = autoirq_report(1);
  638.       if (dev->irq) {
  639.         printk(" and uses IRQ%d.\n", dev->irq);
  640.       } else {
  641.         printk(" and failed to detect IRQ line.\n");
  642.         status = -EAGAIN;
  643.       }
  644. #endif /* MODULE */
  645.     } else {
  646.       printk(" and assigned IRQ%d.\n", dev->irq);
  647.     }
  648.       } else {
  649.     status = -ENXIO;
  650.       }
  651.       if (!status) {
  652.     if (depca_debug > 0) {
  653.       printk(version);
  654.     }
  655.  
  656.     /* The DEPCA-specific entries in the device structure. */
  657.     dev->open = &depca_open;
  658.     dev->hard_start_xmit = &depca_start_xmit;
  659.     dev->stop = &depca_close;
  660.     dev->get_stats = &depca_get_stats;
  661. #ifdef HAVE_MULTICAST
  662.     dev->set_multicast_list = &set_multicast_list;
  663. #endif
  664.  
  665.     dev->mem_start = 0;
  666.     
  667.     /* Fill in the generic field of the device structure. */
  668.      ether_setup(dev);
  669.       }
  670.     } else {
  671.       status = -ENXIO;
  672.     }
  673.  
  674.     return status;
  675. }
  676.  
  677.  
  678. static int
  679. depca_open(struct device *dev)
  680. {
  681.     struct depca_private *lp = (struct depca_private *)dev->priv;
  682.     int i,nicsr,ioaddr = dev->base_addr;
  683.  
  684.     if (request_irq(dev->irq, &depca_interrupt, 0, "depca")) {
  685.         printk("depca_open(): Requested IRQ%d is busy\n",dev->irq);
  686.     return -EAGAIN;
  687.     }
  688.  
  689.     irq2dev_map[dev->irq] = dev;
  690.  
  691.     /*
  692.     ** Stop the DEPCA & get the board status information.  
  693.     */
  694.     STOP_DEPCA;
  695.     nicsr = inb(DEPCA_NICSR);
  696.  
  697.     /*
  698.     ** Make sure the shadow RAM is enabled
  699.     */
  700.     if (strstr(lp->devname,"DEPCA") == NULL) {
  701.       nicsr |= SHE;
  702.       outb(nicsr, DEPCA_NICSR);
  703.     }
  704.  
  705.     /* 
  706.     ** Re-initialize the DEPCA... 
  707.     */
  708.     depca_init_ring(dev);                 /* initialize the descriptor rings */
  709.     LoadCSRs(dev);
  710.  
  711.     if (depca_debug > 1){
  712.       printk("%s: depca open with irq %d\n",dev->name,dev->irq);
  713.       printk("Descriptor head addresses:\n");
  714.       printk("\t0x%8.8lx  0x%8.8lx\n",(long)lp->rx_ring,(long)lp->tx_ring);
  715.       printk("Descriptor addresses:\n");
  716.       for (i=0;i<lp->ringSize;i++){
  717.     printk("\t0x%8.8lx  0x%8.8lx\n",(long)&lp->rx_ring[i].base,
  718.                                     (long)&lp->tx_ring[i].base);
  719.       }
  720.       printk("Buffer addresses:\n");
  721.       for (i=0;i<lp->ringSize;i++){
  722.     printk("\t0x%8.8lx  0x%8.8lx\n",(long)lp->rx_ring[i].base,
  723.                                         (long)lp->tx_ring[i].base);
  724.       }
  725.       printk("Initialisation block at 0x%8.8lx\n",(long)&lp->init_block);
  726.       printk("\tmode: 0x%4.4x\n",lp->init_block.mode);
  727.       printk("\tphysical address: ");
  728.       for (i=0;i<6;i++){
  729.     printk("%2.2x:",(short)lp->init_block.phys_addr[i]);
  730.       }
  731.       printk("\n\tlogical address filter: 0x");
  732.       for (i=0;i<4;i++){
  733.     printk("%2.2x",(short)lp->init_block.filter[i]);
  734.       }
  735.       printk("\n\trx_ring at: 0x%8.8lx\n",(long)lp->init_block.rx_ring);
  736.       printk("\ttx_ring at: 0x%8.8lx\n",(long)lp->init_block.tx_ring);
  737.       printk("dma_buffs: 0x%8.8lx\n",(long)lp->dma_buffs);
  738.       printk("Ring size: %d\nMask: 0x%2.2x\nLog2(ringSize): 0x%8.8lx\n", 
  739.                                          (short)lp->ringSize, 
  740.                                           (char)lp->rmask,
  741.                                           (long)lp->rlen);
  742.       outw(CSR2,DEPCA_ADDR);
  743.       printk("CSR2&1: 0x%4.4x",inw(DEPCA_DATA));
  744.       outw(CSR1,DEPCA_ADDR);
  745.       printk("%4.4x\n",inw(DEPCA_DATA));
  746.       outw(CSR3,DEPCA_ADDR);
  747.       printk("CSR3: 0x%4.4x\n",inw(DEPCA_DATA));
  748.     }
  749.  
  750.     /*
  751.     ** Enable DEPCA board interrupts and turn off LED
  752.     */
  753.     nicsr = ((nicsr & ~IM & ~LED)|IEN);
  754.     outb(nicsr, DEPCA_NICSR);
  755.     outw(CSR0,DEPCA_ADDR);
  756.  
  757.     dev->tbusy = 0;                         
  758.     dev->interrupt = 0;
  759.     dev->start = 1;
  760.  
  761.     InitRestartDepca(dev);                /* ignore the return status */
  762.  
  763.     if (depca_debug > 1){
  764.       printk("CSR0: 0x%4.4x\n",inw(DEPCA_DATA));
  765.       printk("nicsr: 0x%02x\n",inb(DEPCA_NICSR));
  766.     }
  767.  
  768.     MOD_INC_USE_COUNT;
  769.  
  770.     return 0;                      /* Always succeed */
  771. }
  772.  
  773. /* Initialize the lance Rx and Tx descriptor rings. */
  774. static void
  775. depca_init_ring(struct device *dev)
  776. {
  777.     struct depca_private *lp = (struct depca_private *)dev->priv;
  778.     unsigned long i;
  779.  
  780.     lp->init_block.mode = DTX | DRX;         /* Disable Rx and Tx. */
  781.     lp->cur_rx = lp->cur_tx = 0;
  782.     lp->dirty_rx = lp->dirty_tx = 0;
  783.  
  784.     /* Initialize the base addresses and length of each buffer in the ring */
  785.     for (i = 0; i < lp->ringSize; i++) {
  786.     lp->rx_ring[i].base = (lp->dma_buffs + i*PKT_BUF_SZ) | R_OWN;
  787.     lp->rx_ring[i].buf_length = -PKT_BUF_SZ;
  788.     lp->tx_ring[i].base = (lp->dma_buffs + (i+lp->ringSize) * PKT_BUF_SZ) &
  789.                                                (unsigned long)(0x00ffffff);
  790.     }
  791.  
  792.     /* Set up the initialization block */
  793.     for (i = 0; i < ETH_ALEN; i++) {
  794.       lp->init_block.phys_addr[i] = dev->dev_addr[i];
  795.     }
  796.     for (i = 0; i < 4; i++) {
  797.       lp->init_block.filter[i] = 0x0000;
  798.     }
  799.     lp->init_block.rx_ring = ((unsigned long)lp->rx_ring & LA_MASK) | lp->rlen;
  800.     lp->init_block.tx_ring = ((unsigned long)lp->tx_ring & LA_MASK) | lp->rlen;
  801.  
  802.     lp->init_block.mode = 0x0000;            /* Enable the Tx and Rx */ 
  803. }
  804.  
  805. /* 
  806. ** Writes a socket buffer to TX descriptor ring and starts transmission 
  807. */
  808. static int
  809. depca_start_xmit(struct sk_buff *skb, struct device *dev)
  810. {
  811.     struct depca_private *lp = (struct depca_private *)dev->priv;
  812.     int ioaddr = dev->base_addr;
  813.     int status = 0;
  814.  
  815.     /* Transmitter timeout, serious problems. */
  816.     if (dev->tbusy) {
  817.       int tickssofar = jiffies - dev->trans_start;
  818.       if (tickssofar < 10) {
  819.     status = -1;
  820.       } else {
  821.     printk("%s: transmit timed out, status %04x, resetting.\n",
  822.            dev->name, inw(DEPCA_DATA));
  823.     
  824.     STOP_DEPCA;
  825.     depca_init_ring(dev);
  826.     LoadCSRs(dev);
  827.     InitRestartDepca(dev);
  828.     dev->tbusy=0;
  829.     dev->trans_start = jiffies;
  830.       }
  831.       return status;
  832.     }
  833.  
  834.     if (skb == NULL) {
  835.     dev_tint(dev);
  836.     return 0;
  837.     }
  838.  
  839.     if (skb->len <= 0) {
  840.       return 0;
  841.     }
  842.  
  843.     if (depca_debug > 3) {
  844.     outw(CSR0, DEPCA_ADDR);
  845.     printk("%s: depca_start_xmit() called, csr0 %4.4x.\n", dev->name,
  846.            inw(DEPCA_DATA));
  847.     }
  848.  
  849.     /* Block a timer-based transmit from overlapping.  This could better be
  850.        done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
  851.     if (set_bit(0, (void*)&dev->tbusy) != 0)
  852.     printk("%s: Transmitter access conflict.\n", dev->name);
  853.  
  854.     /*
  855.     ** The TX buffer, skb, has to be copied into the local network RAM
  856.     ** for the LANCE to access it. The skb may be at > 16MB for large 
  857.     ** (memory) systems.
  858.     */
  859.     {                /* Fill in a Tx ring entry */
  860.       unsigned char *buf;
  861.       int entry = lp->cur_tx++;
  862.       int len;
  863.       long skbL = skb->len;
  864.       char *p = (char *) skb->data;
  865.  
  866.       entry &= lp->rmask;              /* Ring around buffer number. */
  867.       buf = (unsigned char *)((lp->tx_ring[entry].base+lp->bus_offset) & 
  868.                                                        0x00ffffff);
  869.  
  870.       /* Wait for a full ring to free up */
  871.       while (lp->tx_ring[entry].base < 0);
  872.  
  873.       /* 
  874.       ** Caution: the write order is important here... don't set up the
  875.       ** ownership rights until all the other information is in place.
  876.       */
  877.       len = ((skbL > PKT_SZ) ? PKT_SZ : skbL); /* skb too long */
  878.       if (len < ETH_ZLEN) len = ETH_ZLEN;      /* len too short */
  879.       skbL -= len;
  880.       lp->tx_ring[entry].length = -len;
  881.  
  882.       /* Clears various error flags */
  883.       lp->tx_ring[entry].misc = 0x0000;
  884.  
  885.       /* copy the data from the socket buffer to the net memory */
  886.       memcpy((unsigned char *)(buf), skb->data, len);
  887.  
  888.       /* Hand over buffer ownership to the LANCE */
  889.       if (skbL <= 0) lp->tx_ring[entry].base |= (T_ENP);
  890.       lp->tx_ring[entry].base |= (T_OWN|T_STP);
  891.  
  892.       /* Trigger an immediate send demand. */
  893.       outw(CSR0, DEPCA_ADDR);
  894.       outw(INEA | TDMD, DEPCA_DATA);
  895.  
  896.       dev->trans_start = jiffies;
  897.  
  898.       for (p += len; skbL > 0; p += len) {
  899.  
  900.     /* Get new buffer pointer */
  901.     entry = lp->cur_tx++;
  902.     entry &= lp->rmask;              /* Ring around buffer number. */
  903.     buf = (unsigned char *)((lp->tx_ring[entry].base+lp->bus_offset) &
  904.                                                    0x00ffffff);
  905.  
  906.     /* Wait for a full ring to free up */
  907.     while (lp->tx_ring[entry].base < 0);
  908.     dev->tbusy=0;
  909.  
  910.     /* Copy ethernet header to the new buffer */
  911.     memcpy((unsigned char *)buf, skb->data, PKT_HDR_LEN);
  912.  
  913.     /* Determine length of data buffer */
  914.     len = ((skbL > DAT_SZ) ? DAT_SZ : skbL); /* skbL too long */
  915.     if (len < ETH_ZLEN) len = ETH_ZLEN;      /* len too short */
  916.     skbL -= len;
  917.     lp->tx_ring[entry].length = -len;
  918.  
  919.     /* Clears various error flags */
  920.     lp->tx_ring[entry].misc = 0x0000;
  921.  
  922.     /* copy the data from the socket buffer to the net memory */
  923.     memcpy((unsigned char *)(buf + PKT_HDR_LEN), (unsigned char *)p, len);
  924.  
  925.     /* Hand over buffer ownership to the LANCE */
  926.     if (skbL <= 0) lp->tx_ring[entry].base |= T_ENP;
  927.     lp->tx_ring[entry].base |= T_OWN;
  928.       }
  929.  
  930.       if (depca_debug > 4) {
  931.     unsigned char *pkt =
  932.       (unsigned char *)((lp->tx_ring[entry].base+lp->bus_offset) &
  933.                                                        0x00ffffff);
  934.  
  935.     printk("%s: tx ring[%d], %#lx, sk_buf %#lx len %d.\n",
  936.            dev->name, entry, (unsigned long) &lp->tx_ring[entry],
  937.            lp->tx_ring[entry].base, -lp->tx_ring[entry].length);
  938.     printk("%s:  Tx %2.2x %2.2x %2.2x ... %2.2x  %2.2x %2.2x %2.2x...%2.2x len %2.2x %2.2x  %2.2x %2.2x.\n",
  939.            dev->name, pkt[0], pkt[1], pkt[2], pkt[5], pkt[6],
  940.            pkt[7], pkt[8], pkt[11], pkt[12], pkt[13],
  941.            pkt[14], pkt[15]);
  942.       }
  943.       
  944.       /* Check if the TX ring is full or not - 'tbusy' cleared if not full. */
  945.       if (lp->tx_ring[(entry+1) & lp->rmask].base >= 0) {
  946.     dev->tbusy=0;
  947.       }
  948.  
  949.       dev_kfree_skb (skb, FREE_WRITE);
  950.     }
  951.  
  952.     return 0;
  953. }
  954.  
  955. /*
  956. ** The DEPCA interrupt handler. 
  957. */
  958. static void
  959. depca_interrupt(int irq, struct pt_regs * regs)
  960. {
  961.     struct device *dev = (struct device *)(irq2dev_map[irq]);
  962.     struct depca_private *lp;
  963.     int csr0, ioaddr, nicsr;
  964.  
  965.     if (dev == NULL) {
  966.     printk ("depca_interrupt(): irq %d for unknown device.\n", irq);
  967.     } else {
  968.       lp = (struct depca_private *)dev->priv;
  969.       ioaddr = dev->base_addr;
  970.  
  971.       if (dev->interrupt)
  972.     printk("%s: Re-entering the interrupt handler.\n", dev->name);
  973.  
  974.       dev->interrupt = MASK_INTERRUPTS;
  975.  
  976.       /* mask the DEPCA board interrupts and turn on the LED */
  977.       nicsr = inb(DEPCA_NICSR);
  978.       nicsr |= (IM|LED);
  979.       outb(nicsr, DEPCA_NICSR);
  980.  
  981.       outw(CSR0, DEPCA_ADDR);
  982.       csr0 = inw(DEPCA_DATA);
  983.  
  984.       /* Acknowledge all of the current interrupt sources ASAP. */
  985.       outw(csr0 & ~(INEA|TDMD|STOP|STRT|INIT), DEPCA_DATA);
  986.  
  987.       if (depca_debug > 5)
  988.     printk("%s: interrupt  csr0=%#2.2x new csr=%#2.2x.\n",
  989.            dev->name, csr0, inw(DEPCA_DATA));
  990.  
  991.       if (csr0 & RINT)        /* Rx interrupt (packet arrived) */
  992.     depca_rx(dev);
  993.  
  994.       if (csr0 & TINT)             /* Tx interrupt (packet sent) */
  995.         depca_tx(dev);
  996.  
  997.       /* Clear the interrupts we've handled. */
  998.       outw(CSR0, DEPCA_ADDR);
  999.       outw(BABL|CERR|MISS|MERR|RINT|TINT|IDON|INEA, DEPCA_DATA);
  1000.  
  1001.       if (depca_debug > 4) {
  1002.     printk("%s: exiting interrupt, csr%d=%#4.4x.\n",
  1003.            dev->name, inw(DEPCA_ADDR),
  1004.            inw(DEPCA_DATA));
  1005.       }
  1006.  
  1007.       /* Unmask the DEPCA board interrupts and turn off the LED */
  1008.       nicsr = (nicsr & ~IM & ~LED);
  1009.       outb(nicsr, DEPCA_NICSR);
  1010.       dev->interrupt = UNMASK_INTERRUPTS;
  1011.     }
  1012.  
  1013.     return;
  1014. }
  1015.  
  1016. static int
  1017. depca_rx(struct device *dev)
  1018. {
  1019.     struct depca_private *lp = (struct depca_private *)dev->priv;
  1020.     int entry = lp->cur_rx & lp->rmask;
  1021.  
  1022.     /* If we own the next entry, it's a new packet. Send it up. */
  1023.     for (; lp->rx_ring[entry].base >= 0; entry = (++lp->cur_rx) & lp->rmask) {
  1024.     int status = lp->rx_ring[entry].base >> 16 ;
  1025.     int chained;
  1026.  
  1027.     /*
  1028.     ** There is a tricky error noted by John Murphy, <murf@perftech.com>
  1029.     ** to Russ Nelson: even with full-sized buffers, it's possible for a
  1030.     ** jabber packet to use two buffers, with only the last one correctly
  1031.     ** noting the error.
  1032.     */
  1033.  
  1034.     /* Check for a chaining buffer */
  1035.     chained = 0;
  1036.     if (status == R_STP) { 
  1037.       chained = 1;
  1038.  
  1039.       /* 
  1040.       ** Wait for next buffer to complete to check for errors. This
  1041.       ** is slow but infrequent and allows for correct hardware buffer
  1042.       ** chaining (whilst defeating the chaining's purpose).
  1043.       */
  1044.       while ((status=(lp->rx_ring[(entry+1)&lp->rmask].base >> 16)) < 0);
  1045.  
  1046.       /* NB: 'status' now comes from the buffer following 'entry'. */
  1047.     }
  1048.       
  1049.     if (status & R_ERR) {                   /* There was an error. */
  1050.         lp->stats.rx_errors++;             /* Update the error stats. */
  1051.         if (status & R_FRAM) lp->stats.rx_frame_errors++;
  1052.         if (status & R_OFLO) lp->stats.rx_over_errors++;
  1053.         if (status & R_CRC)  lp->stats.rx_crc_errors++;
  1054.         if (status & R_BUFF) lp->stats.rx_fifo_errors++;
  1055.     } else {      /* Malloc up new buffer, compatible  with net-2e. */
  1056.         short pkt_len = lp->rx_ring[entry].msg_length;
  1057.         struct sk_buff *skb;
  1058.  
  1059.         skb = alloc_skb(pkt_len, GFP_ATOMIC);
  1060.         if (skb == NULL) {
  1061.         printk("%s: Memory squeeze, deferring packet.\n", dev->name);
  1062.         lp->stats.rx_dropped++;    /* Really, deferred. */
  1063.         break;
  1064.         }
  1065.         skb->len = pkt_len;
  1066.         skb->dev = dev;
  1067.         memcpy(skb->data,
  1068.           (unsigned char *)((lp->rx_ring[entry].base+lp->bus_offset) &
  1069.                                                    0x00ffffff),
  1070.            pkt_len);
  1071.         /* 
  1072.         ** Notify the upper protocol layers that there is another 
  1073.         ** packet to handle
  1074.         */
  1075.         netif_rx(skb);
  1076.         lp->stats.rx_packets++;
  1077.     }
  1078.  
  1079.     /* turn over ownership of the current entry back to the LANCE */
  1080.     lp->rx_ring[entry].base |= R_OWN;
  1081.     if (chained && (status & R_ERR)) {          /* next entry also bad */
  1082.       entry = (++lp->cur_rx) & lp->rmask;
  1083.       lp->rx_ring[entry].base |= R_OWN;
  1084.     }
  1085.     }
  1086.  
  1087.     /* 
  1088.     ** We should check that at least two ring entries are free.  If not,
  1089.     ** we should free one and mark stats->rx_dropped++. 
  1090.     */
  1091.  
  1092.     return 0;
  1093. }
  1094.  
  1095. /*
  1096. ** Buffer sent - check for buffer errors.
  1097. */
  1098. static int
  1099. depca_tx(struct device *dev)
  1100. {
  1101.   struct depca_private *lp = (struct depca_private *)dev->priv;
  1102.   int dirty_tx = lp->dirty_tx & lp->rmask;
  1103.  
  1104.   if (depca_debug > 5)
  1105.     printk("%s: Cleaning tx ring, dirty %d clean %d.\n",
  1106.        dev->name, dirty_tx, (lp->cur_tx & lp->rmask));
  1107.   
  1108.   /* 
  1109.   ** While the dirty entry is not the current one AND 
  1110.   ** the LANCE doesn't own it... 
  1111.   */
  1112.   for (; dirty_tx!=(lp->cur_tx & lp->rmask) && lp->tx_ring[dirty_tx].base>0;
  1113.                                        dirty_tx = ++lp->dirty_tx & lp->rmask) {
  1114.     unsigned long *tmdp = (unsigned long *)(&lp->tx_ring[dirty_tx]);
  1115.     int status = lp->tx_ring[dirty_tx].base >> 16;
  1116.  
  1117.     if (status < 0) {                          /* Packet not yet sent! */
  1118.       printk("interrupt for packet not yet sent!\n");
  1119.       break;
  1120.     }
  1121.     if (status & T_ERR) { /* There was an major error, log it. */
  1122.       int err_status = lp->tx_ring[dirty_tx].misc;
  1123.  
  1124.       lp->stats.tx_errors++;
  1125.       if (err_status & TMD3_RTRY) lp->stats.tx_aborted_errors++;
  1126.       if (err_status & TMD3_LCAR) lp->stats.tx_carrier_errors++;
  1127.       if (err_status & TMD3_LCOL) lp->stats.tx_window_errors++;
  1128.       if (err_status & TMD3_UFLO) lp->stats.tx_fifo_errors++;
  1129.       /* We should re-init() after the FIFO error. */
  1130.     } else if (status & (T_MORE | T_ONE)) {
  1131.       lp->stats.collisions++;
  1132.     } else {
  1133.       lp->stats.tx_packets++;
  1134.     }
  1135.  
  1136.     if (depca_debug > 5)
  1137.       printk("%s: Tx done entry %d, %4.4lx %4.4lx %4.4lx %4.4lx.\n",
  1138.          dev->name, dirty_tx,
  1139.          tmdp[0], tmdp[1], tmdp[2], tmdp[3]);
  1140.   }
  1141.   /*mark_bh(INET_BH);*/
  1142.   return 0;
  1143. }
  1144.  
  1145. static int
  1146. depca_close(struct device *dev)
  1147. {
  1148.   struct depca_private *lp = (struct depca_private *)dev->priv;
  1149.   int nicsr, ioaddr = dev->base_addr;
  1150.  
  1151.   dev->start = 0;
  1152.   dev->tbusy = 1;
  1153.  
  1154.   outw(CSR0, DEPCA_ADDR);
  1155.  
  1156.   if (depca_debug > 1) {
  1157.     printk("%s: Shutting down ethercard, status was %2.2x.\n",
  1158.        dev->name, inw(DEPCA_DATA));
  1159.   }
  1160.  
  1161.   /* 
  1162.   ** We stop the DEPCA here -- it occasionally polls
  1163.   ** memory if we don't. 
  1164.   */
  1165.   outw(STOP, DEPCA_DATA);
  1166.  
  1167.   /*
  1168.   ** Give back the ROM in case the user wants to go to DOS
  1169.   */
  1170.   if (strstr(lp->devname,"DEPCA") == NULL) {
  1171.     nicsr = inb(DEPCA_NICSR);
  1172.     nicsr &= ~SHE;
  1173.     outb(nicsr, DEPCA_NICSR);
  1174.   }
  1175.  
  1176.   free_irq(dev->irq);
  1177.  
  1178.   irq2dev_map[dev->irq] = 0;
  1179.  
  1180.   MOD_DEC_USE_COUNT;
  1181.  
  1182.   return 0;
  1183. }
  1184.  
  1185. static void LoadCSRs(struct device *dev)
  1186. {
  1187.   struct depca_private *lp = (struct depca_private *)dev->priv;
  1188.   int ioaddr = dev->base_addr;
  1189.  
  1190.   outw(CSR1, DEPCA_ADDR);                /* initialisation block address LSW */
  1191.   outw((unsigned short)((unsigned long)(&lp->init_block) & LA_MASK), 
  1192.                                                                    DEPCA_DATA);
  1193.   outw(CSR2, DEPCA_ADDR);                /* initialisation block address MSW */
  1194.   outw((unsigned short)(((unsigned long)(&lp->init_block) & LA_MASK) >> 16), 
  1195.                                                                    DEPCA_DATA);
  1196.   outw(CSR3, DEPCA_ADDR);                /* ALE control */
  1197.   outw(ACON, DEPCA_DATA);
  1198.   outw(CSR0, DEPCA_ADDR);                /* point back to CSR0 */
  1199. }
  1200.  
  1201. static int InitRestartDepca(struct device *dev)
  1202. {
  1203.   struct depca_private *lp = (struct depca_private *)dev->priv;
  1204.   int ioaddr = dev->base_addr;
  1205.   int i, status=0;
  1206.  
  1207.   outw(CSR0, DEPCA_ADDR);                /* point back to CSR0 */
  1208.   outw(INIT, DEPCA_DATA);                /* initialize DEPCA */
  1209.  
  1210.   /* wait for lance to complete initialisation */
  1211.   for (i=0;(i<100) && !(inw(DEPCA_DATA) & IDON); i++); 
  1212.  
  1213.   if (i!=100) {
  1214.     /* clear IDON by writing a "1", enable interrupts and start lance */
  1215.     outw(IDON | INEA | STRT, DEPCA_DATA);
  1216.     if (depca_debug > 2) {
  1217.       printk("%s: DEPCA open after %d ticks, init block %#lx csr0 %4.4x.\n",
  1218.          dev->name, i, (long) &lp->init_block, inw(DEPCA_DATA));
  1219.     }
  1220.   } else {
  1221.     status = -1;
  1222.     printk("%s: DEPCA unopened after %d ticks, init block %#lx csr0 %4.4x.\n",
  1223.        dev->name, i, (long) &lp->init_block, inw(DEPCA_DATA));
  1224.   }
  1225.  
  1226.   return status;
  1227. }
  1228.  
  1229. static struct enet_statistics *
  1230. depca_get_stats(struct device *dev)
  1231. {
  1232.     struct depca_private *lp = (struct depca_private *)dev->priv;
  1233.  
  1234.     /* Null body since there is no framing error counter */
  1235.  
  1236.     return &lp->stats;
  1237. }
  1238.  
  1239. #ifdef HAVE_MULTICAST
  1240. /*
  1241. ** Set or clear the multicast filter for this adaptor.
  1242. ** num_addrs == -1    Promiscuous mode, receive all packets
  1243. ** num_addrs == 0    Normal mode, clear multicast list
  1244. ** num_addrs > 0    Multicast mode, receive normal and MC packets, and do
  1245. **             best-effort filtering.
  1246. */
  1247. #define hash_filter lp->init_block.filter
  1248.  
  1249. static void
  1250. set_multicast_list(struct device *dev, int num_addrs, void *addrs)
  1251. {
  1252.   short ioaddr = dev->base_addr;
  1253.   struct depca_private *lp = (struct depca_private *)dev->priv;
  1254.   
  1255.   if (irq2dev_map[dev->irq] != NULL) {
  1256.     STOP_DEPCA;                       /* Temporarily stop the depca.  */
  1257.     depca_init_ring(dev);             /* Initialize the descriptor rings */
  1258.  
  1259.     if (num_addrs >= 0) {
  1260.       SetMulticastFilter(num_addrs, (char *)addrs, (char *)hash_filter);
  1261.       lp->init_block.mode &= ~PROM;   /* Unset promiscuous mode */
  1262.     } else {
  1263.       lp->init_block.mode |= PROM;    /* Set promiscuous mode */
  1264.     }
  1265.  
  1266.     LoadCSRs(dev);                    /* Reload CSR3 */
  1267.     InitRestartDepca(dev);            /* Resume normal operation. */
  1268.   }
  1269. }
  1270.  
  1271. /*
  1272. ** Calculate the hash code and update the logical address filter
  1273. ** from a list of ethernet multicast addresses.
  1274. ** Derived from a 'C' program in the AMD data book:
  1275. ** "Am79C90 CMOS Local Area Network Controller for Ethernet (C-LANCE)", 
  1276. ** Pub #17781, Rev. A, May 1993
  1277. */
  1278. static void SetMulticastFilter(int num_addrs, char *addrs, char *multicast_table)
  1279. {
  1280.   char j, ctrl, bit, octet, hashcode;
  1281.   short int i;
  1282.   long int CRC, poly = (long int) CRC_POLYNOMIAL;
  1283.  
  1284.   for (i=0;i<num_addrs;i++) {                /* for each address in the list */
  1285.     if (((char) *(addrs+ETH_ALEN*i) & 0x01) == 1) {/* is multicast address? */ 
  1286.       CRC = (long int) 0xffffffff;           /* init CRC for each address */
  1287.       for (octet=0;octet<ETH_ALEN;octet++) { /* for each address octet */
  1288.     for(j=0;j<8;j++) {                   /* process each address bit */
  1289.       bit = (((char)* (addrs+ETH_ALEN*i+octet)) >> j) & 0x01;
  1290.       ctrl = ((CRC < 0) ? 1 : 0);        /* shift the control bit */
  1291.       CRC <<= 1;                         /* shift the CRC */
  1292.       if (bit ^ ctrl) {                  /* (bit) XOR (control bit) */
  1293.         CRC ^= poly;                     /* (CRC) XOR (polynomial) */
  1294.       }
  1295.     }
  1296.       }
  1297.       hashcode = (CRC & 0x00000001);         /* hashcode is 6 LSb of CRC ... */
  1298.       for (j=0;j<5;j++) {                    /* ... in reverse order. */
  1299.     hashcode <<= 1;
  1300.     CRC >>= 1;
  1301.     hashcode |= (CRC & 0x00000001);
  1302.       }                                      
  1303.       octet = hashcode >> 3;                  /* bit[3-5] -> octet in filter */
  1304.                                               /* bit[0-2] -> bit in octet */
  1305.       multicast_table[octet] |= (1 << (hashcode & 0x07));
  1306.     }
  1307.   }
  1308.   return;
  1309. }
  1310.  
  1311. #endif  /* HAVE_MULTICAST */
  1312.  
  1313. #ifndef MODULE
  1314. /*
  1315. ** ISA bus I/O device probe
  1316. */
  1317. static struct device *isa_probe(struct device *dev)
  1318. {
  1319.   int *port, ports[] = DEPCA_IO_PORTS;
  1320.   int status;
  1321.  
  1322.   for (status = -ENODEV, port = &ports[0]; 
  1323.                              *port && (num_depcas < MAX_NUM_DEPCAS); port++) {
  1324.     int ioaddr = *port;
  1325.  
  1326.     if (DevicePresent(ioaddr) == 0) {
  1327.       if (num_depcas > 0) {        /* only gets here in autoprobe */
  1328.     dev = alloc_device(dev, ioaddr);
  1329.       } else {
  1330.     if ((status = depca_probe1(dev, ioaddr)) == 0) {
  1331.       num_depcas++;
  1332.     }
  1333.       }
  1334.       num_eth++;
  1335.     }
  1336.   }
  1337.   return dev;
  1338. }
  1339.  
  1340. /*
  1341. ** EISA bus I/O device probe. Probe from slot 1 since slot 0 is usually
  1342. ** the motherboard.
  1343. */
  1344. static struct device *eisa_probe(struct device *dev)
  1345. {
  1346.   int i, ioaddr = DEPCA_EISA_IO_PORTS;
  1347.   int status;
  1348.  
  1349.   ioaddr+=0x1000;                         /* get the first slot address */
  1350.   for (status = -ENODEV, i=1; i<MAX_EISA_SLOTS; i++, ioaddr+=0x1000) {
  1351.  
  1352.     if (EISA_signature(DEPCA_EISA_ID) == 0) {
  1353.       if (num_depcas > 0) {        /* only gets here in autoprobe */
  1354.     dev = alloc_device(dev, ioaddr);
  1355.       } else {
  1356.     if ((status = depca_probe1(dev, ioaddr)) == 0) {
  1357.       num_depcas++;
  1358.     }
  1359.       }
  1360.       num_eth++;
  1361.     }
  1362.   }
  1363.   return dev;
  1364. }
  1365.  
  1366. /*
  1367. ** Allocate the device by pointing to the next available space in the
  1368. ** device structure. Should one not be available, it is created.
  1369. */
  1370. static struct device *alloc_device(struct device *dev, int ioaddr)
  1371. {
  1372.   /*
  1373.   ** Check the device structures for an end of list or unused device
  1374.   */
  1375.   while (dev->next != NULL) {
  1376.     if (dev->next->base_addr == 0xffe0) break;
  1377.     dev = dev->next;         /* walk through eth device list */
  1378.     num_eth++;               /* increment eth device number */
  1379.   }
  1380.  
  1381.   /*
  1382.   ** If no more device structures, malloc one up. If memory could
  1383.   ** not be allocated, print an error message.
  1384.   */
  1385.   if (dev->next == NULL) {
  1386.     dev->next = (struct device *)kmalloc(sizeof(struct device) + 8,
  1387.                      GFP_KERNEL);
  1388.     if (dev->next == NULL) {
  1389.       printk("eth%d: Device not initialised, insufficient memory\n",
  1390.          num_eth);
  1391.     }
  1392.   }
  1393.   
  1394.   /*
  1395.   ** If the memory was allocated, point to the new memory area
  1396.   ** and initialize it (name, I/O address, next device (NULL) and
  1397.   ** initialisation probe routine).
  1398.   */
  1399.   if ((dev->next != NULL) &&
  1400.       (num_eth > 0) && (num_eth < 9999)) {
  1401.     dev = dev->next;                    /* point to the new device */
  1402.     dev->name = (char *)(dev + 1);
  1403.     sprintf(dev->name,"eth%d", num_eth);/* New device name */
  1404.     dev->base_addr = ioaddr;            /* assign the io address */
  1405.     dev->next = NULL;                   /* mark the end of list */
  1406.     dev->init = &depca_probe;           /* initialisation routine */
  1407.     num_depcas++;
  1408.   }
  1409.  
  1410.   return dev;
  1411. }
  1412. #endif    /* MODULE */
  1413.  
  1414. /*
  1415. ** Look for a particular board name in the on-board Remote Diagnostics
  1416. ** and Boot (RDB) ROM. This will also give us a clue to the network RAM
  1417. ** base address.
  1418. */
  1419. static char *DepcaSignature(unsigned long mem_addr)
  1420. {
  1421.   unsigned long i,j,k;
  1422.   static char signatures[][DEPCA_NAME_LENGTH] = DEPCA_SIGNATURE;
  1423.   static char thisName[DEPCA_NAME_LENGTH];
  1424.   char tmpstr[17];
  1425.  
  1426.   for (i=0;i<16;i++) {                  /* copy the first 16 bytes of ROM to */
  1427.     tmpstr[i] = *(unsigned char *)(mem_addr+0xc000+i); /* a temporary string */
  1428.   }
  1429.   tmpstr[i]='\0';
  1430.  
  1431.   strcpy(thisName,"");
  1432.   for (i=0;*signatures[i]!='\0' && *thisName=='\0';i++) {
  1433.     for (j=0,k=0;j<16 && k<strlen(signatures[i]);j++) {
  1434.       if (signatures[i][k] == tmpstr[j]) {              /* track signature */
  1435.     k++;
  1436.       } else {                     /* lost signature; begin search again */
  1437.     k=0;
  1438.       }
  1439.     }
  1440.     if (k == strlen(signatures[i])) {
  1441.       strcpy(thisName,signatures[i]);
  1442.     }
  1443.   }
  1444.  
  1445.   return thisName;                    /* return the device name string */
  1446. }
  1447.  
  1448. /*
  1449. ** Look for a special sequence in the Ethernet station address PROM that
  1450. ** is common across all DEPCA products. Note that the original DEPCA needs
  1451. ** its ROM address counter to be initialized and enabled. Only enable
  1452. ** if the first address octet is a 0x08 - this minimises the chances of
  1453. ** messing around with some other hardware, but it assumes that this DEPCA
  1454. ** card initialized itself correctly.
  1455. ** 
  1456. ** Search the Ethernet address ROM for the signature. Since the ROM address
  1457. ** counter can start at an arbitrary point, the search must include the entire
  1458. ** probe sequence length plus the (length_of_the_signature - 1).
  1459. ** Stop the search IMMEDIATELY after the signature is found so that the
  1460. ** PROM address counter is correctly positioned at the start of the
  1461. ** ethernet address for later read out.
  1462. */
  1463. static int DevicePresent(short ioaddr)
  1464. {
  1465.   union {
  1466.     struct {
  1467.       u_long a;
  1468.       u_long b;
  1469.     } llsig;
  1470.     char Sig[sizeof(long) << 1];
  1471.   } dev;
  1472.   short sigLength=0;
  1473.   char data;
  1474.   int i, j, nicsr, status = 0;
  1475.  
  1476.   data = inb(DEPCA_PROM);                /* clear counter on DEPCA */
  1477.   data = inb(DEPCA_PROM);                /* read data */
  1478.  
  1479.   if (data == 0x08) {                    /* Enable counter on DEPCA */
  1480.     nicsr = inb(DEPCA_NICSR);
  1481.     nicsr |= AAC;
  1482.     outb(nicsr, DEPCA_NICSR);
  1483.   }
  1484.   
  1485.   dev.llsig.a = ETH_PROM_SIG;
  1486.   dev.llsig.b = ETH_PROM_SIG;
  1487.   sigLength = sizeof(long) << 1;
  1488.  
  1489.   for (i=0,j=0;j<sigLength && i<PROBE_LENGTH+sigLength-1;i++) {
  1490.     data = inb(DEPCA_PROM);
  1491.     if (dev.Sig[j] == data) {    /* track signature */
  1492.       j++;
  1493.     } else {                    /* lost signature; begin search again */
  1494.       if (data == dev.Sig[0]) {  /* rare case.... */
  1495.     j=1;
  1496.       } else {
  1497.     j=0;
  1498.       }
  1499.     }
  1500.   }
  1501.  
  1502.   if (j!=sigLength) {
  1503.     status = -ENODEV;           /* search failed */
  1504.   }
  1505.  
  1506.   return status;
  1507. }
  1508.  
  1509. /*
  1510. ** Look for a particular board name in the EISA configuration space
  1511. */
  1512. static int EISA_signature(short iobase)
  1513. {
  1514.   unsigned long i;
  1515.   int status;
  1516.   char *signatures[] = DEPCA_SIGNATURE;
  1517.   char ManCode[8];
  1518.   union {
  1519.     u_long ID;
  1520.     u_char Id[4];
  1521.   } Eisa;
  1522.  
  1523.   for (i=0; i<4; i++) {
  1524.     Eisa.Id[i] = inb(iobase + i);
  1525.   }
  1526.  
  1527.   ManCode[0]=(((Eisa.Id[0]>>2)&0x1f)+0x40);
  1528.   ManCode[1]=(((Eisa.Id[1]&0xe0)>>5)+((Eisa.Id[0]&0x03)<<3)+0x40);
  1529.   ManCode[2]=(((Eisa.Id[2]>>4)&0x0f)+0x30);
  1530.   ManCode[3]=((Eisa.Id[2]&0x0f)+0x30);
  1531.   ManCode[4]=(((Eisa.Id[3]>>4)&0x0f)+0x30);
  1532.   ManCode[5]='\0';
  1533.  
  1534.   for (status = -ENXIO, i=0;*signatures[i] != '\0' && status;i++) {
  1535.     if (strstr(ManCode, signatures[i]) != NULL) {
  1536.       status = 0;
  1537.     }
  1538.   }
  1539.   
  1540.   return status;                            /* return the device name string */
  1541. }
  1542.  
  1543. #ifdef MODULE
  1544. char kernel_version[] = UTS_RELEASE;
  1545. static struct device thisDepca = {
  1546.   "        ",  /* device name inserted by /linux/drivers/net/net_init.c */
  1547.   0, 0, 0, 0,
  1548.   0x200, 7,   /* I/O address, IRQ */
  1549.   0, 0, 0, NULL, depca_probe };
  1550.  
  1551. /*
  1552.  *    This is a tweak to keep the insmod program happy. It can only
  1553.  *    set int values with var=value so we split these out.
  1554.  */
  1555.  
  1556. int irq=7;    /* EDIT THESE LINE FOR YOUR CONFIGURATION */
  1557. int io=0x200;   /* Or use the irq= io= options to insmod */
  1558.     
  1559. int
  1560. init_module(void)
  1561. {
  1562.   thisDepca.irq=irq;
  1563.   thisDepca.base_addr=io;
  1564.   if (register_netdev(&thisDepca) != 0)
  1565.     return -EIO;
  1566.   return 0;
  1567. }
  1568.  
  1569. void
  1570. cleanup_module(void)
  1571. {
  1572.   if (MOD_IN_USE) {
  1573.     printk("%s: device busy, remove delayed\n",thisDepca.name);
  1574.   } else {
  1575.     release_region(thisDepca.base_addr, DEPCA_TOTAL_SIZE);
  1576.     unregister_netdev(&thisDepca);
  1577.   }
  1578. }
  1579. #endif /* MODULE */
  1580.  
  1581.  
  1582. /*
  1583.  * Local variables:
  1584.  *  kernel-compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O2 -m486 -c depca.c"
  1585.  *
  1586.  *  module-compile-command: "gcc -D__KERNEL__ -DMODULE -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O2 -m486 -c depca.c"
  1587.  * End:
  1588.  */
  1589.