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 / lance.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-20  |  33.2 KB  |  1,051 lines
  1. /* lance.c: An AMD LANCE ethernet driver for linux. */
  2. /*
  3.     Written 1993,1994,1995 by Donald Becker.
  4.  
  5.     Copyright 1993 United States Government as represented by the
  6.     Director, National Security Agency.
  7.     This software may be used and distributed according to the terms
  8.     of the GNU Public License, incorporated herein by reference.
  9.  
  10.     This driver is for the Allied Telesis AT1500 and HP J2405A, and should work
  11.     with most other LANCE-based bus-master (NE2100 clone) ethercards.
  12.  
  13.     The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O
  14.     Center of Excellence in Space Data and Information Sciences
  15.        Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
  16. */
  17.  
  18. static char *version = "lance.c:v1.07 1/18/95 becker@cesdis.gsfc.nasa.gov\n";
  19.  
  20. #include <linux/config.h>
  21. #include <linux/kernel.h>
  22. #include <linux/sched.h>
  23. #include <linux/string.h>
  24. #include <linux/ptrace.h>
  25. #include <linux/errno.h>
  26. #include <linux/ioport.h>
  27. #include <linux/malloc.h>
  28. #include <linux/interrupt.h>
  29. #include <linux/pci.h>
  30. #include <linux/bios32.h>
  31. #include <asm/bitops.h>
  32. #include <asm/io.h>
  33. #include <asm/dma.h>
  34.  
  35. #include <linux/netdevice.h>
  36. #include <linux/etherdevice.h>
  37. #include <linux/skbuff.h>
  38.  
  39. struct device *init_etherdev(struct device *dev, int sizeof_private,
  40.                              unsigned long *mem_startp);
  41. static unsigned int lance_portlist[] = {0x300, 0x320, 0x340, 0x360, 0};
  42. unsigned long lance_probe1(int ioaddr, unsigned long mem_start);
  43.  
  44. #ifdef HAVE_DEVLIST
  45. struct netdev_entry lance_drv =
  46. {"lance", lance_probe1, LANCE_TOTAL_SIZE, lance_portlist};
  47. #endif
  48.  
  49. #ifdef LANCE_DEBUG
  50. int lance_debug = LANCE_DEBUG;
  51. #else
  52. int lance_debug = 1;
  53. #endif
  54.  
  55. /*
  56.                 Theory of Operation
  57.  
  58. I. Board Compatibility
  59.  
  60. This device driver is designed for the AMD 79C960, the "PCnet-ISA
  61. single-chip ethernet controller for ISA".  This chip is used in a wide
  62. variety of boards from vendors such as Allied Telesis, HP, Kingston,
  63. and Boca.  This driver is also intended to work with older AMD 7990
  64. designs, such as the NE1500 and NE2100, and newer 79C961.  For convenience,
  65. I use the name LANCE to refer to all of the AMD chips, even though it properly
  66. refers only to the original 7990.
  67.  
  68. II. Board-specific settings
  69.  
  70. The driver is designed to work the boards that use the faster
  71. bus-master mode, rather than in shared memory mode.     (Only older designs
  72. have on-board buffer memory needed to support the slower shared memory mode.)
  73.  
  74. Most ISA boards have jumpered settings for the I/O base, IRQ line, and DMA
  75. channel.  This driver probes the likely base addresses:
  76. {0x300, 0x320, 0x340, 0x360}.
  77. After the board is found it generates a DMA-timeout interrupt and uses
  78. autoIRQ to find the IRQ line.  The DMA channel can be set with the low bits
  79. of the otherwise-unused dev->mem_start value (aka PARAM1).  If unset it is
  80. probed for by enabling each free DMA channel in turn and checking if
  81. initialization succeeds.
  82.  
  83. The HP-J2405A board is an exception: with this board it's easy to read the
  84. EEPROM-set values for the base, IRQ, and DMA.  (Of course you must already
  85. _know_ the base address -- that field is for writing the EEPROM.)
  86.  
  87. III. Driver operation
  88.  
  89. IIIa. Ring buffers
  90. The LANCE uses ring buffers of Tx and Rx descriptors.  Each entry describes
  91. the base and length of the data buffer, along with status bits.     The length
  92. of these buffers is set by LANCE_LOG_{RX,TX}_BUFFERS, which is log_2() of
  93. the buffer length (rather than being directly the buffer length) for
  94. implementation ease.  The current values are 2 (Tx) and 4 (Rx), which leads to
  95. ring sizes of 4 (Tx) and 16 (Rx).  Increasing the number of ring entries
  96. needlessly uses extra space and reduces the chance that an upper layer will
  97. be able to reorder queued Tx packets based on priority.     Decreasing the number
  98. of entries makes it more difficult to achieve back-to-back packet transmission
  99. and increases the chance that Rx ring will overflow.  (Consider the worst case
  100. of receiving back-to-back minimum-sized packets.)
  101.  
  102. The LANCE has the capability to "chain" both Rx and Tx buffers, but this driver
  103. statically allocates full-sized (slightly oversized -- PKT_BUF_SZ) buffers to
  104. avoid the administrative overhead. For the Rx side this avoids dynamically
  105. allocating full-sized buffers "just in case", at the expense of a
  106. memory-to-memory data copy for each packet received.  For most systems this
  107. is a good tradeoff: the Rx buffer will always be in low memory, the copy
  108. is inexpensive, and it primes the cache for later packet processing.  For Tx
  109. the buffers are only used when needed as low-memory bounce buffers.
  110.  
  111. IIIB. 16M memory limitations.
  112. For the ISA bus master mode all structures used directly by the LANCE,
  113. the initialization block, Rx and Tx rings, and data buffers, must be
  114. accessible from the ISA bus, i.e. in the lower 16M of real memory.
  115. This is a problem for current Linux kernels on >16M machines. The network
  116. devices are initialized after memory initialization, and the kernel doles out
  117. memory from the top of memory downward.     The current solution is to have a
  118. special network initialization routine that's called before memory
  119. initialization; this will eventually be generalized for all network devices.
  120. As mentioned before, low-memory "bounce-buffers" are used when needed.
  121.  
  122. IIIC. Synchronization
  123. The driver runs as two independent, single-threaded flows of control.  One
  124. is the send-packet routine, which enforces single-threaded use by the
  125. dev->tbusy flag.  The other thread is the interrupt handler, which is single
  126. threaded by the hardware and other software.
  127.  
  128. The send packet thread has partial control over the Tx ring and 'dev->tbusy'
  129. flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
  130. queue slot is empty, it clears the tbusy flag when finished otherwise it sets
  131. the 'lp->tx_full' flag.
  132.  
  133. The interrupt handler has exclusive control over the Rx ring and records stats
  134. from the Tx ring.  (The Tx-done interrupt can't be selectively turned off, so
  135. we can't avoid the interrupt overhead by having the Tx routine reap the Tx
  136. stats.)     After reaping the stats, it marks the queue entry as empty by setting
  137. the 'base' to zero.     Iff the 'lp->tx_full' flag is set, it clears both the
  138. tx_full and tbusy flags.
  139.  
  140. */
  141.  
  142. /* Set the number of Tx and Rx buffers, using Log_2(# buffers).
  143.    Reasonable default values are 4 Tx buffers, and 16 Rx buffers.
  144.    That translates to 2 (4 == 2^^2) and 4 (16 == 2^^4). */
  145. #ifndef LANCE_LOG_TX_BUFFERS
  146. #define LANCE_LOG_TX_BUFFERS 4
  147. #define LANCE_LOG_RX_BUFFERS 4
  148. #endif
  149.  
  150. #define TX_RING_SIZE            (1 << (LANCE_LOG_TX_BUFFERS))
  151. #define TX_RING_MOD_MASK        (TX_RING_SIZE - 1)
  152. #define TX_RING_LEN_BITS        ((LANCE_LOG_TX_BUFFERS) << 29)
  153.  
  154. #define RX_RING_SIZE            (1 << (LANCE_LOG_RX_BUFFERS))
  155. #define RX_RING_MOD_MASK        (RX_RING_SIZE - 1)
  156. #define RX_RING_LEN_BITS        ((LANCE_LOG_RX_BUFFERS) << 29)
  157.  
  158. #define PKT_BUF_SZ        1544
  159.  
  160. /* Offsets from base I/O address. */
  161. #define LANCE_DATA 0x10
  162. #define LANCE_ADDR 0x12
  163. #define LANCE_RESET 0x14
  164. #define LANCE_BUS_IF 0x16
  165. #define LANCE_TOTAL_SIZE 0x18
  166.  
  167. /* The LANCE Rx and Tx ring descriptors. */
  168. struct lance_rx_head {
  169.     int base;
  170.     short buf_length;            /* This length is 2s complement (negative)! */
  171.     short msg_length;            /* This length is "normal". */
  172. };
  173.  
  174. struct lance_tx_head {
  175.     int      base;
  176.     short length;                /* Length is 2s complement (negative)! */
  177.     short misc;
  178. };
  179.  
  180. /* The LANCE initialization block, described in databook. */
  181. struct lance_init_block {
  182.     unsigned short mode;        /* Pre-set mode (reg. 15) */
  183.     unsigned char phys_addr[6]; /* Physical ethernet address */
  184.     unsigned filter[2];            /* Multicast filter (unused). */
  185.     /* Receive and transmit ring base, along with extra bits. */
  186.     unsigned rx_ring;            /* Tx and Rx ring base pointers */
  187.     unsigned tx_ring;
  188. };
  189.  
  190. struct lance_private {
  191.     char *name;
  192.     void *pad;
  193.     /* The Tx and Rx ring entries must aligned on 8-byte boundaries. */
  194.     struct lance_rx_head rx_ring[RX_RING_SIZE];
  195.     struct lance_tx_head tx_ring[TX_RING_SIZE];
  196.     struct lance_init_block        init_block;
  197.     /* The saved address of a sent-in-place packet/buffer, for skfree(). */
  198.     struct sk_buff* tx_skbuff[TX_RING_SIZE];
  199.     long rx_buffs;                /* Address of Rx and Tx buffers. */
  200.     /* Tx low-memory "bounce buffer" address. */
  201.     char (*tx_bounce_buffs)[PKT_BUF_SZ];
  202.     int cur_rx, cur_tx;            /* The next free ring entry */
  203.     int dirty_rx, dirty_tx;        /* The ring entries to be free()ed. */
  204.     int dma;
  205.     struct enet_statistics stats;
  206.     char chip_version;            /* See lance_chip_type. */
  207.     char tx_full;
  208.     char lock;
  209.     int pad0, pad1;                /* Used for 8-byte alignment */
  210. };
  211.  
  212. /* A mapping from the chip ID number to the part number and features.
  213.    These are from the datasheets -- in real life the '970 version
  214.    reportedly has the same ID as the '965. */
  215. static struct lance_chip_type {
  216.     int id_number;
  217.     char *name;
  218.     int flags;
  219. } chip_table[] = {
  220.     {0x0000, "LANCE 7990", 0},            /* Ancient lance chip.  */
  221.     {0x0003, "PCnet/ISA 79C960", 0},    /* 79C960 PCnet/ISA.  */
  222.     {0x2260, "PCnet/ISA+ 79C961", 0},    /* 79C961 PCnet/ISA+, Plug-n-Play.  */
  223.     {0x2420, "PCnet/PCI 79C970", 0},    /* 79C970 or 79C974 PCnet-SCSI, PCI. */
  224.     /* Bug: the PCnet/PCI actually uses the PCnet/VLB ID number, so just call
  225.         it the PCnet32. */
  226.     {0x2430, "PCnet32", 0},                /* 79C965 PCnet for VL bus. */
  227.     {0x0,      "PCnet (unknown)", 0},
  228. };
  229.  
  230. enum {OLD_LANCE = 0, PCNET_ISA=1, PCNET_ISAP=2, PCNET_PCI=3, PCNET_VLB=4, LANCE_UNKNOWN=5};
  231.  
  232. /* Non-zero only if the current card is a PCI with BIOS-set IRQ. */
  233. static unsigned char pci_irq_line = 0;
  234.  
  235. static int lance_open(struct device *dev);
  236. static void lance_init_ring(struct device *dev);
  237. static int lance_start_xmit(struct sk_buff *skb, struct device *dev);
  238. static int lance_rx(struct device *dev);
  239. static void lance_interrupt(int irq, struct pt_regs *regs);
  240. static int lance_close(struct device *dev);
  241. static struct enet_statistics *lance_get_stats(struct device *dev);
  242. #ifdef HAVE_MULTICAST
  243. static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
  244. #endif
  245.  
  246.  
  247.  
  248. /* This lance probe is unlike the other board probes in 1.0.*.  The LANCE may
  249.    have to allocate a contiguous low-memory region for bounce buffers.
  250.    This requirement is satisfied by having the lance initialization occur
  251.    before the memory management system is started, and thus well before the
  252.    other probes. */
  253.  
  254. unsigned long lance_init(unsigned long mem_start, unsigned long mem_end)
  255. {
  256.     int *port;
  257.  
  258. #if defined(CONFIG_PCI)
  259. #define AMD_VENDOR_ID 0x1022
  260. #define AMD_DEVICE_ID 0x2000
  261.     if (pcibios_present()) {
  262.         int pci_index;
  263.         printk("lance.c: PCI bios is present, checking for devices...\n");
  264.         for (pci_index = 0; pci_index < 8; pci_index++) {
  265.             unsigned char pci_bus, pci_device_fn;
  266.             unsigned long pci_ioaddr;
  267.             unsigned short pci_command;
  268.  
  269.             if (pcibios_find_device (AMD_VENDOR_ID, AMD_DEVICE_ID, pci_index,
  270.                                      &pci_bus, &pci_device_fn) != 0)
  271.                 break;
  272.             pcibios_read_config_byte(pci_bus, pci_device_fn,
  273.                                      PCI_INTERRUPT_LINE, &pci_irq_line);
  274.             pcibios_read_config_dword(pci_bus, pci_device_fn,
  275.                                       PCI_BASE_ADDRESS_0, &pci_ioaddr);
  276.             /* Remove I/O space marker in bit 0. */
  277.             pci_ioaddr &= ~3;
  278.             /* PCI Spec 2.1 states that it is either the driver or PCI card's
  279.               * responsibility to set the PCI Master Enable Bit if needed.
  280.              *    (From Mark Stockton <marks@schooner.sys.hou.compaq.com>)
  281.              */
  282.             pcibios_read_config_word(pci_bus, pci_device_fn,
  283.                                      PCI_COMMAND, &pci_command);
  284.             if ( ! (pci_command & PCI_COMMAND_MASTER)) {
  285.                 printk("PCI Master Bit has not been set. Setting...\n");
  286.                 pci_command |= PCI_COMMAND_MASTER;
  287.                 pcibios_write_config_word(pci_bus, pci_device_fn,
  288.                                           PCI_COMMAND, pci_command);
  289.             }
  290.             printk("Found PCnet/PCI at %#lx, irq %d (mem_start is %#lx).\n",
  291.                    pci_ioaddr, pci_irq_line, mem_start);
  292.             mem_start = lance_probe1(pci_ioaddr, mem_start);
  293.             pci_irq_line = 0;
  294.         }
  295.     }
  296. #endif  /* defined(CONFIG_PCI) */
  297.  
  298.     for (port = lance_portlist; *port; port++) {
  299.         int ioaddr = *port;
  300.  
  301.         if (   check_region(ioaddr, LANCE_TOTAL_SIZE) == 0
  302.             && inb(ioaddr + 14) == 0x57
  303.             && inb(ioaddr + 15) == 0x57) {
  304.             mem_start = lance_probe1(ioaddr, mem_start);
  305.         }
  306.     }
  307.  
  308.     return mem_start;
  309. }
  310.  
  311. unsigned long lance_probe1(int ioaddr, unsigned long mem_start)
  312. {
  313.     struct device *dev;
  314.     struct lance_private *lp;
  315.     short dma_channels;                    /* Mark spuriously-busy DMA channels */
  316.     int i, reset_val, lance_version;
  317.     char *chipname;
  318.     /* Flags for specific chips or boards. */
  319.     unsigned char hpJ2405A = 0;                        /* HP ISA adaptor */
  320.     int hp_builtin = 0;                    /* HP on-board ethernet. */
  321.     static int did_version = 0;            /* Already printed version info. */
  322.  
  323.     /* First we look for special cases.
  324.        Check for HP's on-board ethernet by looking for 'HP' in the BIOS.
  325.        There are two HP versions, check the BIOS for the configuration port.
  326.        This method provided by L. Julliard, Laurent_Julliard@grenoble.hp.com.
  327.        */
  328.     if ( *((unsigned short *) 0x000f0102) == 0x5048)  {
  329.         short ioaddr_table[] = { 0x300, 0x320, 0x340, 0x360};
  330.         int hp_port = ( *((unsigned char *) 0x000f00f1) & 1)  ? 0x499 : 0x99;
  331.         /* We can have boards other than the built-in!  Verify this is on-board. */
  332.         if ((inb(hp_port) & 0xc0) == 0x80
  333.             && ioaddr_table[inb(hp_port) & 3] == ioaddr)
  334.             hp_builtin = hp_port;
  335.     }
  336.     /* We also recognize the HP Vectra on-board here, but check below. */
  337.     hpJ2405A = (inb(ioaddr) == 0x08 && inb(ioaddr+1) == 0x00
  338.                 && inb(ioaddr+2) == 0x09);
  339.  
  340.     /* Reset the LANCE.     */
  341.     reset_val = inw(ioaddr+LANCE_RESET); /* Reset the LANCE */
  342.  
  343.     /* The Un-Reset needed is only needed for the real NE2100, and will
  344.        confuse the HP board. */
  345.     if (!hpJ2405A)
  346.         outw(reset_val, ioaddr+LANCE_RESET);
  347.  
  348.     outw(0x0000, ioaddr+LANCE_ADDR); /* Switch to window 0 */
  349.     if (inw(ioaddr+LANCE_DATA) != 0x0004)
  350.         return mem_start;
  351.  
  352.     /* Get the version of the chip. */
  353.     outw(88, ioaddr+LANCE_ADDR);
  354.     if (inw(ioaddr+LANCE_ADDR) != 88) {
  355.         lance_version = 0;
  356.     } else {                            /* Good, it's a newer chip. */
  357.         int chip_version = inw(ioaddr+LANCE_DATA);
  358.         outw(89, ioaddr+LANCE_ADDR);
  359.         chip_version |= inw(ioaddr+LANCE_DATA) << 16;
  360.         if (lance_debug > 2)
  361.             printk("  LANCE chip version is %#x.\n", chip_version);
  362.         if ((chip_version & 0xfff) != 0x003)
  363.             return mem_start;
  364.         chip_version = (chip_version >> 12) & 0xffff;
  365.         for (lance_version = 1; chip_table[lance_version].id_number; lance_version++) {
  366.             if (chip_table[lance_version].id_number == chip_version)
  367.                 break;
  368.         }
  369.     }
  370.  
  371.     dev = init_etherdev(0, sizeof(struct lance_private)
  372.                         + PKT_BUF_SZ*(RX_RING_SIZE + TX_RING_SIZE),
  373.                         &mem_start);
  374.  
  375.     chipname = chip_table[lance_version].name;
  376.     printk("%s: %s at %#3x,", dev->name, chipname, ioaddr);
  377.  
  378.     /* There is a 16 byte station address PROM at the base address.
  379.        The first six bytes are the station address. */
  380.     for (i = 0; i < 6; i++)
  381.         printk(" %2.2x", dev->dev_addr[i] = inb(ioaddr + i));
  382.  
  383.     dev->base_addr = ioaddr;
  384.     request_region(ioaddr, LANCE_TOTAL_SIZE, chip_table[lance_version].name);
  385.  
  386.     /* Make certain the data structures used by the LANCE are aligned. */
  387.     dev->priv = (void *)(((int)dev->priv + 7) & ~7);
  388.     lp = (struct lance_private *)dev->priv;
  389.     lp->name = chipname;
  390.     lp->rx_buffs = (long)dev->priv + sizeof(struct lance_private);
  391.     lp->tx_bounce_buffs = (char (*)[PKT_BUF_SZ])
  392.                            (lp->rx_buffs + PKT_BUF_SZ*RX_RING_SIZE);
  393.  
  394. #ifndef final_version
  395.     /* This should never happen. */
  396.     if ((int)(lp->rx_ring) & 0x07) {
  397.         printk(" **ERROR** LANCE Rx and Tx rings not on even boundary.\n");
  398.         return mem_start;
  399.     }
  400. #endif
  401.  
  402.     lp->chip_version = lance_version;
  403.  
  404.     lp->init_block.mode = 0x0003;        /* Disable Rx and Tx. */
  405.     for (i = 0; i < 6; i++)
  406.         lp->init_block.phys_addr[i] = dev->dev_addr[i];
  407.     lp->init_block.filter[0] = 0x00000000;
  408.     lp->init_block.filter[1] = 0x00000000;
  409.     lp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
  410.     lp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
  411.  
  412.     outw(0x0001, ioaddr+LANCE_ADDR);
  413.     inw(ioaddr+LANCE_ADDR);
  414.     outw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
  415.     outw(0x0002, ioaddr+LANCE_ADDR);
  416.     inw(ioaddr+LANCE_ADDR);
  417.     outw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
  418.     outw(0x0000, ioaddr+LANCE_ADDR);
  419.     inw(ioaddr+LANCE_ADDR);
  420.  
  421.     if (pci_irq_line) {
  422.         dev->dma = 4;            /* Native bus-master, no DMA channel needed. */
  423.         dev->irq = pci_irq_line;
  424.     } else if (hp_builtin) {
  425.         char dma_tbl[4] = {3, 5, 6, 0};
  426.         char irq_tbl[8] = {3, 4, 5, 9};
  427.         unsigned char port_val = inb(hp_builtin);
  428.         dev->dma = dma_tbl[(port_val >> 4) & 3];
  429.         dev->irq = irq_tbl[(port_val >> 2) & 3];
  430.         printk(" HP Vectra IRQ %d DMA %d.\n", dev->irq, dev->dma);
  431.     } else if (hpJ2405A) {
  432.         char dma_tbl[4] = {3, 5, 6, 7};
  433.         char irq_tbl[8] = {3, 4, 5, 9, 10, 11, 12, 15};
  434.         short reset_val = inw(ioaddr+LANCE_RESET);
  435.         dev->dma = dma_tbl[(reset_val >> 2) & 3];
  436.         dev->irq = irq_tbl[(reset_val >> 4) & 7];
  437.         printk(" HP J2405A IRQ %d DMA %d.\n", dev->irq, dev->dma);
  438.     } else if (lance_version == PCNET_ISAP) {        /* The plug-n-play version. */
  439.         short bus_info;
  440.         outw(8, ioaddr+LANCE_ADDR);
  441.         bus_info = inw(ioaddr+LANCE_BUS_IF);
  442.         dev->dma = bus_info & 0x07;
  443.         dev->irq = (bus_info >> 4) & 0x0F;
  444.     } else {
  445.         /* The DMA channel may be passed in PARAM1. */
  446.         if (dev->mem_start & 0x07)
  447.             dev->dma = dev->mem_start & 0x07;
  448.     }
  449.  
  450.     if (dev->dma == 0) {
  451.         /* Read the DMA channel status register, so that we can avoid
  452.            stuck DMA channels in the DMA detection below. */
  453.         dma_channels = ((inb(DMA1_STAT_REG) >> 4) & 0x0f) |
  454.             (inb(DMA2_STAT_REG) & 0xf0);
  455.     }
  456.     if (dev->irq >= 2)
  457.         printk(" assigned IRQ %d", dev->irq);
  458.     else {
  459.         /* To auto-IRQ we enable the initialization-done and DMA error
  460.            interrupts. For ISA boards we get a DMA error, but VLB and PCI
  461.            boards will work. */
  462.         autoirq_setup(0);
  463.  
  464.         /* Trigger an initialization just for the interrupt. */
  465.         outw(0x0041, ioaddr+LANCE_DATA);
  466.  
  467.         dev->irq = autoirq_report(1);
  468.         if (dev->irq)
  469.             printk(", probed IRQ %d", dev->irq);
  470.         else {
  471.             printk(", failed to detect IRQ line.\n");
  472.             return mem_start;
  473.         }
  474.  
  475.         /* Check for the initialization done bit, 0x0100, which means
  476.            that we don't need a DMA channel. */
  477.         if (inw(ioaddr+LANCE_DATA) & 0x0100)
  478.             dev->dma = 4;
  479.     }
  480.  
  481.     if (dev->dma == 4) {
  482.         printk(", no DMA needed.\n");
  483.     } else if (dev->dma) {
  484.         if (request_dma(dev->dma, chipname)) {
  485.             printk("DMA %d allocation failed.\n", dev->dma);
  486.             return mem_start;
  487.         } else
  488.             printk(", assigned DMA %d.\n", dev->dma);
  489.     } else {            /* OK, we have to auto-DMA. */
  490.         int dmas[] = { 5, 6, 7, 3 }, boguscnt;
  491.  
  492.         for (i = 0; i < 4; i++) {
  493.             int dma = dmas[i];
  494.  
  495.             /* Don't enable a permanently busy DMA channel, or the machine
  496.                will hang. */
  497.             if (test_bit(dma, &dma_channels))
  498.                 continue;
  499.             outw(0x7f04, ioaddr+LANCE_DATA); /* Clear the memory error bits. */
  500.             if (request_dma(dma, chipname))
  501.                 continue;
  502.             set_dma_mode(dma, DMA_MODE_CASCADE);
  503.             enable_dma(dma);
  504.  
  505.             /* Trigger an initialization. */
  506.             outw(0x0001, ioaddr+LANCE_DATA);
  507.             for (boguscnt = 100; boguscnt > 0; --boguscnt)
  508.                 if (inw(ioaddr+LANCE_DATA) & 0x0900)
  509.                     break;
  510.             if (inw(ioaddr+LANCE_DATA) & 0x0100) {
  511.                 dev->dma = dma;
  512.                 printk(", DMA %d.\n", dev->dma);
  513.                 break;
  514.             } else {
  515.                 disable_dma(dma);
  516.                 free_dma(dma);
  517.             }
  518.         }
  519.         if (i == 4) {            /* Failure: bail. */
  520.             printk("DMA detection failed.\n");
  521.             return mem_start;
  522.         }
  523.     }
  524.  
  525.     if (lp->chip_version !=  OLD_LANCE) {
  526.         /* Turn on auto-select of media (10baseT or BNC) so that the user
  527.            can watch the LEDs even if the board isn't opened. */
  528.         outw(0x0002, ioaddr+LANCE_ADDR);
  529.         outw(0x0002, ioaddr+LANCE_BUS_IF);
  530.     }
  531.  
  532.     if (lance_debug > 0  &&  did_version++ == 0)
  533.         printk(version);
  534.  
  535.     /* The LANCE-specific entries in the device structure. */
  536.     dev->open = &lance_open;
  537.     dev->hard_start_xmit = &lance_start_xmit;
  538.     dev->stop = &lance_close;
  539.     dev->get_stats = &lance_get_stats;
  540.     dev->set_multicast_list = &set_multicast_list;
  541.  
  542.     return mem_start;
  543. }
  544.  
  545.  
  546. static int
  547. lance_open(struct device *dev)
  548. {
  549.     struct lance_private *lp = (struct lance_private *)dev->priv;
  550.     int ioaddr = dev->base_addr;
  551.     int i;
  552.  
  553.     if (dev->irq == 0 ||
  554.         request_irq(dev->irq, &lance_interrupt, 0, lp->name)) {
  555.         return -EAGAIN;
  556.     }
  557.  
  558.     /* We used to allocate DMA here, but that was silly.
  559.        DMA lines can't be shared!  We now permanently snarf them. */
  560.  
  561.     irq2dev_map[dev->irq] = dev;
  562.  
  563.     /* Reset the LANCE */
  564.     inw(ioaddr+LANCE_RESET);
  565.  
  566.     /* The DMA controller is used as a no-operation slave, "cascade mode". */
  567.     if (dev->dma != 4) {
  568.         enable_dma(dev->dma);
  569.         set_dma_mode(dev->dma, DMA_MODE_CASCADE);
  570.     }
  571.  
  572.     /* Un-Reset the LANCE, needed only for the NE2100. */
  573.     if (lp->chip_version == OLD_LANCE)
  574.         outw(0, ioaddr+LANCE_RESET);
  575.  
  576.     if (lp->chip_version != OLD_LANCE) {
  577.         /* This is 79C960-specific: Turn on auto-select of media (AUI, BNC). */
  578.         outw(0x0002, ioaddr+LANCE_ADDR);
  579.         outw(0x0002, ioaddr+LANCE_BUS_IF);
  580.     }
  581.  
  582.     if (lance_debug > 1)
  583.         printk("%s: lance_open() irq %d dma %d tx/rx rings %#x/%#x init %#x.\n",
  584.                dev->name, dev->irq, dev->dma, (int) lp->tx_ring, (int) lp->rx_ring,
  585.                (int) &lp->init_block);
  586.  
  587.     lance_init_ring(dev);
  588.     /* Re-initialize the LANCE, and start it when done. */
  589.     outw(0x0001, ioaddr+LANCE_ADDR);
  590.     outw((short) (int) &lp->init_block, ioaddr+LANCE_DATA);
  591.     outw(0x0002, ioaddr+LANCE_ADDR);
  592.     outw(((int)&lp->init_block) >> 16, ioaddr+LANCE_DATA);
  593.  
  594.     outw(0x0004, ioaddr+LANCE_ADDR);
  595.     outw(0x0d15, ioaddr+LANCE_DATA);
  596.  
  597.     outw(0x0000, ioaddr+LANCE_ADDR);
  598.     outw(0x0001, ioaddr+LANCE_DATA);
  599.  
  600.     dev->tbusy = 0;
  601.     dev->interrupt = 0;
  602.     dev->start = 1;
  603.     i = 0;
  604.     while (i++ < 100)
  605.         if (inw(ioaddr+LANCE_DATA) & 0x0100)
  606.             break;
  607.     /* 
  608.      * We used to clear the InitDone bit, 0x0100, here but Mark Stockton
  609.      * reports that doing so triggers a bug in the '974.
  610.      */
  611.      outw(0x0042, ioaddr+LANCE_DATA);
  612.  
  613.     if (lance_debug > 2)
  614.         printk("%s: LANCE open after %d ticks, init block %#x csr0 %4.4x.\n",
  615.                dev->name, i, (int) &lp->init_block, inw(ioaddr+LANCE_DATA));
  616.  
  617.     return 0;                    /* Always succeed */
  618. }
  619.  
  620. /* Initialize the LANCE Rx and Tx rings. */
  621. static void
  622. lance_init_ring(struct device *dev)
  623. {
  624.     struct lance_private *lp = (struct lance_private *)dev->priv;
  625.     int i;
  626.  
  627.     lp->lock = 0, lp->tx_full = 0;
  628.     lp->cur_rx = lp->cur_tx = 0;
  629.     lp->dirty_rx = lp->dirty_tx = 0;
  630.  
  631.     for (i = 0; i < RX_RING_SIZE; i++) {
  632.         lp->rx_ring[i].base = (lp->rx_buffs + i*PKT_BUF_SZ) | 0x80000000;
  633.         lp->rx_ring[i].buf_length = -PKT_BUF_SZ;
  634.     }
  635.     /* The Tx buffer address is filled in as needed, but we do need to clear
  636.        the upper ownership bit. */
  637.     for (i = 0; i < TX_RING_SIZE; i++) {
  638.         lp->tx_ring[i].base = 0;
  639.     }
  640.  
  641.     lp->init_block.mode = 0x0000;
  642.     for (i = 0; i < 6; i++)
  643.         lp->init_block.phys_addr[i] = dev->dev_addr[i];
  644.     lp->init_block.filter[0] = 0x00000000;
  645.     lp->init_block.filter[1] = 0x00000000;
  646.     lp->init_block.rx_ring = (int)lp->rx_ring | RX_RING_LEN_BITS;
  647.     lp->init_block.tx_ring = (int)lp->tx_ring | TX_RING_LEN_BITS;
  648. }
  649.  
  650. static int
  651. lance_start_xmit(struct sk_buff *skb, struct device *dev)
  652. {
  653.     struct lance_private *lp = (struct lance_private *)dev->priv;
  654.     int ioaddr = dev->base_addr;
  655.     int entry;
  656.  
  657.     /* Transmitter timeout, serious problems. */
  658.     if (dev->tbusy) {
  659.         int tickssofar = jiffies - dev->trans_start;
  660.         if (tickssofar < 20)
  661.             return 1;
  662.         outw(0, ioaddr+LANCE_ADDR);
  663.         printk("%s: transmit timed out, status %4.4x, resetting.\n",
  664.                dev->name, inw(ioaddr+LANCE_DATA));
  665.         outw(0x0004, ioaddr+LANCE_DATA);
  666.         lp->stats.tx_errors++;
  667. #ifndef final_version
  668.         {
  669.             int i;
  670.             printk(" Ring data dump: dirty_tx %d cur_tx %d%s cur_rx %d.",
  671.                    lp->dirty_tx, lp->cur_tx, lp->tx_full ? " (full)" : "",
  672.                    lp->cur_rx);
  673.             for (i = 0 ; i < RX_RING_SIZE; i++)
  674.                 printk("%s %08x %04x %04x", i & 0x3 ? "" : "\n ",
  675.                        lp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
  676.                        lp->rx_ring[i].msg_length);
  677.             for (i = 0 ; i < TX_RING_SIZE; i++)
  678.                 printk("%s %08x %04x %04x", i & 0x3 ? "" : "\n ",
  679.                        lp->tx_ring[i].base, -lp->tx_ring[i].length,
  680.                        lp->tx_ring[i].misc);
  681.             printk("\n");
  682.         }
  683. #endif
  684.         lance_init_ring(dev);
  685.         outw(0x0043, ioaddr+LANCE_DATA);
  686.  
  687.         dev->tbusy=0;
  688.         dev->trans_start = jiffies;
  689.  
  690.         return 0;
  691.     }
  692.  
  693.     if (skb == NULL) {
  694.         dev_tint(dev);
  695.         return 0;
  696.     }
  697.  
  698.     if (skb->len <= 0)
  699.         return 0;
  700.  
  701.     if (lance_debug > 3) {
  702.         outw(0x0000, ioaddr+LANCE_ADDR);
  703.         printk("%s: lance_start_xmit() called, csr0 %4.4x.\n", dev->name,
  704.                inw(ioaddr+LANCE_DATA));
  705.         outw(0x0000, ioaddr+LANCE_DATA);
  706.     }
  707.  
  708.     /* Block a timer-based transmit from overlapping.  This could better be
  709.        done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
  710.     if (set_bit(0, (void*)&dev->tbusy) != 0) {
  711.         printk("%s: Transmitter access conflict.\n", dev->name);
  712.         return 1;
  713.     }
  714.  
  715.     if (set_bit(0, (void*)&lp->lock) != 0) {
  716.         if (lance_debug > 0)
  717.             printk("%s: tx queue lock!.\n", dev->name);
  718.         /* don't clear dev->tbusy flag. */
  719.         return 1;
  720.     }
  721.  
  722.     /* Fill in a Tx ring entry */
  723.  
  724.     /* Mask to ring buffer boundary. */
  725.     entry = lp->cur_tx & TX_RING_MOD_MASK;
  726.  
  727.     /* Caution: the write order is important here, set the base address
  728.        with the "ownership" bits last. */
  729.  
  730.     /* The old LANCE chips doesn't automatically pad buffers to min. size. */
  731.     if (lp->chip_version == OLD_LANCE) {
  732.         lp->tx_ring[entry].length =
  733.             -(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
  734.     } else
  735.         lp->tx_ring[entry].length = -skb->len;
  736.  
  737.     lp->tx_ring[entry].misc = 0x0000;
  738.  
  739.     /* If any part of this buffer is >16M we must copy it to a low-memory
  740.        buffer. */
  741.     if ((int)(skb->data) + skb->len > 0x01000000) {
  742.         if (lance_debug > 5)
  743.             printk("%s: bouncing a high-memory packet (%#x).\n",
  744.                    dev->name, (int)(skb->data));
  745.         memcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
  746.         lp->tx_ring[entry].base =
  747.             (int)(lp->tx_bounce_buffs + entry) | 0x83000000;
  748.         dev_kfree_skb (skb, FREE_WRITE);
  749.     } else {
  750.         lp->tx_skbuff[entry] = skb;
  751.         lp->tx_ring[entry].base = (int)(skb->data) | 0x83000000;
  752.     }
  753.     lp->cur_tx++;
  754.  
  755.     /* Trigger an immediate send poll. */
  756.     outw(0x0000, ioaddr+LANCE_ADDR);
  757.     outw(0x0048, ioaddr+LANCE_DATA);
  758.  
  759.     dev->trans_start = jiffies;
  760.  
  761.     cli();
  762.     lp->lock = 0;
  763.     if (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
  764.         dev->tbusy=0;
  765.     else
  766.         lp->tx_full = 1;
  767.     sti();
  768.  
  769.     return 0;
  770. }
  771.  
  772. /* The LANCE interrupt handler. */
  773. static void
  774. lance_interrupt(int irq, struct pt_regs * regs)
  775. {
  776.     struct device *dev = (struct device *)(irq2dev_map[irq]);
  777.     struct lance_private *lp;
  778.     int csr0, ioaddr, boguscnt=10;
  779.  
  780.     if (dev == NULL) {
  781.         printk ("lance_interrupt(): irq %d for unknown device.\n", irq);
  782.         return;
  783.     }
  784.  
  785.     ioaddr = dev->base_addr;
  786.     lp = (struct lance_private *)dev->priv;
  787.     if (dev->interrupt)
  788.         printk("%s: Re-entering the interrupt handler.\n", dev->name);
  789.  
  790.     dev->interrupt = 1;
  791.  
  792.     outw(0x00, dev->base_addr + LANCE_ADDR);
  793.     while ((csr0 = inw(dev->base_addr + LANCE_DATA)) & 0x8600
  794.            && --boguscnt >= 0) {
  795.         /* Acknowledge all of the current interrupt sources ASAP. */
  796.         outw(csr0 & ~0x004f, dev->base_addr + LANCE_DATA);
  797.  
  798.         if (lance_debug > 5)
  799.             printk("%s: interrupt  csr0=%#2.2x new csr=%#2.2x.\n",
  800.                    dev->name, csr0, inw(dev->base_addr + LANCE_DATA));
  801.  
  802.         if (csr0 & 0x0400)            /* Rx interrupt */
  803.             lance_rx(dev);
  804.  
  805.         if (csr0 & 0x0200) {        /* Tx-done interrupt */
  806.             int dirty_tx = lp->dirty_tx;
  807.  
  808.             while (dirty_tx < lp->cur_tx) {
  809.                 int entry = dirty_tx & TX_RING_MOD_MASK;
  810.                 int status = lp->tx_ring[entry].base;
  811.             
  812.                 if (status < 0)
  813.                     break;            /* It still hasn't been Txed */
  814.  
  815.                 lp->tx_ring[entry].base = 0;
  816.  
  817.                 if (status & 0x40000000) {
  818.                     /* There was an major error, log it. */
  819.                     int err_status = lp->tx_ring[entry].misc;
  820.                     lp->stats.tx_errors++;
  821.                     if (err_status & 0x0400) lp->stats.tx_aborted_errors++;
  822.                     if (err_status & 0x0800) lp->stats.tx_carrier_errors++;
  823.                     if (err_status & 0x1000) lp->stats.tx_window_errors++;
  824.                     if (err_status & 0x4000) {
  825.                         /* Ackk!  On FIFO errors the Tx unit is turned off! */
  826.                         lp->stats.tx_fifo_errors++;
  827.                         /* Remove this verbosity later! */
  828.                         printk("%s: Tx FIFO error! Status %4.4x.\n",
  829.                                dev->name, csr0);
  830.                         /* Restart the chip. */
  831.                         outw(0x0002, dev->base_addr + LANCE_DATA);
  832.                     }
  833.                 } else {
  834.                     if (status & 0x18000000)
  835.                         lp->stats.collisions++;
  836.                     lp->stats.tx_packets++;
  837.                 }
  838.  
  839.                 /* We must free the original skb if it's not a data-only copy
  840.                    in the bounce buffer. */
  841.                 if (lp->tx_skbuff[entry]) {
  842.                     dev_kfree_skb(lp->tx_skbuff[entry],FREE_WRITE);
  843.                     lp->tx_skbuff[entry] = 0;
  844.                 }
  845.                 dirty_tx++;
  846.             }
  847.  
  848. #ifndef final_version
  849.             if (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
  850.                 printk("out-of-sync dirty pointer, %d vs. %d, full=%d.\n",
  851.                        dirty_tx, lp->cur_tx, lp->tx_full);
  852.                 dirty_tx += TX_RING_SIZE;
  853.             }
  854. #endif
  855.  
  856.             if (lp->tx_full && dev->tbusy
  857.                 && dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
  858.                 /* The ring is no longer full, clear tbusy. */
  859.                 lp->tx_full = 0;
  860.                 dev->tbusy = 0;
  861.                 mark_bh(NET_BH);
  862.             }
  863.  
  864.             lp->dirty_tx = dirty_tx;
  865.         }
  866.  
  867.         /* Log misc errors. */
  868.         if (csr0 & 0x4000) lp->stats.tx_errors++; /* Tx babble. */
  869.         if (csr0 & 0x1000) lp->stats.rx_errors++; /* Missed a Rx frame. */
  870.         if (csr0 & 0x0800) {
  871.             printk("%s: Bus master arbitration failure, status %4.4x.\n",
  872.                    dev->name, csr0);
  873.             /* Restart the chip. */
  874.             outw(0x0002, dev->base_addr + LANCE_DATA);
  875.         }
  876.     }
  877.  
  878.     /* Clear any other interrupt, and set interrupt enable. */
  879.     outw(0x0000, dev->base_addr + LANCE_ADDR);
  880.     outw(0x7940, dev->base_addr + LANCE_DATA);
  881.  
  882.     if (lance_debug > 4)
  883.         printk("%s: exiting interrupt, csr%d=%#4.4x.\n",
  884.                dev->name, inw(ioaddr + LANCE_ADDR),
  885.                inw(dev->base_addr + LANCE_DATA));
  886.  
  887.     dev->interrupt = 0;
  888.     return;
  889. }
  890.  
  891. static int
  892. lance_rx(struct device *dev)
  893. {
  894.     struct lance_private *lp = (struct lance_private *)dev->priv;
  895.     int entry = lp->cur_rx & RX_RING_MOD_MASK;
  896.     int i;
  897.         
  898.     /* If we own the next entry, it's a new packet. Send it up. */
  899.     while (lp->rx_ring[entry].base >= 0) {
  900.         int status = lp->rx_ring[entry].base >> 24;
  901.  
  902.         if (status != 0x03) {            /* There was an error. */
  903.             /* There is a tricky error noted by John Murphy,
  904.                <murf@perftech.com> to Russ Nelson: Even with full-sized
  905.                buffers it's possible for a jabber packet to use two
  906.                buffers, with only the last correctly noting the error. */
  907.             if (status & 0x01)    /* Only count a general error at the */
  908.                 lp->stats.rx_errors++; /* end of a packet.*/
  909.             if (status & 0x20) lp->stats.rx_frame_errors++;
  910.             if (status & 0x10) lp->stats.rx_over_errors++;
  911.             if (status & 0x08) lp->stats.rx_crc_errors++;
  912.             if (status & 0x04) lp->stats.rx_fifo_errors++;
  913.             lp->rx_ring[entry].base &= 0x03ffffff;
  914.         } else {
  915.             /* Malloc up new buffer, compatible with net-2e. */
  916.             short pkt_len = lp->rx_ring[entry].msg_length;
  917.             struct sk_buff *skb;
  918.  
  919.             skb = alloc_skb(pkt_len, GFP_ATOMIC);
  920.             if (skb == NULL) {
  921.                 printk("%s: Memory squeeze, deferring packet.\n", dev->name);
  922.                 for (i=0; i < RX_RING_SIZE; i++)
  923.                   if (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
  924.                     break;
  925.  
  926.                 if (i > RX_RING_SIZE -2) {
  927.                   lp->stats.rx_dropped++;
  928.                   lp->rx_ring[entry].base |= 0x80000000;
  929.                   lp->cur_rx++;
  930.                 }
  931.                 break;
  932.             }
  933.             skb->len = pkt_len;
  934.             skb->dev = dev;
  935.             memcpy(skb->data,
  936.                    (unsigned char *)(lp->rx_ring[entry].base & 0x00ffffff),
  937.                    pkt_len);
  938.             netif_rx(skb);
  939.             lp->stats.rx_packets++;
  940.         }
  941.  
  942.         /* The docs say that the buffer length isn't touched, but Andrew Boyd
  943.            of QNX reports that some revs of the 79C965 clear it. */
  944.         lp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
  945.         lp->rx_ring[entry].base |= 0x80000000;
  946.         entry = (++lp->cur_rx) & RX_RING_MOD_MASK;
  947.     }
  948.  
  949.     /* We should check that at least two ring entries are free.     If not,
  950.        we should free one and mark stats->rx_dropped++. */
  951.  
  952.     return 0;
  953. }
  954.  
  955. static int
  956. lance_close(struct device *dev)
  957. {
  958.     int ioaddr = dev->base_addr;
  959.     struct lance_private *lp = (struct lance_private *)dev->priv;
  960.  
  961.     dev->start = 0;
  962.     dev->tbusy = 1;
  963.  
  964.     if (lp->chip_version != OLD_LANCE) {
  965.         outw(112, ioaddr+LANCE_ADDR);
  966.         lp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
  967.     }
  968.     outw(0, ioaddr+LANCE_ADDR);
  969.  
  970.     if (lance_debug > 1)
  971.         printk("%s: Shutting down ethercard, status was %2.2x.\n",
  972.                dev->name, inw(ioaddr+LANCE_DATA));
  973.  
  974.     /* We stop the LANCE here -- it occasionally polls
  975.        memory if we don't. */
  976.     outw(0x0004, ioaddr+LANCE_DATA);
  977.  
  978.     if (dev->dma != 4)
  979.         disable_dma(dev->dma);
  980.  
  981.     free_irq(dev->irq);
  982.  
  983.     irq2dev_map[dev->irq] = 0;
  984.  
  985.     return 0;
  986. }
  987.  
  988. static struct enet_statistics *
  989. lance_get_stats(struct device *dev)
  990. {
  991.     struct lance_private *lp = (struct lance_private *)dev->priv;
  992.     short ioaddr = dev->base_addr;
  993.     short saved_addr;
  994.  
  995.     if (lp->chip_version != OLD_LANCE) {
  996.         cli();
  997.         saved_addr = inw(ioaddr+LANCE_ADDR);
  998.         outw(112, ioaddr+LANCE_ADDR);
  999.         lp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
  1000.         outw(saved_addr, ioaddr+LANCE_ADDR);
  1001.         sti();
  1002.     }
  1003.  
  1004.     return &lp->stats;
  1005. }
  1006.  
  1007. /* Set or clear the multicast filter for this adaptor.
  1008.    num_addrs == -1        Promiscuous mode, receive all packets
  1009.    num_addrs == 0        Normal mode, clear multicast list
  1010.    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
  1011.                         best-effort filtering.
  1012.  */
  1013. static void
  1014. set_multicast_list(struct device *dev, int num_addrs, void *addrs)
  1015. {
  1016.     short ioaddr = dev->base_addr;
  1017.  
  1018.     /* We take the simple way out and always enable promiscuous mode. */
  1019.     outw(0, ioaddr+LANCE_ADDR);
  1020.     outw(0x0004, ioaddr+LANCE_DATA); /* Temporarily stop the lance.     */
  1021.  
  1022.     outw(15, ioaddr+LANCE_ADDR);
  1023.     if (num_addrs >= 0) {
  1024.         short multicast_table[4];
  1025.         int i;
  1026.         /* We don't use the multicast table, but rely on upper-layer filtering. */
  1027.         memset(multicast_table, (num_addrs == 0) ? 0 : -1, sizeof(multicast_table));
  1028.         for (i = 0; i < 4; i++) {
  1029.             outw(8 + i, ioaddr+LANCE_ADDR);
  1030.             outw(multicast_table[i], ioaddr+LANCE_DATA);
  1031.         }
  1032.         outw(0x0000, ioaddr+LANCE_DATA); /* Unset promiscuous mode */
  1033.     } else {
  1034.         /* Log any net taps. */
  1035.         printk("%s: Promiscuous mode enabled.\n", dev->name);
  1036.         outw(0x8000, ioaddr+LANCE_DATA); /* Set promiscuous mode */
  1037.     }
  1038.  
  1039.     outw(0, ioaddr+LANCE_ADDR);
  1040.     outw(0x0142, ioaddr+LANCE_DATA); /* Resume normal operation. */
  1041. }
  1042.  
  1043.  
  1044. /*
  1045.  * Local variables:
  1046.  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c lance.c"
  1047.  *  c-indent-level: 4
  1048.  *  tab-width: 4
  1049.  * End:
  1050.  */
  1051.