Return to lance.c CVS log

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

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

1.1     ! root        1: /* lance.c: An AMD LANCE/PCnet ethernet driver for Linux. */
        !             2: /*
        !             3:        Written/copyright 1993-1998 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/NE2500) ethercards.
        !            12: 
        !            13:        The author may be reached as [email protected], 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:        Fixing alignment problem with 1.3.* kernel and some minor changes
        !            18:        by Andrey V. Savochkin, 1996.
        !            19: 
        !            20:        Problems or questions may be send to Donald Becker (see above) or to
        !            21:        Andrey Savochkin -- [email protected] or
        !            22:                Laboratory of Computation Methods, 
        !            23:                Department of Mathematics and Mechanics,
        !            24:                Moscow State University,
        !            25:                Leninskye Gory, Moscow 119899
        !            26: 
        !            27:        But I should to inform you that I'm not an expert in the LANCE card
        !            28:        and it may occurs that you will receive no answer on your mail
        !            29:        to Donald Becker. I didn't receive any answer on all my letters
        !            30:        to him. Who knows why... But may be you are more lucky?  ;->
        !            31:                                                           SAW
        !            32: 
        !            33:        Thomas Bogendoerfer ([email protected]):
        !            34:        - added support for Linux/Alpha, but removed most of it, because
        !            35:         it worked only for the PCI chip. 
        !            36:       - added hook for the 32bit lance driver
        !            37:       - added PCnetPCI II (79C970A) to chip table
        !            38:        Paul Gortmaker ([email protected]):
        !            39:        - hopefully fix above so Linux/Alpha can use ISA cards too.
        !            40:     8/20/96 Fixed 7990 autoIRQ failure and reversed unneeded alignment -djb
        !            41:     v1.12 10/27/97 Module support -djb
        !            42:     v1.14  2/3/98 Module support modified, made PCI support optional -djb
        !            43: */
        !            44: 
        !            45: static const char *version = "lance.c:v1.14 2/3/1998 [email protected], [email protected]\n";
        !            46: 
        !            47: #ifdef MODULE
        !            48: #ifdef MODVERSIONS
        !            49: #include <linux/modversions.h>
        !            50: #endif
        !            51: #include <linux/module.h>
        !            52: #include <linux/version.h>
        !            53: #else
        !            54: #define MOD_INC_USE_COUNT
        !            55: #define MOD_DEC_USE_COUNT
        !            56: #endif
        !            57: 
        !            58: #include <linux/config.h>
        !            59: #include <linux/kernel.h>
        !            60: #include <linux/sched.h>
        !            61: #include <linux/string.h>
        !            62: #include <linux/ptrace.h>
        !            63: #include <linux/errno.h>
        !            64: #include <linux/ioport.h>
        !            65: #include <linux/malloc.h>
        !            66: #include <linux/interrupt.h>
        !            67: #include <linux/pci.h>
        !            68: #include <linux/bios32.h>
        !            69: #include <asm/bitops.h>
        !            70: #include <asm/io.h>
        !            71: #include <asm/dma.h>
        !            72: 
        !            73: #include <linux/netdevice.h>
        !            74: #include <linux/etherdevice.h>
        !            75: #include <linux/skbuff.h>
        !            76: 
        !            77: static unsigned int lance_portlist[] = { 0x300, 0x320, 0x340, 0x360, 0};
        !            78: int lance_probe(struct device *dev);
        !            79: int lance_probe1(struct device *dev, int ioaddr, int irq, int options);
        !            80: 
        !            81: #ifdef HAVE_DEVLIST
        !            82: struct netdev_entry lance_drv =
        !            83: {"lance", lance_probe1, LANCE_TOTAL_SIZE, lance_portlist};
        !            84: #endif
        !            85: 
        !            86: #ifdef LANCE_DEBUG
        !            87: int lance_debug = LANCE_DEBUG;
        !            88: #else
        !            89: int lance_debug = 1;
        !            90: #endif
        !            91: 
        !            92: /*
        !            93:                                Theory of Operation
        !            94: 
        !            95: I. Board Compatibility
        !            96: 
        !            97: This device driver is designed for the AMD 79C960, the "PCnet-ISA
        !            98: single-chip ethernet controller for ISA".  This chip is used in a wide
        !            99: variety of boards from vendors such as Allied Telesis, HP, Kingston,
        !           100: and Boca.  This driver is also intended to work with older AMD 7990
        !           101: designs, such as the NE1500 and NE2100, and newer 79C961.  For convenience,
        !           102: I use the name LANCE to refer to all of the AMD chips, even though it properly
        !           103: refers only to the original 7990.
        !           104: 
        !           105: II. Board-specific settings
        !           106: 
        !           107: The driver is designed to work the boards that use the faster
        !           108: bus-master mode, rather than in shared memory mode.     (Only older designs
        !           109: have on-board buffer memory needed to support the slower shared memory mode.)
        !           110: 
        !           111: Most ISA boards have jumpered settings for the I/O base, IRQ line, and DMA
        !           112: channel.  This driver probes the likely base addresses:
        !           113: {0x300, 0x320, 0x340, 0x360}.
        !           114: After the board is found it generates a DMA-timeout interrupt and uses
        !           115: autoIRQ to find the IRQ line.  The DMA channel can be set with the low bits
        !           116: of the otherwise-unused dev->mem_start value (aka PARAM1).  If unset it is
        !           117: probed for by enabling each free DMA channel in turn and checking if
        !           118: initialization succeeds.
        !           119: 
        !           120: The HP-J2405A board is an exception: with this board it is easy to read the
        !           121: EEPROM-set values for the base, IRQ, and DMA.  (Of course you must already
        !           122: _know_ the base address -- that field is for writing the EEPROM.)
        !           123: 
        !           124: III. Driver operation
        !           125: 
        !           126: IIIa. Ring buffers
        !           127: The LANCE uses ring buffers of Tx and Rx descriptors.  Each entry describes
        !           128: the base and length of the data buffer, along with status bits.         The length
        !           129: of these buffers is set by LANCE_LOG_{RX,TX}_BUFFERS, which is log_2() of
        !           130: the buffer length (rather than being directly the buffer length) for
        !           131: implementation ease.  The current values are 2 (Tx) and 4 (Rx), which leads to
        !           132: ring sizes of 4 (Tx) and 16 (Rx).  Increasing the number of ring entries
        !           133: needlessly uses extra space and reduces the chance that an upper layer will
        !           134: be able to reorder queued Tx packets based on priority.         Decreasing the number
        !           135: of entries makes it more difficult to achieve back-to-back packet transmission
        !           136: and increases the chance that Rx ring will overflow.  (Consider the worst case
        !           137: of receiving back-to-back minimum-sized packets.)
        !           138: 
        !           139: The LANCE has the capability to "chain" both Rx and Tx buffers, but this driver
        !           140: statically allocates full-sized (slightly oversized -- PKT_BUF_SZ) buffers to
        !           141: avoid the administrative overhead. For the Rx side this avoids dynamically
        !           142: allocating full-sized buffers "just in case", at the expense of a
        !           143: memory-to-memory data copy for each packet received.  For most systems this
        !           144: is a good tradeoff: the Rx buffer will always be in low memory, the copy
        !           145: is inexpensive, and it primes the cache for later packet processing.  For Tx
        !           146: the buffers are only used when needed as low-memory bounce buffers.
        !           147: 
        !           148: IIIB. 16M memory limitations.
        !           149: For the ISA bus master mode all structures used directly by the LANCE,
        !           150: the initialization block, Rx and Tx rings, and data buffers, must be
        !           151: accessible from the ISA bus, i.e. in the lower 16M of real memory.
        !           152: This is a problem for current Linux kernels on >16M machines. The network
        !           153: devices are initialized after memory initialization, and the kernel doles out
        !           154: memory from the top of memory downward.         The current solution is to have a
        !           155: special network initialization routine that's called before memory
        !           156: initialization; this will eventually be generalized for all network devices.
        !           157: As mentioned before, low-memory "bounce-buffers" are used when needed.
        !           158: 
        !           159: IIIC. Synchronization
        !           160: The driver runs as two independent, single-threaded flows of control.  One
        !           161: is the send-packet routine, which enforces single-threaded use by the
        !           162: dev->tbusy flag.  The other thread is the interrupt handler, which is single
        !           163: threaded by the hardware and other software.
        !           164: 
        !           165: The send packet thread has partial control over the Tx ring and 'dev->tbusy'
        !           166: flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
        !           167: queue slot is empty, it clears the tbusy flag when finished otherwise it sets
        !           168: the 'lp->tx_full' flag.
        !           169: 
        !           170: The interrupt handler has exclusive control over the Rx ring and records stats
        !           171: from the Tx ring.  (The Tx-done interrupt can't be selectively turned off, so
        !           172: we can't avoid the interrupt overhead by having the Tx routine reap the Tx
        !           173: stats.)         After reaping the stats, it marks the queue entry as empty by setting
        !           174: the 'base' to zero.     Iff the 'lp->tx_full' flag is set, it clears both the
        !           175: tx_full and tbusy flags.
        !           176: 
        !           177: */
        !           178: 
        !           179: /* Set the number of Tx and Rx buffers, using Log_2(# buffers).
        !           180:    Reasonable default values are 16 Tx buffers, and 16 Rx buffers.
        !           181:    That translates to 4 and 4 (16 == 2^^4).
        !           182:    This is a compile-time option for efficiency.
        !           183:    */
        !           184: #ifndef LANCE_LOG_TX_BUFFERS
        !           185: #define LANCE_LOG_TX_BUFFERS 4
        !           186: #define LANCE_LOG_RX_BUFFERS 4
        !           187: #endif
        !           188: 
        !           189: #define TX_RING_SIZE                   (1 << (LANCE_LOG_TX_BUFFERS))
        !           190: #define TX_RING_MOD_MASK               (TX_RING_SIZE - 1)
        !           191: #define TX_RING_LEN_BITS               ((LANCE_LOG_TX_BUFFERS) << 29)
        !           192: 
        !           193: #define RX_RING_SIZE                   (1 << (LANCE_LOG_RX_BUFFERS))
        !           194: #define RX_RING_MOD_MASK               (RX_RING_SIZE - 1)
        !           195: #define RX_RING_LEN_BITS               ((LANCE_LOG_RX_BUFFERS) << 29)
        !           196: 
        !           197: #define PKT_BUF_SZ             1544
        !           198: 
        !           199: /* Offsets from base I/O address. */
        !           200: #define LANCE_DATA 0x10
        !           201: #define LANCE_ADDR 0x12
        !           202: #define LANCE_RESET 0x14
        !           203: #define LANCE_BUS_IF 0x16
        !           204: #define LANCE_TOTAL_SIZE 0x18
        !           205: 
        !           206: /* The LANCE Rx and Tx ring descriptors. */
        !           207: struct lance_rx_head {
        !           208:        s32 base;
        !           209:        s16 buf_length;                 /* This length is 2s complement (negative)! */
        !           210:        s16 msg_length;                 /* This length is "normal". */
        !           211: };
        !           212: 
        !           213: struct lance_tx_head {
        !           214:        s32 base;
        !           215:        s16 length;                             /* Length is 2s complement (negative)! */
        !           216:        s16 misc;
        !           217: };
        !           218: 
        !           219: /* The LANCE initialization block, described in databook. */
        !           220: struct lance_init_block {
        !           221:        u16 mode;               /* Pre-set mode (reg. 15) */
        !           222:        u8  phys_addr[6]; /* Physical ethernet address */
        !           223:        u32 filter[2];                  /* Multicast filter (unused). */
        !           224:        /* Receive and transmit ring base, along with extra bits. */
        !           225:        u32  rx_ring;                   /* Tx and Rx ring base pointers */
        !           226:        u32  tx_ring;
        !           227: };
        !           228: 
        !           229: struct lance_private {
        !           230:        /* The Tx and Rx ring entries must be aligned on 8-byte boundaries. */
        !           231:        struct lance_rx_head rx_ring[RX_RING_SIZE];
        !           232:        struct lance_tx_head tx_ring[TX_RING_SIZE];
        !           233:        struct lance_init_block init_block;
        !           234:        const char *name;
        !           235:        /* The saved address of a sent-in-place packet/buffer, for skfree(). */
        !           236:        struct sk_buff* tx_skbuff[TX_RING_SIZE];
        !           237:        /* The addresses of receive-in-place skbuffs. */
        !           238:        struct sk_buff* rx_skbuff[RX_RING_SIZE];
        !           239:        unsigned long rx_buffs;         /* Address of Rx and Tx buffers. */
        !           240:        /* Tx low-memory "bounce buffer" address. */
        !           241:        char (*tx_bounce_buffs)[PKT_BUF_SZ];
        !           242:        int cur_rx, cur_tx;                     /* The next free ring entry */
        !           243:        int dirty_rx, dirty_tx;         /* The ring entries to be free()ed. */
        !           244:        int dma;
        !           245:        struct enet_statistics stats;
        !           246:        unsigned char chip_version;     /* See lance_chip_type. */
        !           247:        char tx_full;
        !           248:        unsigned long lock;
        !           249: };
        !           250: 
        !           251: #define LANCE_MUST_PAD          0x00000001
        !           252: #define LANCE_ENABLE_AUTOSELECT 0x00000002
        !           253: #define LANCE_MUST_REINIT_RING  0x00000004
        !           254: #define LANCE_MUST_UNRESET      0x00000008
        !           255: #define LANCE_HAS_MISSED_FRAME  0x00000010
        !           256: 
        !           257: /* A mapping from the chip ID number to the part number and features.
        !           258:    These are from the datasheets -- in real life the '970 version
        !           259:    reportedly has the same ID as the '965. */
        !           260: static struct lance_chip_type {
        !           261:        int id_number;
        !           262:        const char *name;
        !           263:        int flags;
        !           264: } chip_table[] = {
        !           265:        {0x0000, "LANCE 7990",                          /* Ancient lance chip.  */
        !           266:                LANCE_MUST_PAD + LANCE_MUST_UNRESET},
        !           267:        {0x0003, "PCnet/ISA 79C960",            /* 79C960 PCnet/ISA.  */
        !           268:                LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
        !           269:                        LANCE_HAS_MISSED_FRAME},
        !           270:        {0x2260, "PCnet/ISA+ 79C961",           /* 79C961 PCnet/ISA+, Plug-n-Play.  */
        !           271:                LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
        !           272:                        LANCE_HAS_MISSED_FRAME},
        !           273:        {0x2420, "PCnet/PCI 79C970",            /* 79C970 or 79C974 PCnet-SCSI, PCI. */
        !           274:                LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
        !           275:                        LANCE_HAS_MISSED_FRAME},
        !           276:        /* Bug: the PCnet/PCI actually uses the PCnet/VLB ID number, so just call
        !           277:                it the PCnet32. */
        !           278:        {0x2430, "PCnet32",                                     /* 79C965 PCnet for VL bus. */
        !           279:                LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
        !           280:                        LANCE_HAS_MISSED_FRAME},
        !           281:         {0x2621, "PCnet/PCI-II 79C970A",        /* 79C970A PCInetPCI II. */
        !           282:                 LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
        !           283:                         LANCE_HAS_MISSED_FRAME},
        !           284:        {0x0,    "PCnet (unknown)",
        !           285:                LANCE_ENABLE_AUTOSELECT + LANCE_MUST_REINIT_RING +
        !           286:                        LANCE_HAS_MISSED_FRAME},
        !           287: };
        !           288: 
        !           289: enum {OLD_LANCE = 0, PCNET_ISA=1, PCNET_ISAP=2, PCNET_PCI=3, PCNET_VLB=4, PCNET_PCI_II=5, LANCE_UNKNOWN=6};
        !           290: 
        !           291: /* Non-zero only if the current card is a PCI with BIOS-set IRQ. */
        !           292: static unsigned char pci_irq_line = 0;
        !           293: 
        !           294: /* Non-zero if lance_probe1() needs to allocate low-memory bounce buffers.
        !           295:    Assume yes until we know the memory size. */
        !           296: static unsigned char lance_need_isa_bounce_buffers = 1;
        !           297: 
        !           298: static int lance_open(struct device *dev);
        !           299: static int lance_open_fail(struct device *dev);
        !           300: static void lance_init_ring(struct device *dev, int mode);
        !           301: static int lance_start_xmit(struct sk_buff *skb, struct device *dev);
        !           302: static int lance_rx(struct device *dev);
        !           303: static void lance_interrupt(int irq, void *dev_id, struct pt_regs *regs);
        !           304: static int lance_close(struct device *dev);
        !           305: static struct enet_statistics *lance_get_stats(struct device *dev);
        !           306: static void set_multicast_list(struct device *dev);
        !           307: 
        !           308: 
        !           309: 
        !           310: #ifdef MODULE
        !           311: #define MAX_CARDS              8       /* Max number of interfaces (cards) per module */
        !           312: #define IF_NAMELEN             8       /* # of chars for storing dev->name */
        !           313: 
        !           314: static int io[MAX_CARDS] = { 0, };
        !           315: static int dma[MAX_CARDS] = { 0, };
        !           316: static int irq[MAX_CARDS]  = { 0, };
        !           317: 
        !           318: static char ifnames[MAX_CARDS][IF_NAMELEN] = { {0, }, };
        !           319: static struct device dev_lance[MAX_CARDS] =
        !           320: {{
        !           321:     0, /* device name is inserted by linux/drivers/net/net_init.c */
        !           322:        0, 0, 0, 0,
        !           323:        0, 0,
        !           324:        0, 0, 0, NULL, NULL}};
        !           325: 
        !           326: int init_module(void)
        !           327: {
        !           328:        int this_dev, found = 0;
        !           329: 
        !           330:        for (this_dev = 0; this_dev < MAX_CARDS; this_dev++) {
        !           331:                struct device *dev = &dev_lance[this_dev];
        !           332:                dev->name = ifnames[this_dev];
        !           333:                dev->irq = irq[this_dev];
        !           334:                dev->base_addr = io[this_dev];
        !           335:                dev->dma = dma[this_dev];
        !           336:                dev->init = lance_probe;
        !           337:                if (io[this_dev] == 0)  {
        !           338:                        if (this_dev != 0) break; /* only complain once */
        !           339:                        printk(KERN_NOTICE "lance.c: Module autoprobing not allowed. Append \"io=0xNNN\" value(s).\n");
        !           340:                        return -EPERM;
        !           341:                }
        !           342:                if (register_netdev(dev) != 0) {
        !           343:                        printk(KERN_WARNING "lance.c: No PCnet/LANCE card found (i/o = 0x%x).\n", io[this_dev]);
        !           344:                        if (found != 0) return 0;       /* Got at least one. */
        !           345:                        return -ENXIO;
        !           346:                }
        !           347:                found++;
        !           348:        }
        !           349: 
        !           350:        return 0;
        !           351: }
        !           352: 
        !           353: void
        !           354: cleanup_module(void)
        !           355: {
        !           356:        int this_dev;
        !           357: 
        !           358:        for (this_dev = 0; this_dev < MAX_CARDS; this_dev++) {
        !           359:                struct device *dev = &dev_lance[this_dev];
        !           360:                if (dev->priv != NULL) {
        !           361:                        kfree(dev->priv);
        !           362:                        dev->priv = NULL;
        !           363:                        free_dma(dev->dma);
        !           364:                        release_region(dev->base_addr, LANCE_TOTAL_SIZE);
        !           365:                        unregister_netdev(dev);
        !           366:                }
        !           367:        }
        !           368: }
        !           369: #endif /* MODULE */
        !           370: 
        !           371: /* Starting in v2.1.*, the LANCE/PCnet probe is now similar to the other
        !           372:    board probes now that kmalloc() can allocate ISA DMA-able regions.
        !           373:    This also allows the LANCE driver to be used as a module.
        !           374:    */
        !           375: int lance_probe(struct device *dev)
        !           376: {
        !           377:        int *port, result;
        !           378: 
        !           379:        if (high_memory <= 16*1024*1024)
        !           380:                lance_need_isa_bounce_buffers = 0;
        !           381: 
        !           382: #if defined(CONFIG_PCI)
        !           383:     if (pcibios_present()) {
        !           384:            int pci_index;
        !           385:                if (lance_debug > 1)
        !           386:                        printk("lance.c: PCI bios is present, checking for devices...\n");
        !           387:                for (pci_index = 0; pci_index < 8; pci_index++) {
        !           388:                        unsigned char pci_bus, pci_device_fn;
        !           389:                        unsigned int pci_ioaddr;
        !           390:                        unsigned short pci_command;
        !           391: 
        !           392:                        if (pcibios_find_device (PCI_VENDOR_ID_AMD,
        !           393:                                                                         PCI_DEVICE_ID_AMD_LANCE, pci_index,
        !           394:                                                                         &pci_bus, &pci_device_fn) != 0)
        !           395:                                break;
        !           396:                        pcibios_read_config_byte(pci_bus, pci_device_fn,
        !           397:                                                                         PCI_INTERRUPT_LINE, &pci_irq_line);
        !           398:                        pcibios_read_config_dword(pci_bus, pci_device_fn,
        !           399:                                                                          PCI_BASE_ADDRESS_0, &pci_ioaddr);
        !           400:                        /* Remove I/O space marker in bit 0. */
        !           401:                        pci_ioaddr &= ~3;
        !           402:                        /* PCI Spec 2.1 states that it is either the driver or PCI card's
        !           403:                         * responsibility to set the PCI Master Enable Bit if needed.
        !           404:                         *      (From Mark Stockton <[email protected]>)
        !           405:                         */
        !           406:                        pcibios_read_config_word(pci_bus, pci_device_fn,
        !           407:                                                                         PCI_COMMAND, &pci_command);
        !           408:                        if ( ! (pci_command & PCI_COMMAND_MASTER)) {
        !           409:                                printk("PCI Master Bit has not been set. Setting...\n");
        !           410:                                pci_command |= PCI_COMMAND_MASTER;
        !           411:                                pcibios_write_config_word(pci_bus, pci_device_fn,
        !           412:                                                                                  PCI_COMMAND, pci_command);
        !           413:                        }
        !           414:                        printk("Found PCnet/PCI at %#x, irq %d.\n",
        !           415:                                   pci_ioaddr, pci_irq_line);
        !           416:                        result = lance_probe1(dev, pci_ioaddr, pci_irq_line, 0);
        !           417:                        pci_irq_line = 0;
        !           418:                        if (!result) return 0;
        !           419:                }
        !           420:        }
        !           421: #endif  /* defined(CONFIG_PCI) */
        !           422: 
        !           423:        for (port = lance_portlist; *port; port++) {
        !           424:                int ioaddr = *port;
        !           425: 
        !           426:                if ( check_region(ioaddr, LANCE_TOTAL_SIZE) == 0) {
        !           427:                        /* Detect "normal" 0x57 0x57 and the NI6510EB 0x52 0x44
        !           428:                           signatures w/ minimal I/O reads */
        !           429:                        char offset15, offset14 = inb(ioaddr + 14);
        !           430:                        
        !           431:                        if ((offset14 == 0x52 || offset14 == 0x57) &&
        !           432:                                ((offset15 = inb(ioaddr + 15)) == 0x57 || offset15 == 0x44)) {
        !           433:                                result = lance_probe1(dev, ioaddr, 0, 0);
        !           434:                                if ( !result ) return 0;
        !           435:                        }
        !           436:                }
        !           437:        }
        !           438:        return -ENODEV;
        !           439: }
        !           440: 
        !           441: int lance_probe1(struct device *dev, int ioaddr, int irq, int options)
        !           442: {
        !           443:        struct lance_private *lp;
        !           444:        short dma_channels;                                     /* Mark spuriously-busy DMA channels */
        !           445:        int i, reset_val, lance_version;
        !           446:        const char *chipname;
        !           447:        /* Flags for specific chips or boards. */
        !           448:        unsigned char hpJ2405A = 0;                     /* HP ISA adaptor */
        !           449:        int hp_builtin = 0;                                     /* HP on-board ethernet. */
        !           450:        static int did_version = 0;                     /* Already printed version info. */
        !           451: 
        !           452:        /* First we look for special cases.
        !           453:           Check for HP's on-board ethernet by looking for 'HP' in the BIOS.
        !           454:           There are two HP versions, check the BIOS for the configuration port.
        !           455:           This method provided by L. Julliard, [email protected].
        !           456:           */
        !           457:        if (readw(0x000f0102) == 0x5048)  {
        !           458:                static const short ioaddr_table[] = { 0x300, 0x320, 0x340, 0x360};
        !           459:                int hp_port = (readl(0x000f00f1) & 1)  ? 0x499 : 0x99;
        !           460:                /* We can have boards other than the built-in!  Verify this is on-board. */
        !           461:                if ((inb(hp_port) & 0xc0) == 0x80
        !           462:                        && ioaddr_table[inb(hp_port) & 3] == ioaddr)
        !           463:                        hp_builtin = hp_port;
        !           464:        }
        !           465:        /* We also recognize the HP Vectra on-board here, but check below. */
        !           466:        hpJ2405A = (inb(ioaddr) == 0x08 && inb(ioaddr+1) == 0x00
        !           467:                                && inb(ioaddr+2) == 0x09);
        !           468: 
        !           469:        /* Reset the LANCE.      */
        !           470:        reset_val = inw(ioaddr+LANCE_RESET); /* Reset the LANCE */
        !           471: 
        !           472:        /* The Un-Reset needed is only needed for the real NE2100, and will
        !           473:           confuse the HP board. */
        !           474:        if (!hpJ2405A)
        !           475:                outw(reset_val, ioaddr+LANCE_RESET);
        !           476: 
        !           477:        outw(0x0000, ioaddr+LANCE_ADDR); /* Switch to window 0 */
        !           478:        if (inw(ioaddr+LANCE_DATA) != 0x0004)
        !           479:                return -ENODEV;
        !           480: 
        !           481:        /* Get the version of the chip. */
        !           482:        outw(88, ioaddr+LANCE_ADDR);
        !           483:        if (inw(ioaddr+LANCE_ADDR) != 88) {
        !           484:                lance_version = 0;
        !           485:        } else {                                                        /* Good, it's a newer chip. */
        !           486:                int chip_version = inw(ioaddr+LANCE_DATA);
        !           487:                outw(89, ioaddr+LANCE_ADDR);
        !           488:                chip_version |= inw(ioaddr+LANCE_DATA) << 16;
        !           489:                if (lance_debug > 2)
        !           490:                        printk("  LANCE chip version is %#x.\n", chip_version);
        !           491:                if ((chip_version & 0xfff) != 0x003)
        !           492:                        return -ENODEV;
        !           493:                chip_version = (chip_version >> 12) & 0xffff;
        !           494:                for (lance_version = 1; chip_table[lance_version].id_number; lance_version++) {
        !           495:                        if (chip_table[lance_version].id_number == chip_version)
        !           496:                                break;
        !           497:                }
        !           498:        }
        !           499: 
        !           500:        /* We can't use init_etherdev() to allocate dev->priv because it must
        !           501:           a ISA DMA-able region. */
        !           502:        dev = init_etherdev(dev, 0);
        !           503:        dev->open = lance_open_fail;
        !           504:        chipname = chip_table[lance_version].name;
        !           505:        printk("%s: %s at %#3x,", dev->name, chipname, ioaddr);
        !           506: 
        !           507:        /* There is a 16 byte station address PROM at the base address.
        !           508:           The first six bytes are the station address. */
        !           509:        for (i = 0; i < 6; i++)
        !           510:                printk(" %2.2x", dev->dev_addr[i] = inb(ioaddr + i));
        !           511: 
        !           512:        dev->base_addr = ioaddr;
        !           513:        request_region(ioaddr, LANCE_TOTAL_SIZE, chip_table[lance_version].name);
        !           514: 
        !           515:        /* Make certain the data structures used by the LANCE are aligned and DMAble. */
        !           516:                
        !           517:        lp = (struct lance_private *)(((unsigned long)kmalloc(sizeof(*lp)+7,
        !           518:                                                                                   GFP_DMA | GFP_KERNEL)+7) & ~7);
        !           519:        if (lance_debug > 6) printk(" (#0x%05lx)", (unsigned long)lp);
        !           520:        memset(lp, 0, sizeof(*lp));
        !           521:        dev->priv = lp;
        !           522:        lp->name = chipname;
        !           523:        lp->rx_buffs = (unsigned long)kmalloc(PKT_BUF_SZ*RX_RING_SIZE,
        !           524:                                                                                  GFP_DMA | GFP_KERNEL);
        !           525:        if (lance_need_isa_bounce_buffers)
        !           526:                lp->tx_bounce_buffs = kmalloc(PKT_BUF_SZ*TX_RING_SIZE,
        !           527:                                                                          GFP_DMA | GFP_KERNEL);
        !           528:        else
        !           529:                lp->tx_bounce_buffs = NULL;
        !           530: 
        !           531:        lp->chip_version = lance_version;
        !           532: 
        !           533:        lp->init_block.mode = 0x0003;           /* Disable Rx and Tx. */
        !           534:        for (i = 0; i < 6; i++)
        !           535:                lp->init_block.phys_addr[i] = dev->dev_addr[i];
        !           536:        lp->init_block.filter[0] = 0x00000000;
        !           537:        lp->init_block.filter[1] = 0x00000000;
        !           538:        lp->init_block.rx_ring = ((u32)virt_to_bus(lp->rx_ring) & 0xffffff) | RX_RING_LEN_BITS;
        !           539:        lp->init_block.tx_ring = ((u32)virt_to_bus(lp->tx_ring) & 0xffffff) | TX_RING_LEN_BITS;
        !           540: 
        !           541:        outw(0x0001, ioaddr+LANCE_ADDR);
        !           542:        inw(ioaddr+LANCE_ADDR);
        !           543:        outw((short) (u32) virt_to_bus(&lp->init_block), ioaddr+LANCE_DATA);
        !           544:        outw(0x0002, ioaddr+LANCE_ADDR);
        !           545:        inw(ioaddr+LANCE_ADDR);
        !           546:        outw(((u32)virt_to_bus(&lp->init_block)) >> 16, ioaddr+LANCE_DATA);
        !           547:        outw(0x0000, ioaddr+LANCE_ADDR);
        !           548:        inw(ioaddr+LANCE_ADDR);
        !           549: 
        !           550:        if (irq) {                                      /* Set iff PCI card. */
        !           551:                dev->dma = 4;                   /* Native bus-master, no DMA channel needed. */
        !           552:                dev->irq = irq;
        !           553:        } else if (hp_builtin) {
        !           554:                static const char dma_tbl[4] = {3, 5, 6, 0};
        !           555:                static const char irq_tbl[4] = {3, 4, 5, 9};
        !           556:                unsigned char port_val = inb(hp_builtin);
        !           557:                dev->dma = dma_tbl[(port_val >> 4) & 3];
        !           558:                dev->irq = irq_tbl[(port_val >> 2) & 3];
        !           559:                printk(" HP Vectra IRQ %d DMA %d.\n", dev->irq, dev->dma);
        !           560:        } else if (hpJ2405A) {
        !           561:                static const char dma_tbl[4] = {3, 5, 6, 7};
        !           562:                static const char irq_tbl[8] = {3, 4, 5, 9, 10, 11, 12, 15};
        !           563:                short reset_val = inw(ioaddr+LANCE_RESET);
        !           564:                dev->dma = dma_tbl[(reset_val >> 2) & 3];
        !           565:                dev->irq = irq_tbl[(reset_val >> 4) & 7];
        !           566:                printk(" HP J2405A IRQ %d DMA %d.\n", dev->irq, dev->dma);
        !           567:        } else if (lance_version == PCNET_ISAP) {               /* The plug-n-play version. */
        !           568:                short bus_info;
        !           569:                outw(8, ioaddr+LANCE_ADDR);
        !           570:                bus_info = inw(ioaddr+LANCE_BUS_IF);
        !           571:                dev->dma = bus_info & 0x07;
        !           572:                dev->irq = (bus_info >> 4) & 0x0F;
        !           573:        } else {
        !           574:                /* The DMA channel may be passed in PARAM1. */
        !           575:                if (dev->mem_start & 0x07)
        !           576:                        dev->dma = dev->mem_start & 0x07;
        !           577:        }
        !           578: 
        !           579:        if (dev->dma == 0) {
        !           580:                /* Read the DMA channel status register, so that we can avoid
        !           581:                   stuck DMA channels in the DMA detection below. */
        !           582:                dma_channels = ((inb(DMA1_STAT_REG) >> 4) & 0x0f) |
        !           583:                        (inb(DMA2_STAT_REG) & 0xf0);
        !           584:        }
        !           585:        if (dev->irq >= 2)
        !           586:                printk(" assigned IRQ %d", dev->irq);
        !           587:        else if (lance_version != 0)  { /* 7990 boards need DMA detection first. */
        !           588:                /* To auto-IRQ we enable the initialization-done and DMA error
        !           589:                   interrupts. For ISA boards we get a DMA error, but VLB and PCI
        !           590:                   boards will work. */
        !           591:                autoirq_setup(0);
        !           592: 
        !           593:                /* Trigger an initialization just for the interrupt. */
        !           594:                outw(0x0041, ioaddr+LANCE_DATA);
        !           595: 
        !           596:                dev->irq = autoirq_report(2);
        !           597:                if (dev->irq)
        !           598:                        printk(", probed IRQ %d", dev->irq);
        !           599:                else {
        !           600:                        printk(", failed to detect IRQ line.\n");
        !           601:                        return -ENODEV;
        !           602:                }
        !           603: 
        !           604:                /* Check for the initialization done bit, 0x0100, which means
        !           605:                   that we don't need a DMA channel. */
        !           606:                if (inw(ioaddr+LANCE_DATA) & 0x0100)
        !           607:                        dev->dma = 4;
        !           608:        }
        !           609: 
        !           610:        if (dev->dma == 4) {
        !           611:                printk(", no DMA needed.\n");
        !           612:        } else if (dev->dma) {
        !           613:                if (request_dma(dev->dma, chipname)) {
        !           614:                        printk("DMA %d allocation failed.\n", dev->dma);
        !           615:                        return -ENODEV;
        !           616:                } else
        !           617:                        printk(", assigned DMA %d.\n", dev->dma);
        !           618:        } else {                        /* OK, we have to auto-DMA. */
        !           619:                for (i = 0; i < 4; i++) {
        !           620:                        static const char dmas[] = { 5, 6, 7, 3 };
        !           621:                        int dma = dmas[i];
        !           622:                        int boguscnt;
        !           623: 
        !           624:                        /* Don't enable a permanently busy DMA channel, or the machine
        !           625:                           will hang. */
        !           626:                        if (test_bit(dma, &dma_channels))
        !           627:                                continue;
        !           628:                        outw(0x7f04, ioaddr+LANCE_DATA); /* Clear the memory error bits. */
        !           629:                        if (request_dma(dma, chipname))
        !           630:                                continue;
        !           631:                        set_dma_mode(dma, DMA_MODE_CASCADE);
        !           632:                        enable_dma(dma);
        !           633: 
        !           634:                        /* Trigger an initialization. */
        !           635:                        outw(0x0001, ioaddr+LANCE_DATA);
        !           636:                        for (boguscnt = 100; boguscnt > 0; --boguscnt)
        !           637:                                if (inw(ioaddr+LANCE_DATA) & 0x0900)
        !           638:                                        break;
        !           639:                        if (inw(ioaddr+LANCE_DATA) & 0x0100) {
        !           640:                                dev->dma = dma;
        !           641:                                printk(", DMA %d.\n", dev->dma);
        !           642:                                break;
        !           643:                        } else {
        !           644:                                disable_dma(dma);
        !           645:                                free_dma(dma);
        !           646:                        }
        !           647:                }
        !           648:                if (i == 4) {                   /* Failure: bail. */
        !           649:                        printk("DMA detection failed.\n");
        !           650:                        return -ENODEV;
        !           651:                }
        !           652:        }
        !           653: 
        !           654:        if (lance_version == 0 && dev->irq == 0) {
        !           655:                /* We may auto-IRQ now that we have a DMA channel. */
        !           656:                /* Trigger an initialization just for the interrupt. */
        !           657:                autoirq_setup(0);
        !           658:                outw(0x0041, ioaddr+LANCE_DATA);
        !           659: 
        !           660:                dev->irq = autoirq_report(4);
        !           661:                if (dev->irq == 0) {
        !           662:                        printk("  Failed to detect the 7990 IRQ line.\n");
        !           663:                        return -ENODEV;
        !           664:                }
        !           665:                printk("  Auto-IRQ detected IRQ%d.\n", dev->irq);
        !           666:        }
        !           667: 
        !           668:        if (chip_table[lp->chip_version].flags & LANCE_ENABLE_AUTOSELECT) {
        !           669:                /* Turn on auto-select of media (10baseT or BNC) so that the user
        !           670:                   can watch the LEDs even if the board isn't opened. */
        !           671:                outw(0x0002, ioaddr+LANCE_ADDR);
        !           672:                /* Don't touch 10base2 power bit. */
        !           673:                outw(inw(ioaddr+LANCE_BUS_IF) | 0x0002, ioaddr+LANCE_BUS_IF);
        !           674:        }
        !           675: 
        !           676:        if (lance_debug > 0  &&  did_version++ == 0)
        !           677:                printk(version);
        !           678: 
        !           679:        /* The LANCE-specific entries in the device structure. */
        !           680:        dev->open = lance_open;
        !           681:        dev->hard_start_xmit = lance_start_xmit;
        !           682:        dev->stop = lance_close;
        !           683:        dev->get_stats = lance_get_stats;
        !           684:        dev->set_multicast_list = set_multicast_list;
        !           685: 
        !           686:        return 0;
        !           687: }
        !           688: 
        !           689: static int
        !           690: lance_open_fail(struct device *dev)
        !           691: {
        !           692:        return -ENODEV;
        !           693: }
        !           694: 
        !           695: 
        !           696: 
        !           697: static int
        !           698: lance_open(struct device *dev)
        !           699: {
        !           700:        struct lance_private *lp = (struct lance_private *)dev->priv;
        !           701:        int ioaddr = dev->base_addr;
        !           702:        int i;
        !           703: 
        !           704:        if (dev->irq == 0 ||
        !           705:                request_irq(dev->irq, &lance_interrupt, 0, lp->name, dev)) {
        !           706:                return -EAGAIN;
        !           707:        }
        !           708: 
        !           709:        MOD_INC_USE_COUNT;
        !           710: 
        !           711:        /* We used to allocate DMA here, but that was silly.
        !           712:           DMA lines can't be shared!  We now permanently allocate them. */
        !           713: 
        !           714:        /* Reset the LANCE */
        !           715:        inw(ioaddr+LANCE_RESET);
        !           716: 
        !           717:        /* The DMA controller is used as a no-operation slave, "cascade mode". */
        !           718:        if (dev->dma != 4) {
        !           719:                enable_dma(dev->dma);
        !           720:                set_dma_mode(dev->dma, DMA_MODE_CASCADE);
        !           721:        }
        !           722: 
        !           723:        /* Un-Reset the LANCE, needed only for the NE2100. */
        !           724:        if (chip_table[lp->chip_version].flags & LANCE_MUST_UNRESET)
        !           725:                outw(0, ioaddr+LANCE_RESET);
        !           726: 
        !           727:        if (chip_table[lp->chip_version].flags & LANCE_ENABLE_AUTOSELECT) {
        !           728:                /* This is 79C960-specific: Turn on auto-select of media (AUI, BNC). */
        !           729:                outw(0x0002, ioaddr+LANCE_ADDR);
        !           730:                /* Only touch autoselect bit. */
        !           731:                outw(inw(ioaddr+LANCE_BUS_IF) | 0x0002, ioaddr+LANCE_BUS_IF);
        !           732:        }
        !           733: 
        !           734:        if (lance_debug > 1)
        !           735:                printk("%s: lance_open() irq %d dma %d tx/rx rings %#x/%#x init %#x.\n",
        !           736:                           dev->name, dev->irq, dev->dma,
        !           737:                           (u32) virt_to_bus(lp->tx_ring),
        !           738:                           (u32) virt_to_bus(lp->rx_ring),
        !           739:                           (u32) virt_to_bus(&lp->init_block));
        !           740: 
        !           741:        lance_init_ring(dev, GFP_KERNEL);
        !           742:        /* Re-initialize the LANCE, and start it when done. */
        !           743:        outw(0x0001, ioaddr+LANCE_ADDR);
        !           744:        outw((short) (u32) virt_to_bus(&lp->init_block), ioaddr+LANCE_DATA);
        !           745:        outw(0x0002, ioaddr+LANCE_ADDR);
        !           746:        outw(((u32)virt_to_bus(&lp->init_block)) >> 16, ioaddr+LANCE_DATA);
        !           747: 
        !           748:        outw(0x0004, ioaddr+LANCE_ADDR);
        !           749:        outw(0x0915, ioaddr+LANCE_DATA);
        !           750: 
        !           751:        outw(0x0000, ioaddr+LANCE_ADDR);
        !           752:        outw(0x0001, ioaddr+LANCE_DATA);
        !           753: 
        !           754:        dev->tbusy = 0;
        !           755:        dev->interrupt = 0;
        !           756:        dev->start = 1;
        !           757:        i = 0;
        !           758:        while (i++ < 100)
        !           759:                if (inw(ioaddr+LANCE_DATA) & 0x0100)
        !           760:                        break;
        !           761:        /* 
        !           762:         * We used to clear the InitDone bit, 0x0100, here but Mark Stockton
        !           763:         * reports that doing so triggers a bug in the '974.
        !           764:         */
        !           765:        outw(0x0042, ioaddr+LANCE_DATA);
        !           766: 
        !           767:        if (lance_debug > 2)
        !           768:                printk("%s: LANCE open after %d ticks, init block %#x csr0 %4.4x.\n",
        !           769:                           dev->name, i, (u32) virt_to_bus(&lp->init_block), inw(ioaddr+LANCE_DATA));
        !           770: 
        !           771:        return 0;                                       /* Always succeed */
        !           772: }
        !           773: 
        !           774: /* The LANCE has been halted for one reason or another (busmaster memory
        !           775:    arbitration error, Tx FIFO underflow, driver stopped it to reconfigure,
        !           776:    etc.).  Modern LANCE variants always reload their ring-buffer
        !           777:    configuration when restarted, so we must reinitialize our ring
        !           778:    context before restarting.  As part of this reinitialization,
        !           779:    find all packets still on the Tx ring and pretend that they had been
        !           780:    sent (in effect, drop the packets on the floor) - the higher-level
        !           781:    protocols will time out and retransmit.  It'd be better to shuffle
        !           782:    these skbs to a temp list and then actually re-Tx them after
        !           783:    restarting the chip, but I'm too lazy to do so right now.  [email protected]
        !           784: */
        !           785: 
        !           786: static void 
        !           787: lance_purge_tx_ring(struct device *dev)
        !           788: {
        !           789:        struct lance_private *lp = (struct lance_private *)dev->priv;
        !           790:        int i;
        !           791: 
        !           792:        for (i = 0; i < TX_RING_SIZE; i++) {
        !           793:                if (lp->tx_skbuff[i]) {
        !           794:                        dev_kfree_skb(lp->tx_skbuff[i],FREE_WRITE);
        !           795:                        lp->tx_skbuff[i] = NULL;
        !           796:                }
        !           797:        }
        !           798: }
        !           799: 
        !           800: 
        !           801: /* Initialize the LANCE Rx and Tx rings. */
        !           802: static void
        !           803: lance_init_ring(struct device *dev, int gfp)
        !           804: {
        !           805:        struct lance_private *lp = (struct lance_private *)dev->priv;
        !           806:        int i;
        !           807: 
        !           808:        lp->lock = 0, lp->tx_full = 0;
        !           809:        lp->cur_rx = lp->cur_tx = 0;
        !           810:        lp->dirty_rx = lp->dirty_tx = 0;
        !           811: 
        !           812:        for (i = 0; i < RX_RING_SIZE; i++) {
        !           813:                struct sk_buff *skb;
        !           814:                void *rx_buff;
        !           815: 
        !           816:                skb = alloc_skb(PKT_BUF_SZ, GFP_DMA | gfp);
        !           817:                lp->rx_skbuff[i] = skb;
        !           818:                if (skb) {
        !           819:                        skb->dev = dev;
        !           820:                        rx_buff = skb->tail;
        !           821:                } else
        !           822:                        rx_buff = kmalloc(PKT_BUF_SZ, GFP_DMA | gfp);
        !           823:                if (rx_buff == NULL)
        !           824:                        lp->rx_ring[i].base = 0;
        !           825:                else
        !           826:                        lp->rx_ring[i].base = (u32)virt_to_bus(rx_buff) | 0x80000000;
        !           827:                lp->rx_ring[i].buf_length = -PKT_BUF_SZ;
        !           828:        }
        !           829:        /* The Tx buffer address is filled in as needed, but we do need to clear
        !           830:           the upper ownership bit. */
        !           831:        for (i = 0; i < TX_RING_SIZE; i++) {
        !           832:                lp->tx_skbuff[i] = 0;
        !           833:                lp->tx_ring[i].base = 0;
        !           834:        }
        !           835: 
        !           836:        lp->init_block.mode = 0x0000;
        !           837:        for (i = 0; i < 6; i++)
        !           838:                lp->init_block.phys_addr[i] = dev->dev_addr[i];
        !           839:        lp->init_block.filter[0] = 0x00000000;
        !           840:        lp->init_block.filter[1] = 0x00000000;
        !           841:        lp->init_block.rx_ring = ((u32)virt_to_bus(lp->rx_ring) & 0xffffff) | RX_RING_LEN_BITS;
        !           842:        lp->init_block.tx_ring = ((u32)virt_to_bus(lp->tx_ring) & 0xffffff) | TX_RING_LEN_BITS;
        !           843: }
        !           844: 
        !           845: static void
        !           846: lance_restart(struct device *dev, unsigned int csr0_bits, int must_reinit)
        !           847: {
        !           848:        struct lance_private *lp = (struct lance_private *)dev->priv;
        !           849: 
        !           850:        if (must_reinit ||
        !           851:                (chip_table[lp->chip_version].flags & LANCE_MUST_REINIT_RING)) {
        !           852:                lance_purge_tx_ring(dev);
        !           853:                lance_init_ring(dev, GFP_ATOMIC);
        !           854:        }
        !           855:        outw(0x0000,    dev->base_addr + LANCE_ADDR);
        !           856:        outw(csr0_bits, dev->base_addr + LANCE_DATA);
        !           857: }
        !           858: 
        !           859: static int
        !           860: lance_start_xmit(struct sk_buff *skb, struct device *dev)
        !           861: {
        !           862:        struct lance_private *lp = (struct lance_private *)dev->priv;
        !           863:        int ioaddr = dev->base_addr;
        !           864:        int entry;
        !           865:        unsigned long flags;
        !           866: 
        !           867:        /* Transmitter timeout, serious problems. */
        !           868:        if (dev->tbusy) {
        !           869:                int tickssofar = jiffies - dev->trans_start;
        !           870:                if (tickssofar < 20)
        !           871:                        return 1;
        !           872:                outw(0, ioaddr+LANCE_ADDR);
        !           873:                printk("%s: transmit timed out, status %4.4x, resetting.\n",
        !           874:                           dev->name, inw(ioaddr+LANCE_DATA));
        !           875:                outw(0x0004, ioaddr+LANCE_DATA);
        !           876:                lp->stats.tx_errors++;
        !           877: #ifndef final_version
        !           878:                {
        !           879:                        int i;
        !           880:                        printk(" Ring data dump: dirty_tx %d cur_tx %d%s cur_rx %d.",
        !           881:                                   lp->dirty_tx, lp->cur_tx, lp->tx_full ? " (full)" : "",
        !           882:                                   lp->cur_rx);
        !           883:                        for (i = 0 ; i < RX_RING_SIZE; i++)
        !           884:                                printk("%s %08x %04x %04x", i & 0x3 ? "" : "\n ",
        !           885:                                           lp->rx_ring[i].base, -lp->rx_ring[i].buf_length,
        !           886:                                           lp->rx_ring[i].msg_length);
        !           887:                        for (i = 0 ; i < TX_RING_SIZE; i++)
        !           888:                                printk("%s %08x %04x %04x", i & 0x3 ? "" : "\n ",
        !           889:                                           lp->tx_ring[i].base, -lp->tx_ring[i].length,
        !           890:                                           lp->tx_ring[i].misc);
        !           891:                        printk("\n");
        !           892:                }
        !           893: #endif
        !           894:                lance_restart(dev, 0x0043, 1);
        !           895: 
        !           896:                dev->tbusy=0;
        !           897:                dev->trans_start = jiffies;
        !           898: 
        !           899:                return 0;
        !           900:        }
        !           901: 
        !           902:        if (lance_debug > 3) {
        !           903:                outw(0x0000, ioaddr+LANCE_ADDR);
        !           904:                printk("%s: lance_start_xmit() called, csr0 %4.4x.\n", dev->name,
        !           905:                           inw(ioaddr+LANCE_DATA));
        !           906:                outw(0x0000, ioaddr+LANCE_DATA);
        !           907:        }
        !           908: 
        !           909:        /* Block a timer-based transmit from overlapping.  This could better be
        !           910:           done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
        !           911:        if (set_bit(0, (void*)&dev->tbusy) != 0) {
        !           912:                printk("%s: Transmitter access conflict.\n", dev->name);
        !           913:                return 1;
        !           914:        }
        !           915: 
        !           916:        if (set_bit(0, (void*)&lp->lock) != 0) {
        !           917:                if (lance_debug > 0)
        !           918:                        printk("%s: tx queue lock!.\n", dev->name);
        !           919:                /* don't clear dev->tbusy flag. */
        !           920:                return 1;
        !           921:        }
        !           922: 
        !           923:        /* Fill in a Tx ring entry */
        !           924: 
        !           925:        /* Mask to ring buffer boundary. */
        !           926:        entry = lp->cur_tx & TX_RING_MOD_MASK;
        !           927: 
        !           928:        /* Caution: the write order is important here, set the base address
        !           929:           with the "ownership" bits last. */
        !           930: 
        !           931:        /* The old LANCE chips doesn't automatically pad buffers to min. size. */
        !           932:        if (chip_table[lp->chip_version].flags & LANCE_MUST_PAD) {
        !           933:                lp->tx_ring[entry].length =
        !           934:                        -(ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
        !           935:        } else
        !           936:                lp->tx_ring[entry].length = -skb->len;
        !           937: 
        !           938:        lp->tx_ring[entry].misc = 0x0000;
        !           939: 
        !           940:        /* If any part of this buffer is >16M we must copy it to a low-memory
        !           941:           buffer. */
        !           942:        if ((u32)virt_to_bus(skb->data) + skb->len > 0x01000000) {
        !           943:                if (lance_debug > 5)
        !           944:                        printk("%s: bouncing a high-memory packet (%#x).\n",
        !           945:                                   dev->name, (u32)virt_to_bus(skb->data));
        !           946:                memcpy(&lp->tx_bounce_buffs[entry], skb->data, skb->len);
        !           947:                lp->tx_ring[entry].base =
        !           948:                        ((u32)virt_to_bus((lp->tx_bounce_buffs + entry)) & 0xffffff) | 0x83000000;
        !           949:                dev_kfree_skb (skb, FREE_WRITE);
        !           950:        } else {
        !           951:                lp->tx_skbuff[entry] = skb;
        !           952:                lp->tx_ring[entry].base = ((u32)virt_to_bus(skb->data) & 0xffffff) | 0x83000000;
        !           953:        }
        !           954:        lp->cur_tx++;
        !           955: 
        !           956:        /* Trigger an immediate send poll. */
        !           957:        outw(0x0000, ioaddr+LANCE_ADDR);
        !           958:        outw(0x0048, ioaddr+LANCE_DATA);
        !           959: 
        !           960:        dev->trans_start = jiffies;
        !           961: 
        !           962:        save_flags(flags);
        !           963:        cli();
        !           964:        lp->lock = 0;
        !           965:        if (lp->tx_ring[(entry+1) & TX_RING_MOD_MASK].base == 0)
        !           966:                dev->tbusy=0;
        !           967:        else
        !           968:                lp->tx_full = 1;
        !           969:        restore_flags(flags);
        !           970: 
        !           971:        return 0;
        !           972: }
        !           973: 
        !           974: /* The LANCE interrupt handler. */
        !           975: static void
        !           976: lance_interrupt(int irq, void *dev_id, struct pt_regs * regs)
        !           977: {
        !           978:        struct device *dev = (struct device *)dev_id;
        !           979:        struct lance_private *lp;
        !           980:        int csr0, ioaddr, boguscnt=10;
        !           981:        int must_restart;
        !           982: 
        !           983:        if (dev == NULL) {
        !           984:                printk ("lance_interrupt(): irq %d for unknown device.\n", irq);
        !           985:                return;
        !           986:        }
        !           987: 
        !           988:        ioaddr = dev->base_addr;
        !           989:        lp = (struct lance_private *)dev->priv;
        !           990:        if (dev->interrupt)
        !           991:                printk("%s: Re-entering the interrupt handler.\n", dev->name);
        !           992: 
        !           993:        dev->interrupt = 1;
        !           994: 
        !           995:        outw(0x00, dev->base_addr + LANCE_ADDR);
        !           996:        while ((csr0 = inw(dev->base_addr + LANCE_DATA)) & 0x8600
        !           997:                   && --boguscnt >= 0) {
        !           998:                /* Acknowledge all of the current interrupt sources ASAP. */
        !           999:                outw(csr0 & ~0x004f, dev->base_addr + LANCE_DATA);
        !          1000: 
        !          1001:                must_restart = 0;
        !          1002: 
        !          1003:                if (lance_debug > 5)
        !          1004:                        printk("%s: interrupt  csr0=%#2.2x new csr=%#2.2x.\n",
        !          1005:                                   dev->name, csr0, inw(dev->base_addr + LANCE_DATA));
        !          1006: 
        !          1007:                if (csr0 & 0x0400)                      /* Rx interrupt */
        !          1008:                        lance_rx(dev);
        !          1009: 
        !          1010:                if (csr0 & 0x0200) {            /* Tx-done interrupt */
        !          1011:                        int dirty_tx = lp->dirty_tx;
        !          1012: 
        !          1013:                        while (dirty_tx < lp->cur_tx) {
        !          1014:                                int entry = dirty_tx & TX_RING_MOD_MASK;
        !          1015:                                int status = lp->tx_ring[entry].base;
        !          1016:                        
        !          1017:                                if (status < 0)
        !          1018:                                        break;                  /* It still hasn't been Txed */
        !          1019: 
        !          1020:                                lp->tx_ring[entry].base = 0;
        !          1021: 
        !          1022:                                if (status & 0x40000000) {
        !          1023:                                        /* There was an major error, log it. */
        !          1024:                                        int err_status = lp->tx_ring[entry].misc;
        !          1025:                                        lp->stats.tx_errors++;
        !          1026:                                        if (err_status & 0x0400) lp->stats.tx_aborted_errors++;
        !          1027:                                        if (err_status & 0x0800) lp->stats.tx_carrier_errors++;
        !          1028:                                        if (err_status & 0x1000) lp->stats.tx_window_errors++;
        !          1029:                                        if (err_status & 0x4000) {
        !          1030:                                                /* Ackk!  On FIFO errors the Tx unit is turned off! */
        !          1031:                                                lp->stats.tx_fifo_errors++;
        !          1032:                                                /* Remove this verbosity later! */
        !          1033:                                                printk("%s: Tx FIFO error! Status %4.4x.\n",
        !          1034:                                                           dev->name, csr0);
        !          1035:                                                /* Restart the chip. */
        !          1036:                                                must_restart = 1;
        !          1037:                                        }
        !          1038:                                } else {
        !          1039:                                        if (status & 0x18000000)
        !          1040:                                                lp->stats.collisions++;
        !          1041:                                        lp->stats.tx_packets++;
        !          1042:                                }
        !          1043: 
        !          1044:                                /* We must free the original skb if it's not a data-only copy
        !          1045:                                   in the bounce buffer. */
        !          1046:                                if (lp->tx_skbuff[entry]) {
        !          1047:                                        dev_kfree_skb(lp->tx_skbuff[entry],FREE_WRITE);
        !          1048:                                        lp->tx_skbuff[entry] = 0;
        !          1049:                                }
        !          1050:                                dirty_tx++;
        !          1051:                        }
        !          1052: 
        !          1053: #ifndef final_version
        !          1054:                        if (lp->cur_tx - dirty_tx >= TX_RING_SIZE) {
        !          1055:                                printk("out-of-sync dirty pointer, %d vs. %d, full=%d.\n",
        !          1056:                                           dirty_tx, lp->cur_tx, lp->tx_full);
        !          1057:                                dirty_tx += TX_RING_SIZE;
        !          1058:                        }
        !          1059: #endif
        !          1060: 
        !          1061:                        if (lp->tx_full && dev->tbusy
        !          1062:                                && dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) {
        !          1063:                                /* The ring is no longer full, clear tbusy. */
        !          1064:                                lp->tx_full = 0;
        !          1065:                                dev->tbusy = 0;
        !          1066:                                mark_bh(NET_BH);
        !          1067:                        }
        !          1068: 
        !          1069:                        lp->dirty_tx = dirty_tx;
        !          1070:                }
        !          1071: 
        !          1072:                /* Log misc errors. */
        !          1073:                if (csr0 & 0x4000) lp->stats.tx_errors++; /* Tx babble. */
        !          1074:                if (csr0 & 0x1000) lp->stats.rx_errors++; /* Missed a Rx frame. */
        !          1075:                if (csr0 & 0x0800) {
        !          1076:                        printk("%s: Bus master arbitration failure, status %4.4x.\n",
        !          1077:                                   dev->name, csr0);
        !          1078:                        /* Restart the chip. */
        !          1079:                        must_restart = 1;
        !          1080:                }
        !          1081: 
        !          1082:                if (must_restart) {
        !          1083:                        /* stop the chip to clear the error condition, then restart */
        !          1084:                        outw(0x0000, dev->base_addr + LANCE_ADDR);
        !          1085:                        outw(0x0004, dev->base_addr + LANCE_DATA);
        !          1086:                        lance_restart(dev, 0x0002, 0);
        !          1087:                }
        !          1088:        }
        !          1089: 
        !          1090:        /* Clear any other interrupt, and set interrupt enable. */
        !          1091:        outw(0x0000, dev->base_addr + LANCE_ADDR);
        !          1092:        outw(0x7940, dev->base_addr + LANCE_DATA);
        !          1093: 
        !          1094:        if (lance_debug > 4)
        !          1095:                printk("%s: exiting interrupt, csr%d=%#4.4x.\n",
        !          1096:                           dev->name, inw(ioaddr + LANCE_ADDR),
        !          1097:                           inw(dev->base_addr + LANCE_DATA));
        !          1098: 
        !          1099:        dev->interrupt = 0;
        !          1100:        return;
        !          1101: }
        !          1102: 
        !          1103: static int
        !          1104: lance_rx(struct device *dev)
        !          1105: {
        !          1106:        struct lance_private *lp = (struct lance_private *)dev->priv;
        !          1107:        int entry = lp->cur_rx & RX_RING_MOD_MASK;
        !          1108:        int i;
        !          1109:                
        !          1110:        /* If we own the next entry, it's a new packet. Send it up. */
        !          1111:        while (lp->rx_ring[entry].base >= 0) {
        !          1112:                int status = lp->rx_ring[entry].base >> 24;
        !          1113: 
        !          1114:                if (status != 0x03) {                   /* There was an error. */
        !          1115:                        /* There is a tricky error noted by John Murphy,
        !          1116:                           <[email protected]> to Russ Nelson: Even with full-sized
        !          1117:                           buffers it's possible for a jabber packet to use two
        !          1118:                           buffers, with only the last correctly noting the error. */
        !          1119:                        if (status & 0x01)      /* Only count a general error at the */
        !          1120:                                lp->stats.rx_errors++; /* end of a packet.*/
        !          1121:                        if (status & 0x20) lp->stats.rx_frame_errors++;
        !          1122:                        if (status & 0x10) lp->stats.rx_over_errors++;
        !          1123:                        if (status & 0x08) lp->stats.rx_crc_errors++;
        !          1124:                        if (status & 0x04) lp->stats.rx_fifo_errors++;
        !          1125:                        lp->rx_ring[entry].base &= 0x03ffffff;
        !          1126:                }
        !          1127:                else 
        !          1128:                {
        !          1129:                        /* Malloc up new buffer, compatible with net3. */
        !          1130:                        short pkt_len = (lp->rx_ring[entry].msg_length & 0xfff)-4;
        !          1131:                        struct sk_buff *skb;
        !          1132:                        
        !          1133:                        if(pkt_len<60)
        !          1134:                        {
        !          1135:                                printk("%s: Runt packet!\n",dev->name);
        !          1136:                                lp->stats.rx_errors++;
        !          1137:                        }
        !          1138:                        else
        !          1139:                        {
        !          1140:                                skb = dev_alloc_skb(pkt_len+2);
        !          1141:                                if (skb == NULL) 
        !          1142:                                {
        !          1143:                                        printk("%s: Memory squeeze, deferring packet.\n", dev->name);
        !          1144:                                        for (i=0; i < RX_RING_SIZE; i++)
        !          1145:                                                if (lp->rx_ring[(entry+i) & RX_RING_MOD_MASK].base < 0)
        !          1146:                                                        break;
        !          1147: 
        !          1148:                                        if (i > RX_RING_SIZE -2) 
        !          1149:                                        {
        !          1150:                                                lp->stats.rx_dropped++;
        !          1151:                                                lp->rx_ring[entry].base |= 0x80000000;
        !          1152:                                                lp->cur_rx++;
        !          1153:                                        }
        !          1154:                                        break;
        !          1155:                                }
        !          1156:                                skb->dev = dev;
        !          1157:                                skb_reserve(skb,2);     /* 16 byte align */
        !          1158:                                skb_put(skb,pkt_len);   /* Make room */
        !          1159:                                eth_copy_and_sum(skb,
        !          1160:                                        (unsigned char *)bus_to_virt((lp->rx_ring[entry].base & 0x00ffffff)),
        !          1161:                                        pkt_len,0);
        !          1162:                                skb->protocol=eth_type_trans(skb,dev);
        !          1163:                                netif_rx(skb);
        !          1164:                                lp->stats.rx_packets++;
        !          1165:                        }
        !          1166:                }
        !          1167:                /* The docs say that the buffer length isn't touched, but Andrew Boyd
        !          1168:                   of QNX reports that some revs of the 79C965 clear it. */
        !          1169:                lp->rx_ring[entry].buf_length = -PKT_BUF_SZ;
        !          1170:                lp->rx_ring[entry].base |= 0x80000000;
        !          1171:                entry = (++lp->cur_rx) & RX_RING_MOD_MASK;
        !          1172:        }
        !          1173: 
        !          1174:        /* We should check that at least two ring entries are free.      If not,
        !          1175:           we should free one and mark stats->rx_dropped++. */
        !          1176: 
        !          1177:        return 0;
        !          1178: }
        !          1179: 
        !          1180: static int
        !          1181: lance_close(struct device *dev)
        !          1182: {
        !          1183:        int ioaddr = dev->base_addr;
        !          1184:        struct lance_private *lp = (struct lance_private *)dev->priv;
        !          1185:        int i;
        !          1186: 
        !          1187:        dev->start = 0;
        !          1188:        dev->tbusy = 1;
        !          1189: 
        !          1190:        if (chip_table[lp->chip_version].flags & LANCE_HAS_MISSED_FRAME) {
        !          1191:                outw(112, ioaddr+LANCE_ADDR);
        !          1192:                lp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
        !          1193:        }
        !          1194:        outw(0, ioaddr+LANCE_ADDR);
        !          1195: 
        !          1196:        if (lance_debug > 1)
        !          1197:                printk("%s: Shutting down ethercard, status was %2.2x.\n",
        !          1198:                           dev->name, inw(ioaddr+LANCE_DATA));
        !          1199: 
        !          1200:        /* We stop the LANCE here -- it occasionally polls
        !          1201:           memory if we don't. */
        !          1202:        outw(0x0004, ioaddr+LANCE_DATA);
        !          1203: 
        !          1204:        if (dev->dma != 4)
        !          1205:                disable_dma(dev->dma);
        !          1206: 
        !          1207:        free_irq(dev->irq, dev);
        !          1208: 
        !          1209:        /* Free all the skbuffs in the Rx and Tx queues. */
        !          1210:        for (i = 0; i < RX_RING_SIZE; i++) {
        !          1211:                struct sk_buff *skb = lp->rx_skbuff[i];
        !          1212:                lp->rx_skbuff[i] = 0;
        !          1213:                lp->rx_ring[i].base = 0;                /* Not owned by LANCE chip. */
        !          1214:                if (skb) {
        !          1215:                        skb->free = 1;
        !          1216:                        dev_kfree_skb(skb, FREE_WRITE);
        !          1217:                }
        !          1218:        }
        !          1219:        for (i = 0; i < TX_RING_SIZE; i++) {
        !          1220:                if (lp->tx_skbuff[i])
        !          1221:                        dev_kfree_skb(lp->tx_skbuff[i], FREE_WRITE);
        !          1222:                lp->tx_skbuff[i] = 0;
        !          1223:        }
        !          1224: 
        !          1225:        MOD_DEC_USE_COUNT;
        !          1226:        return 0;
        !          1227: }
        !          1228: 
        !          1229: static struct enet_statistics *
        !          1230: lance_get_stats(struct device *dev)
        !          1231: {
        !          1232:        struct lance_private *lp = (struct lance_private *)dev->priv;
        !          1233:        short ioaddr = dev->base_addr;
        !          1234:        short saved_addr;
        !          1235:        unsigned long flags;
        !          1236: 
        !          1237:        if (chip_table[lp->chip_version].flags & LANCE_HAS_MISSED_FRAME) {
        !          1238:                save_flags(flags);
        !          1239:                cli();
        !          1240:                saved_addr = inw(ioaddr+LANCE_ADDR);
        !          1241:                outw(112, ioaddr+LANCE_ADDR);
        !          1242:                lp->stats.rx_missed_errors = inw(ioaddr+LANCE_DATA);
        !          1243:                outw(saved_addr, ioaddr+LANCE_ADDR);
        !          1244:                restore_flags(flags);
        !          1245:        }
        !          1246: 
        !          1247:        return &lp->stats;
        !          1248: }
        !          1249: 
        !          1250: /* Set or clear the multicast filter for this adaptor.
        !          1251:  */
        !          1252: 
        !          1253: static void set_multicast_list(struct device *dev)
        !          1254: {
        !          1255:        short ioaddr = dev->base_addr;
        !          1256: 
        !          1257:        outw(0, ioaddr+LANCE_ADDR);
        !          1258:        outw(0x0004, ioaddr+LANCE_DATA); /* Temporarily stop the lance.  */
        !          1259: 
        !          1260:        if (dev->flags&IFF_PROMISC) {
        !          1261:                /* Log any net taps. */
        !          1262:                printk("%s: Promiscuous mode enabled.\n", dev->name);
        !          1263:                outw(15, ioaddr+LANCE_ADDR);
        !          1264:                outw(0x8000, ioaddr+LANCE_DATA); /* Set promiscuous mode */
        !          1265:        } else {
        !          1266:                short multicast_table[4];
        !          1267:                int i;
        !          1268:                int num_addrs=dev->mc_count;
        !          1269:                if(dev->flags&IFF_ALLMULTI)
        !          1270:                        num_addrs=1;
        !          1271:                /* FIXIT: We don't use the multicast table, but rely on upper-layer filtering. */
        !          1272:                memset(multicast_table, (num_addrs == 0) ? 0 : -1, sizeof(multicast_table));
        !          1273:                for (i = 0; i < 4; i++) {
        !          1274:                        outw(8 + i, ioaddr+LANCE_ADDR);
        !          1275:                        outw(multicast_table[i], ioaddr+LANCE_DATA);
        !          1276:                }
        !          1277:                outw(15, ioaddr+LANCE_ADDR);
        !          1278:                outw(0x0000, ioaddr+LANCE_DATA); /* Unset promiscuous mode */
        !          1279:        }
        !          1280: 
        !          1281:        lance_restart(dev, 0x0142, 0); /*  Resume normal operation */
        !          1282: 
        !          1283: }
        !          1284: 
        !          1285: 
        !          1286: /*
        !          1287:  * Local variables:
        !          1288:  *  compile-command: "gcc -DMODULE -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c lance.c"
        !          1289:  *  c-indent-level: 4
        !          1290:  *  c-basic-offset: 4
        !          1291:  *  tab-width: 4
        !          1292:  * End:
        !          1293:  */

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