depca.c

LINUX1.0内核源代码,学习LINUX编程的一定要看。

/*  depca.c: A DIGITAL DEPCA ethernet driver for linux.

    Written 1994 by David C. Davies.

    Copyright 1994 David C. Davies and United States Government as
    represented by the Director, National Security Agency.  This software
    may be used and distributed according to the terms of the GNU Public
    License, incorporated herein by reference.

    This driver is written for the Digital Equipment Corporation series
    of DEPCA ethernet cards:

    	DE100 DEPCA
	DE200 DEPCA Turbo
	DE202 DEPCA Turbo (TP BNC)
	DE210 DEPCA

    The driver has been tested on DE100 and DE20x cards in a relatively busy 
    network.

    The author may be reached as [e-mail] or
    Digital Equipment Corporation, 146 Main Street, Maynard MA 01754.

    =========================================================================
    The driver was based on the 'lance.c' driver from Donald Becker which is
    included with the standard driver distribution for linux. Modifications
    were made to most routines and the hardware recognition routines were
    written from scratch. Primary references used were:

    1) Lance.c code in /linux/drivers/net/
    2) "Ethernet/IEEE 802.3 Family. 1992 World Network Data Book/Handbook",
       AMD, 1992 [[phone]].
    3) "Am79C90 CMOS Local Area Network Controller for Ethernet (C-LANCE)",
       AMD, Pub. #17881, May 1993.
    4) "Am79C960 PCnet-ISA(tm), Single-Chip Ethernet Controller for ISA",
       AMD, Pub. #16907, May 1992
    5) "DEC EtherWORKS LC Ethernet Controller Owners Manual",
       Digital Equipment corporation, 1990, Pub. #EK-DE100-OM.003
    6) "DEC EtherWORKS Turbo Ethernet Controller Owners Manual",
       Digital Equipment corporation, 1990, Pub. #EK-DE200-OM.003
    7) "DEPCA Hardware Reference Manual", Pub. #EK-DEPCA-PR
       Digital Equipment Corporation, 1989
    8) "DEC EtherWORKS Turbo_(TP BNC) Ethernet Controller Owners Manual",
       Digital Equipment corporation, 1991, Pub. #EK-DE202-OM.001
    
    Peter Bauer's depca.c (V0.5) was referred to when debugging this driver.
    The hash filter code was  derived from Reference  3 and has been  tested
    only to the extent that the Table  A-1, page A-7,  was confirmed to fill
    the   filter bit   positions  correctly.  Hash   filtering  is  not  yet
    implemented in the current driver set.

    The  DE200 series boards have   on-board 64kB RAM  for  use as a  shared
    memory network buffer. Only  the DE100 cards  make  use of a  2kB buffer
    mode  which has not  been implemented in  this driver (only the 32kB and
    64kB modes are supported).

    At the  most only 2 DEPCA  cards can be supported  because there is only
    provision for two I/O base addresses on the cards (0x300 and 0x200). The
    base  address is  'autoprobed' by  looking  for  the self  test PROM and
    detecting the  card name.  The shared memory  base address is decoded by
    'autoprobing' the Ethernet PROM address information. The second DEPCA is
    detected and information placed  in the base_addr  variable of the  next
    device  structure   (which is created    if  necessary),  thus  enabling
    ethif_probe initialization for the device.

    ************************************************************************

    NOTE: If you are using two  DEPCAs, it is important  that you assign the
    base memory addresses  correctly.  The driver  autoprobes I/O 0x300 then
    0x200.  The base memory  address for the  first device must be less than
    that of the second so that the auto probe will  correctly assign the I/O
    and  memory addresses on  the same card.  I can't  think of  a way to do
    this unambiguously at the moment, since there is nothing on the cards to
    tie I/O and memory information together.

    I   am unable to test    2 DEPCAs together for   now,   so this code  is
    unchecked. All reports, good or bad, are welcome.

    ************************************************************************

    The board IRQ  setting must be  at  an unused  IRQ  which is auto-probed
    using   Donald Becker's   autoprobe   routines. DE100   board IRQs   are
    {2,3,4,5,7}, whereas  the DE200 is at  {5,9,10,11,15}. Note that IRQ2 is
    really IRQ9 in machines with 16 IRQ lines.

    No 16MB memory  limitation should exist with this  driver as DMA is  not
    used and the common memory area is in low memory on the network card (my
    current system has 20MB and I've not had problems yet).

    The DE203,  DE204  and DE205 cards  may  also work  with this driver  (I
    haven't tested  them so I don't  know). If you have  one of these cards,
    place the name in the DEPCA_SIGNATURE string  around line 160, recompile
    the kernel and reboot. Check if the card  is recognised and works - mail
    me if so, so that I can add it into the list of supported cards!

    TO DO:
    ------

    1. Implement the 2k buffer mode - does anyone need it??

    Revision History
    ----------------

    Version   Date        Description
  
      0.1   25-jan-94     Initial writing
      0.2   27-jan-94     Added LANCE TX buffer chaining
      0.3    1-feb-94     Added multiple DEPCA support
      0.31   4-feb-94     Added DE202 recognition
      0.32  19-feb-94     Tidy up. Improve multi-DEPCA support.

    =========================================================================
*/

static char *version = "depca.c:v0.32 2/19/94 [e-mail]\n";

#include <stdarg.h>
#include <linux/config.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/string.h>
#include <linux/ptrace.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/malloc.h>
#include <linux/interrupt.h>
#include <asm/bitops.h>
#include <asm/io.h>
#include <asm/dma.h>

#include "dev.h"
#include "iow.h"
#include "eth.h"
#include "skbuff.h"
#include "arp.h"
#include "depca.h"

#ifdef DEPCA_DEBUG
int depca_debug = DEPCA_DEBUG;
#else
int depca_debug = 1;
#endif

#ifndef DEPCA_IRQ
/*#define DEPCA_IRQ	{5,9,10,11,15,0}*/
#define DEPCA_IRQ	5
#endif

#ifndef PROBE_LENGTH
#define PROBE_LENGTH    32
#endif

#ifndef PROBE_SEQUENCE
#define PROBE_SEQUENCE "FF0055AAFF0055AA"
#endif

#ifndef DEPCA_SIGNATURE
#define DEPCA_SIGNATURE {"DEPCA","DE100","DE200","DE202","DE210",""}
#define DEPCA_NAME_LENGTH 8
#endif

#ifndef DEPCA_RAM_BASE_ADDRESSES
#define DEPCA_RAM_BASE_ADDRESSES {0xc0000,0xd0000,0xe0000,0x00000}
#endif
static short mem_chkd = 0;               /* holds which base addrs have been */
					 /* checked, for multi-DEPCA case */

#ifndef DEPCA_IO_PORTS
#define DEPCA_IO_PORTS {0x300, 0x200, 0}
#endif

#ifndef DEPCA_TOTAL_SIZE
#define DEPCA_TOTAL_SIZE 0x10
#endif

#ifndef MAX_NUM_DEPCAS
#define MAX_NUM_DEPCAS 2
#endif

/*
** Set the number of Tx and Rx buffers. 
*/
#ifndef DEPCA_BUFFER_LOG_SZ
#define RING_SIZE	16              /* 16 buffers */
#else
#define RING_SIZE	(1 << (DEPCA_BUFFERS_LOG_SZ))
#endif  /* DEPCA_BUFFER_LOG_SZ */

#define PKT_BUF_SZ	1544            /* Buffer size for each Tx/Rx buffer */
#define PKT_SZ   	1514            /* Maximum ethernet packet length */
#define DAT_SZ   	1500            /* Maximum ethernet data length */
#define PKT_HDR_LEN     14              /* Addresses and data length info */

#ifdef HAVE_MULTICAST
#ifndef CRC_POLYNOMIAL
#define CRC_POLYNOMIAL 0x04c11db7       /* Ethernet CRC polynomial */
#endif /* CRC_POLYNOMIAL */
#endif /* HAVE_MULTICAST */

#ifndef HAVE_ALLOC_SKB
#define alloc_skb(size, priority) (struct sk_buff *) kmalloc(size,priority)
#define kfree_skbmem(buff, size) kfree_s(buff,size)
#endif  /* HAVE_ALLOC_SKB */

/*
** The DEPCA Rx and Tx ring descriptors. 
*/
struct depca_rx_head {
    long base;
    short buf_length;		/* This length is negative 2's complement! */
    short msg_length;		/* This length is "normal". */
};

struct depca_tx_head {
    long base;
    short length;		/* This length is negative 2's complement! */
    short misc;                 /* Errors and TDR info */
};

struct depca_ring_info {
};

/*
** The Lance initialization block, described in databook, in common memory.
*/
struct depca_init {
    unsigned short mode;	/* Mode register */
    unsigned char phys_addr[ETH_ALEN];	/* Physical ethernet address */
    unsigned short filter[4];	/* Multicast filter. */
    unsigned long rx_ring;     	/* Rx ring base pointer & ring length */
    unsigned long tx_ring;	/* Tx ring base pointer & ring length */
};

struct depca_private {
    char devname[8];            /* Not used */
    struct depca_rx_head *rx_ring; /* Pointer to start of RX descriptor ring */
    struct depca_tx_head *tx_ring; /* Pointer to start of TX descriptor ring */
    struct depca_init	init_block;/* Initialization block */
    long dma_buffs;		/* Start address of Rx and Tx buffers. */
    int	cur_rx, cur_tx;		/* The next free ring entry */
    int dirty_rx, dirty_tx;	/* The ring entries to be free()ed. */
    int dma;
    struct enet_statistics stats;
    char old_depca;
    short ringSize;             /* ring size based on available memory */
    short rmask;                /* modulus mask based on ring size */
    long rlen;                  /* log2(ringSize) for the descriptors */
};

/*
** Public Functions
*/
static int depca_open(struct device *dev);
static int depca_start_xmit(struct sk_buff *skb, struct device *dev);
static void depca_interrupt(int reg_ptr);
static int depca_close(struct device *dev);
static struct enet_statistics *depca_get_stats(struct device *dev);
#ifdef HAVE_MULTICAST
static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
#endif

/*
** Private functions
*/
static int depca_probe1(struct device *dev, short ioaddr);
static void depca_init_ring(struct device *dev);
static int depca_rx(struct device *dev);
static int depca_tx(struct device *dev);

static void LoadCSRs(struct device *dev);
static int InitRestartDepca(struct device *dev);
static char *DepcaSignature(unsigned long mem_addr);
static int DevicePresent(short ioaddr);
#ifdef HAVE_MULTICAST
static void SetMulticastFilter(int num_addrs, char *addrs, char *multicast_table);
#endif

static int num_depcas = 0, num_eth = 0;;

/*
** Miscellaneous defines...
*/
#define STOP_DEPCA \
    outw(CSR0, DEPCA_ADDR);\
    outw(STOP, DEPCA_DATA)



int depca_probe(struct device *dev)
{
    int *port, ports[] = DEPCA_IO_PORTS;
    int base_addr = dev->base_addr;
    int status;
    struct device *eth0 = (struct device *) NULL;

    if (base_addr > 0x1ff) {	      /* Check a single specified location. */
		status = depca_probe1(dev, base_addr);
    } else if (base_addr > 0) {	      /* Don't probe at all. */
		status = -ENXIO;
    } else {                          /* First probe for the DEPCA test */
                                      /* pattern in ROM */

      for (status = -ENODEV, port = &ports[0]; 
	                    *port && (num_depcas < MAX_NUM_DEPCAS); port++) {
	int ioaddr = *port;

#ifdef HAVE_PORTRESERVE
	if (check_region(ioaddr, DEPCA_TOTAL_SIZE))
	    continue;
#endif
	if (DevicePresent(DEPCA_PROM) == 0) {
	  if (num_depcas > 0) {        /* only gets here in autoprobe */

	    /*
	    ** Check the device structures for an end of list or unused device
	    */
	    while (dev->next != (struct device *)NULL) {
	      if (dev->next->base_addr == 0xffe0) break;
	      dev = dev->next;         /* walk through eth device list */
	      num_eth++;               /* increment eth device number */
	    }

	    /*
	    ** If no more device structures, malloc one up. If memory could
	    ** not be allocated, print an error message.
	    ** 
	    */
	    if (dev->next == (struct device *)NULL) {
	      dev->next = (struct device *)kmalloc(sizeof(struct device) + 8,
                                                                  GFP_KERNEL);
	    } else {
	      printk("eth%d: Device not initialised, insufficient memory\n",
		                                                      num_eth);
	    }

	    /*
	    ** If the memory was allocated, point to the new memory area
	    ** and initialize it (name, I/O address, next device (NULL) and
	    ** initialisation probe routine).
	    */
	    if ((dev->next != (struct device *)NULL) &&
		(num_eth > 0) && (num_eth < 9999)) {
	      dev = dev->next;         /* point to the new device */
	      dev->name = (char *)(dev + sizeof(struct device));
	      sprintf(dev->name,"eth%d", num_eth); /* New device name */
	      dev->base_addr = ioaddr; /* assign the io address */
	      dev->next = (struct device *)NULL; /* mark the end of list */
	      dev->init = &depca_probe;/* initialisation routine */
	    }
	  } else {
	    eth0 = dev;                /* remember the first device */
	    status = depca_probe1(dev, ioaddr);
	  }
	  num_depcas++;
	  num_eth++;
	}
      }
      if (eth0) dev = eth0;             /* restore the first device */
    }

    if (status) dev->base_addr = base_addr;

    return status;			/* ENODEV would be more accurate. */
}

static int
depca_probe1(struct device *dev, short ioaddr)
{
    struct depca_private *lp;
    int i,j, status=0;
    unsigned long mem_start, mem_base[] = DEPCA_RAM_BASE_ADDRESSES;
    char *name=(char *)NULL;
    int nicsr, offset;


    /*
    ** Stop the DEPCA. Enable the DBR ROM. Disable interrupts and remote boot
    */
    STOP_DEPCA;

    nicsr = inw(DEPCA_NICSR);
    nicsr = ((nicsr & ~SHE & ~RBE & ~IEN) | IM);
    outw(nicsr, DEPCA_NICSR);

    if (inw(DEPCA_DATA) == STOP) {

    /* Now find out what kind of DEPCA we have. The DE100 uses a different
    ** addressing scheme for some registers compared to the DE2xx series.
    ** Note that a base address location is marked as checked if no DEPCA is
    ** there or one is found (when the search is immediately terminated). This
    ** shortens the search time a little for multiple DEPCAs.
    */

      for (j = 0, i = 0; mem_base[i] && (j == 0);) {
	if (((mem_chkd >> i) & 0x01) == 0) { /* has the memory been checked? */
	  name = DepcaSignature(mem_base[i]);/* check for a DEPCA here */
	  mem_chkd |= (0x01 << i);           /* mark location checked */
	  if (*name != (char)NULL) {         /* one found? */
	    j = 1;                           /* set exit flag */
	  } else {
	    i++;                             /* increment search index */
	  }
	}
      }

      if (*name != (char)NULL) {          /* found a DEPCA device */
	mem_start = mem_base[i];
	dev->base_addr = ioaddr;

	printk("%s: DEPCA at %#3x is a %s, ", dev->name, ioaddr, name);

      /* There is a 32 byte station address PROM at DEPCA_PROM address.
	 The first six bytes are the station address. They can be read
	 directly since the signature search set up the ROM address 
	 counter correctly just before this function.

	 For the DE100 we have to be careful about which port is used to
	 read the ROM info.
      */

	if (strstr(name,"DE100")!=(char *)NULL) {
	  j = 1;
	} else {
	  j = 0;
	}

	printk("ethernet address ");
	for (i = 0; i < ETH_ALEN - 1; i++) { /* get the ethernet address */
	  printk("%2.2x:", dev->dev_addr[i] = inb(DEPCA_PROM + j));
	}
	printk("%2.2x", dev->dev_addr[i] = inb(DEPCA_PROM + j));

	for (;i<32;i++) {                /* leave ROM counter in known state */
	  j=inb(DEPCA_PROM);
	}

#ifdef HAVE_PORTRESERVE
	snarf_region(ioaddr, DEPCA_TOTAL_SIZE);
#endif

	/* 
	 ** Determine the base address for the DEPCA RAM from the NI-CSR
	 ** and make up a DEPCA-specific-data structure. 
        */

	if (nicsr & BUF) {
	  offset = 0x8000;              /* 32kbyte RAM */
	  nicsr &= ~BS;                 /* DEPCA RAM in top 32k */
	  printk(",\n      with 32kB RAM");
	} else {
	  offset = 0x0000;              /* 64kbyte RAM */
	  printk(",\n      with 64kB RAM");
	}

	mem_start += offset;