Return to 3c515.c CVS log

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

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

1.1     ! root        1: /* 3c515.c: A 3Com ISA EtherLink XL "Corkscrew" ethernet driver for linux. */
        !             2: /*
        !             3:        Written 1997-1998 by Donald Becker.
        !             4: 
        !             5:        This software may be used and distributed according to the terms
        !             6:        of the GNU Public License, incorporated herein by reference.
        !             7: 
        !             8:        This driver is for the 3Com ISA EtherLink XL "Corkscrew" 3c515 ethercard.
        !             9: 
        !            10:        The author may be reached as [email protected], or C/O
        !            11:        Center of Excellence in Space Data and Information Sciences
        !            12:           Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
        !            13: */
        !            14: 
        !            15: static char *version = "3c515.c:v0.99 4/7/98 [email protected]\n";
        !            16: #define CORKSCREW 1
        !            17: 
        !            18: /* "Knobs" that adjust features and parameters. */
        !            19: /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
        !            20:    Setting to > 1512 effectively disables this feature. */
        !            21: static const int rx_copybreak = 200;
        !            22: /* Allow setting MTU to a larger size, bypassing the normal ethernet setup. */
        !            23: static const int mtu = 1500;
        !            24: /* Maximum events (Rx packets, etc.) to handle at each interrupt. */
        !            25: static int max_interrupt_work = 20;
        !            26: 
        !            27: /* Enable the automatic media selection code -- usually set. */
        !            28: #define AUTOMEDIA 1
        !            29: 
        !            30: /* Allow the use of fragment bus master transfers instead of only
        !            31:    programmed-I/O for Vortex cards.  Full-bus-master transfers are always
        !            32:    enabled by default on Boomerang cards.  If VORTEX_BUS_MASTER is defined,
        !            33:    the feature may be turned on using 'options'. */
        !            34: #define VORTEX_BUS_MASTER
        !            35: 
        !            36: /* A few values that may be tweaked. */
        !            37: /* Keep the ring sizes a power of two for efficiency. */
        !            38: #define TX_RING_SIZE   16
        !            39: #define RX_RING_SIZE   16
        !            40: #define PKT_BUF_SZ             1536                    /* Size of each temporary Rx buffer.*/
        !            41: 
        !            42: #ifdef MODULE
        !            43: #ifdef MODVERSIONS
        !            44: #include <linux/modversions.h>
        !            45: #endif
        !            46: #include <linux/module.h>
        !            47: #include <linux/version.h>
        !            48: #else
        !            49: #define MOD_INC_USE_COUNT
        !            50: #define MOD_DEC_USE_COUNT
        !            51: #endif
        !            52: 
        !            53: #include <linux/kernel.h>
        !            54: #include <linux/sched.h>
        !            55: #include <linux/string.h>
        !            56: #include <linux/ptrace.h>
        !            57: #include <linux/errno.h>
        !            58: #include <linux/in.h>
        !            59: #include <linux/ioport.h>
        !            60: #include <linux/malloc.h>
        !            61: #include <linux/interrupt.h>
        !            62: #include <linux/pci.h>
        !            63: #include <linux/bios32.h>
        !            64: #include <linux/timer.h>
        !            65: #include <asm/bitops.h>
        !            66: #include <asm/io.h>
        !            67: #include <asm/dma.h>
        !            68: 
        !            69: #include <linux/netdevice.h>
        !            70: #include <linux/etherdevice.h>
        !            71: #include <linux/skbuff.h>
        !            72: #if (LINUX_VERSION_CODE >= 0x10344)
        !            73: #define NEW_MULTICAST
        !            74: #include <linux/delay.h>
        !            75: #else
        !            76: #define udelay(microsec)       do { int _i = 4*microsec; while (--_i > 0) { __SLOW_DOWN_IO; }} while (0)
        !            77: #endif
        !            78: 
        !            79: /* Kernel version compatibility functions. */
        !            80: #define RUN_AT(x) (jiffies + (x))
        !            81: #define DEV_ALLOC_SKB(len) dev_alloc_skb(len + 2)
        !            82: 
        !            83: #define FREE_IRQ(irqnum, dev) free_irq(irqnum, dev)
        !            84: #define REQUEST_IRQ(i,h,f,n, instance) request_irq(i,h,f,n, instance)
        !            85: #define IRQ(irq, dev_id, pt_regs) (irq, dev_id, pt_regs)
        !            86: 
        !            87: #if (LINUX_VERSION_CODE < 0x20123)
        !            88: #define test_and_set_bit(val, addr) set_bit(val, addr)
        !            89: #elif defined(MODULE)
        !            90: MODULE_AUTHOR("Donald Becker <[email protected]>");
        !            91: MODULE_DESCRIPTION("3Com 3c515 Corkscrew driver");
        !            92: MODULE_PARM(debug, "i");
        !            93: MODULE_PARM(options, "1-" __MODULE_STRING(8) "i");
        !            94: MODULE_PARM(full_duplex, "1-" __MODULE_STRING(8) "i");
        !            95: MODULE_PARM(rx_copybreak, "i");
        !            96: MODULE_PARM(max_interrupt_work, "i");
        !            97: #endif
        !            98: 
        !            99: /* "Knobs" for adjusting internal parameters. */
        !           100: /* Put out somewhat more debugging messages. (0 - no msg, 1 minimal msgs). */
        !           101: #define DRIVER_DEBUG 1
        !           102: /* Some values here only for performance evaluation and path-coverage
        !           103:    debugging. */
        !           104: static int rx_nocopy = 0, rx_copy = 0, queued_packet = 0;
        !           105: 
        !           106: /* Number of times to check to see if the Tx FIFO has space, used in some
        !           107:    limited cases. */
        !           108: #define WAIT_TX_AVAIL 200
        !           109: 
        !           110: /* Operational parameter that usually are not changed. */
        !           111: #define TX_TIMEOUT  40         /* Time in jiffies before concluding Tx hung */
        !           112: 
        !           113: /* The size here is somewhat misleading: the Corkscrew also uses the ISA
        !           114:    aliased registers at <base>+0x400.
        !           115:    */
        !           116: #define CORKSCREW_TOTAL_SIZE 0x20
        !           117: 
        !           118: #ifdef HAVE_DEVLIST
        !           119: struct netdev_entry tc515_drv =
        !           120: {"3c515", tc515_probe, CORKSCREW_TOTAL_SIZE, NULL};
        !           121: #endif
        !           122: 
        !           123: #ifdef DRIVER_DEBUG
        !           124: int vortex_debug = DRIVER_DEBUG;
        !           125: #else
        !           126: int vortex_debug = 1;
        !           127: #endif
        !           128: 
        !           129: #define CORKSCREW_ID 10
        !           130: 
        !           131: /*
        !           132:                                Theory of Operation
        !           133: 
        !           134: I. Board Compatibility
        !           135: 
        !           136: This device driver is designed for the 3Com 3c515 ISA Fast EtherLink XL,
        !           137: 3Com's ISA bus adapter for Fast Ethernet.  Due to the unique I/O port layout,
        !           138: it's not practical to integrate this driver with the other EtherLink drivers.
        !           139: 
        !           140: II. Board-specific settings
        !           141: 
        !           142: The Corkscrew has an EEPROM for configuration, but no special settings are
        !           143: needed for Linux.
        !           144: 
        !           145: III. Driver operation
        !           146: 
        !           147: The 3c515 series use an interface that's very similar to the 3c900 "Boomerang"
        !           148: PCI cards, with the bus master interface extensively modified to work with
        !           149: the ISA bus.
        !           150: 
        !           151: The card is capable of full-bus-master transfers with separate
        !           152: lists of transmit and receive descriptors, similar to the AMD LANCE/PCnet,
        !           153: DEC Tulip and Intel Speedo3.
        !           154: 
        !           155: This driver uses a "RX_COPYBREAK" scheme rather than a fixed intermediate
        !           156: receive buffer.  This scheme allocates full-sized skbuffs as receive
        !           157: buffers.  The value RX_COPYBREAK is used as the copying breakpoint: it is
        !           158: chosen to trade-off the memory wasted by passing the full-sized skbuff to
        !           159: the queue layer for all frames vs. the copying cost of copying a frame to a
        !           160: correctly-sized skbuff.
        !           161: 
        !           162: 
        !           163: IIIC. Synchronization
        !           164: The driver runs as two independent, single-threaded flows of control.  One
        !           165: is the send-packet routine, which enforces single-threaded use by the
        !           166: dev->tbusy flag.  The other thread is the interrupt handler, which is single
        !           167: threaded by the hardware and other software.
        !           168: 
        !           169: IV. Notes
        !           170: 
        !           171: Thanks to Terry Murphy of 3Com for providing documentation and a development
        !           172: board.
        !           173: 
        !           174: The names "Vortex", "Boomerang" and "Corkscrew" are the internal 3Com
        !           175: project names.  I use these names to eliminate confusion -- 3Com product
        !           176: numbers and names are very similar and often confused.
        !           177: 
        !           178: The new chips support both ethernet (1.5K) and FDDI (4.5K) frame sizes!
        !           179: This driver only supports ethernet frames because of the recent MTU limit
        !           180: of 1.5K, but the changes to support 4.5K are minimal.
        !           181: */
        !           182: 
        !           183: /* Operational definitions.
        !           184:    These are not used by other compilation units and thus are not
        !           185:    exported in a ".h" file.
        !           186: 
        !           187:    First the windows.  There are eight register windows, with the command
        !           188:    and status registers available in each.
        !           189:    */
        !           190: #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
        !           191: #define EL3_CMD 0x0e
        !           192: #define EL3_STATUS 0x0e
        !           193: 
        !           194: /* The top five bits written to EL3_CMD are a command, the lower
        !           195:    11 bits are the parameter, if applicable.
        !           196:    Note that 11 parameters bits was fine for ethernet, but the new chips
        !           197:    can handle FDDI length frames (~4500 octets) and now parameters count
        !           198:    32-bit 'Dwords' rather than octets. */
        !           199: 
        !           200: enum vortex_cmd {
        !           201:        TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
        !           202:        RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11,
        !           203:        UpStall = 6<<11, UpUnstall = (6<<11)+1,
        !           204:        DownStall = (6<<11)+2, DownUnstall = (6<<11)+3,
        !           205:        RxDiscard = 8<<11, TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
        !           206:        FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrEnb = 14<<11,
        !           207:        SetStatusEnb = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
        !           208:        SetTxThreshold = 18<<11, SetTxStart = 19<<11,
        !           209:        StartDMAUp = 20<<11, StartDMADown = (20<<11)+1, StatsEnable = 21<<11,
        !           210:        StatsDisable = 22<<11, StopCoax = 23<<11,};
        !           211: 
        !           212: /* The SetRxFilter command accepts the following classes: */
        !           213: enum RxFilter {
        !           214:        RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
        !           215: 
        !           216: /* Bits in the general status register. */
        !           217: enum vortex_status {
        !           218:        IntLatch = 0x0001, AdapterFailure = 0x0002, TxComplete = 0x0004,
        !           219:        TxAvailable = 0x0008, RxComplete = 0x0010, RxEarly = 0x0020,
        !           220:        IntReq = 0x0040, StatsFull = 0x0080,
        !           221:        DMADone = 1<<8, DownComplete = 1<<9, UpComplete = 1<<10,
        !           222:        DMAInProgress = 1<<11,                  /* DMA controller is still busy.*/
        !           223:        CmdInProgress = 1<<12,                  /* EL3_CMD is still busy.*/
        !           224: };
        !           225: 
        !           226: /* Register window 1 offsets, the window used in normal operation.
        !           227:    On the Corkscrew this window is always mapped at offsets 0x10-0x1f. */
        !           228: enum Window1 {
        !           229:        TX_FIFO = 0x10,  RX_FIFO = 0x10,  RxErrors = 0x14,
        !           230:        RxStatus = 0x18,  Timer=0x1A, TxStatus = 0x1B,
        !           231:        TxFree = 0x1C, /* Remaining free bytes in Tx buffer. */
        !           232: };
        !           233: enum Window0 {
        !           234:   Wn0IRQ = 0x08,
        !           235: #if defined(CORKSCREW)
        !           236:        Wn0EepromCmd = 0x200A,          /* Corkscrew EEPROM command register. */
        !           237:        Wn0EepromData = 0x200C,         /* Corkscrew EEPROM results register. */
        !           238: #else
        !           239:        Wn0EepromCmd = 10,              /* Window 0: EEPROM command register. */
        !           240:        Wn0EepromData = 12,             /* Window 0: EEPROM results register. */
        !           241: #endif
        !           242: };
        !           243: enum Win0_EEPROM_bits {
        !           244:        EEPROM_Read = 0x80, EEPROM_WRITE = 0x40, EEPROM_ERASE = 0xC0,
        !           245:        EEPROM_EWENB = 0x30,            /* Enable erasing/writing for 10 msec. */
        !           246:        EEPROM_EWDIS = 0x00,            /* Disable EWENB before 10 msec timeout. */
        !           247: };
        !           248: /* EEPROM locations. */
        !           249: enum eeprom_offset {
        !           250:        PhysAddr01=0, PhysAddr23=1, PhysAddr45=2, ModelID=3,
        !           251:        EtherLink3ID=7, };
        !           252: 
        !           253: enum Window3 {                 /* Window 3: MAC/config bits. */
        !           254:        Wn3_Config=0, Wn3_MAC_Ctrl=6, Wn3_Options=8,
        !           255: };
        !           256: union wn3_config {
        !           257:        int i;
        !           258:        struct w3_config_fields {
        !           259:                unsigned int ram_size:3, ram_width:1, ram_speed:2, rom_size:2;
        !           260:                int pad8:8;
        !           261:                unsigned int ram_split:2, pad18:2, xcvr:3, pad21:1, autoselect:1;
        !           262:                int pad24:7;
        !           263:        } u;
        !           264: };
        !           265: 
        !           266: enum Window4 {
        !           267:        Wn4_NetDiag = 6, Wn4_Media = 10,                /* Window 4: Xcvr/media bits. */
        !           268: };
        !           269: enum Win4_Media_bits {
        !           270:        Media_SQE = 0x0008,             /* Enable SQE error counting for AUI. */
        !           271:        Media_10TP = 0x00C0,    /* Enable link beat and jabber for 10baseT. */
        !           272:        Media_Lnk = 0x0080,             /* Enable just link beat for 100TX/100FX. */
        !           273:        Media_LnkBeat = 0x0800,
        !           274: };
        !           275: enum Window7 {                                 /* Window 7: Bus Master control. */
        !           276:        Wn7_MasterAddr = 0, Wn7_MasterLen = 6, Wn7_MasterStatus = 12,
        !           277: };
        !           278: /* Boomerang-style bus master control registers.  Note ISA aliases! */
        !           279: enum MasterCtrl {
        !           280:        PktStatus = 0x400, DownListPtr = 0x404, FragAddr = 0x408, FragLen = 0x40c,
        !           281:        TxFreeThreshold = 0x40f, UpPktStatus = 0x410, UpListPtr = 0x418,
        !           282: };
        !           283: 
        !           284: /* The Rx and Tx descriptor lists.
        !           285:    Caution Alpha hackers: these types are 32 bits!  Note also the 8 byte
        !           286:    alignment contraint on tx_ring[] and rx_ring[]. */
        !           287: struct boom_rx_desc {
        !           288:        u32 next;
        !           289:        s32 status;
        !           290:        u32 addr;
        !           291:        s32 length;
        !           292: };
        !           293: /* Values for the Rx status entry. */
        !           294: enum rx_desc_status {
        !           295:        RxDComplete=0x00008000, RxDError=0x4000,
        !           296:        /* See boomerang_rx() for actual error bits */
        !           297: };
        !           298: 
        !           299: struct boom_tx_desc {
        !           300:        u32 next;
        !           301:        s32 status;
        !           302:        u32 addr;
        !           303:        s32 length;
        !           304: };
        !           305: 
        !           306: struct vortex_private {
        !           307:        char devname[8];                        /* "ethN" string, also for kernel debug. */
        !           308:        const char *product_name;
        !           309:        struct device *next_module;
        !           310:        /* The Rx and Tx rings are here to keep them quad-word-aligned. */
        !           311:        struct boom_rx_desc rx_ring[RX_RING_SIZE];
        !           312:        struct boom_tx_desc tx_ring[TX_RING_SIZE];
        !           313:        /* The addresses of transmit- and receive-in-place skbuffs. */
        !           314:        struct sk_buff* rx_skbuff[RX_RING_SIZE];
        !           315:        struct sk_buff* tx_skbuff[TX_RING_SIZE];
        !           316:        unsigned int cur_rx, cur_tx;            /* The next free ring entry */
        !           317:        unsigned int dirty_rx, dirty_tx;        /* The ring entries to be free()ed. */
        !           318:        struct enet_statistics stats;
        !           319:        struct sk_buff *tx_skb;         /* Packet being eaten by bus master ctrl.  */
        !           320:        struct timer_list timer;        /* Media selection timer. */
        !           321:        int capabilities;                       /* Adapter capabilities word. */
        !           322:        int options;                            /* User-settable misc. driver options. */
        !           323:        int last_rx_packets;            /* For media autoselection. */
        !           324:        unsigned int available_media:8, /* From Wn3_Options */
        !           325:          media_override:3,                     /* Passed-in media type. */
        !           326:          default_media:3,                      /* Read from the EEPROM. */
        !           327:          full_duplex:1, autoselect:1,
        !           328:          bus_master:1,                         /* Vortex can only do a fragment bus-m. */
        !           329:          full_bus_master_tx:1, full_bus_master_rx:1, /* Boomerang  */
        !           330:       tx_full:1;
        !           331: };
        !           332: 
        !           333: /* The action to take with a media selection timer tick.
        !           334:    Note that we deviate from the 3Com order by checking 10base2 before AUI.
        !           335:  */
        !           336: enum xcvr_types {
        !           337:        XCVR_10baseT=0, XCVR_AUI, XCVR_10baseTOnly, XCVR_10base2, XCVR_100baseTx,
        !           338:        XCVR_100baseFx, XCVR_MII=6, XCVR_Default=8,
        !           339: };
        !           340: 
        !           341: static struct media_table {
        !           342:   char *name;
        !           343:   unsigned int media_bits:16,          /* Bits to set in Wn4_Media register. */
        !           344:        mask:8,                         /* The transceiver-present bit in Wn3_Config.*/
        !           345:        next:8;                         /* The media type to try next. */
        !           346:   short wait;                  /* Time before we check media status. */
        !           347: } media_tbl[] = {
        !           348:   {    "10baseT",   Media_10TP,0x08, XCVR_10base2, (14*HZ)/10},
        !           349:   { "10Mbs AUI", Media_SQE, 0x20, XCVR_Default, (1*HZ)/10},
        !           350:   { "undefined", 0,                    0x80, XCVR_10baseT, 10000},
        !           351:   { "10base2",   0,                    0x10, XCVR_AUI,         (1*HZ)/10},
        !           352:   { "100baseTX", Media_Lnk, 0x02, XCVR_100baseFx, (14*HZ)/10},
        !           353:   { "100baseFX", Media_Lnk, 0x04, XCVR_MII,            (14*HZ)/10},
        !           354:   { "MII",              0,                     0x40, XCVR_10baseT, 3*HZ },
        !           355:   { "undefined", 0,                    0x01, XCVR_10baseT, 10000},
        !           356:   { "Default",  0,                     0xFF, XCVR_10baseT, 10000},
        !           357: };
        !           358: 
        !           359: static int vortex_scan(struct device *dev);
        !           360: static struct device *vortex_found_device(struct device *dev, int ioaddr,
        !           361:                                                                                  int irq, int product_index,
        !           362:                                                                                  int options);
        !           363: static int vortex_probe1(struct device *dev);
        !           364: static int vortex_open(struct device *dev);
        !           365: static void vortex_timer(unsigned long arg);
        !           366: static int vortex_start_xmit(struct sk_buff *skb, struct device *dev);
        !           367: static int vortex_rx(struct device *dev);
        !           368: static int boomerang_rx(struct device *dev);
        !           369: static void vortex_interrupt IRQ(int irq, void *dev_id, struct pt_regs *regs);
        !           370: static int vortex_close(struct device *dev);
        !           371: static void update_stats(int addr, struct device *dev);
        !           372: static struct enet_statistics *vortex_get_stats(struct device *dev);
        !           373: static void set_rx_mode(struct device *dev);
        !           374: 
        !           375: 
        !           376: /* Unlike the other PCI cards the 59x cards don't need a large contiguous
        !           377:    memory region, so making the driver a loadable module is feasible.
        !           378: 
        !           379:    Unfortunately maximizing the shared code between the integrated and
        !           380:    module version of the driver results in a complicated set of initialization
        !           381:    procedures.
        !           382:    init_module() -- modules /  tc59x_init()  -- built-in
        !           383:                The wrappers for vortex_scan()
        !           384:    vortex_scan()                The common routine that scans for PCI and EISA cards
        !           385:    vortex_found_device() Allocate a device structure when we find a card.
        !           386:                                        Different versions exist for modules and built-in.
        !           387:    vortex_probe1()             Fill in the device structure -- this is separated
        !           388:                                        so that the modules code can put it in dev->init.
        !           389: */
        !           390: /* This driver uses 'options' to pass the media type, full-duplex flag, etc. */
        !           391: /* Note: this is the only limit on the number of cards supported!! */
        !           392: static int options[8] = { -1, -1, -1, -1, -1, -1, -1, -1,};
        !           393: 
        !           394: #ifdef MODULE
        !           395: static int debug = -1;
        !           396: /* A list of all installed Vortex devices, for removing the driver module. */
        !           397: static struct device *root_vortex_dev = NULL;
        !           398: 
        !           399: int
        !           400: init_module(void)
        !           401: {
        !           402:        int cards_found;
        !           403: 
        !           404:        if (debug >= 0)
        !           405:                vortex_debug = debug;
        !           406:        if (vortex_debug)
        !           407:                printk(version);
        !           408: 
        !           409:        root_vortex_dev = NULL;
        !           410:        cards_found = vortex_scan(0);
        !           411:        return cards_found ? 0 : -ENODEV;
        !           412: }
        !           413: 
        !           414: #else
        !           415: int tc515_probe(struct device *dev)
        !           416: {
        !           417:        int cards_found = 0;
        !           418: 
        !           419:        cards_found = vortex_scan(dev);
        !           420: 
        !           421:        if (vortex_debug > 0  &&  cards_found)
        !           422:                printk(version);
        !           423: 
        !           424:        return cards_found ? 0 : -ENODEV;
        !           425: }
        !           426: #endif  /* not MODULE */
        !           427: 
        !           428: static int vortex_scan(struct device *dev)
        !           429: {
        !           430:        int cards_found = 0;
        !           431:        static int ioaddr = 0x100;
        !           432: 
        !           433:        /* Check all locations on the ISA bus -- evil! */
        !           434:        for (; ioaddr < 0x400; ioaddr += 0x20) {
        !           435:          int irq;
        !           436:          if (check_region(ioaddr, CORKSCREW_TOTAL_SIZE))
        !           437:                continue;
        !           438:          /* Check the resource configuration for a matching ioaddr. */
        !           439:          if ((inw(ioaddr + 0x2002) & 0x1f0) != (ioaddr & 0x1f0))
        !           440:                continue;
        !           441:          /* Verify by reading the device ID from the EEPROM. */
        !           442:          {
        !           443:                int timer;
        !           444:                outw(EEPROM_Read + 7, ioaddr + Wn0EepromCmd);
        !           445:                /* Pause for at least 162 us. for the read to take place. */
        !           446:                for (timer = 4; timer >= 0; timer--) {
        !           447:                  udelay(162);
        !           448:                  if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
        !           449:                        break;
        !           450:                }
        !           451:                if (inw(ioaddr + Wn0EepromData) != 0x6d50)
        !           452:                  continue;
        !           453:          }
        !           454:          printk("3c515 Resource configuraiton register %#4.4x, DCR %4.4x.\n",
        !           455:                         inl(ioaddr + 0x2002), inw(ioaddr + 0x2000));
        !           456:          irq = inw(ioaddr + 0x2002) & 15;
        !           457:          vortex_found_device(dev, ioaddr, irq, CORKSCREW_ID, dev && dev->mem_start
        !           458:                                                  ? dev->mem_start : options[cards_found]);
        !           459:          dev = 0;
        !           460:          cards_found++;
        !           461:        }
        !           462: 
        !           463:        if (vortex_debug)
        !           464:          printk("%d 3c515 cards found.\n", cards_found);
        !           465:        return cards_found;
        !           466: }
        !           467: 
        !           468: static struct device *vortex_found_device(struct device *dev, int ioaddr,
        !           469:                                                                                  int irq, int product_index,
        !           470:                                                                                  int options)
        !           471: {
        !           472:        struct vortex_private *vp;
        !           473: 
        !           474: #ifdef MODULE
        !           475:        /* Allocate and fill new device structure. */
        !           476:        int dev_size = sizeof(struct device) +
        !           477:                sizeof(struct vortex_private) + 15;             /* Pad for alignment */
        !           478:        
        !           479:        dev = (struct device *) kmalloc(dev_size, GFP_KERNEL);
        !           480:        memset(dev, 0, dev_size);
        !           481:        /* Align the Rx and Tx ring entries.  */
        !           482:        dev->priv = (void *)(((long)dev + sizeof(struct device) + 15) & ~15);
        !           483:        vp = (struct vortex_private *)dev->priv;
        !           484:        dev->name = vp->devname; /* An empty string. */
        !           485:        dev->base_addr = ioaddr;
        !           486:        dev->irq = irq;
        !           487:        dev->dma = (product_index == CORKSCREW_ID ? inw(ioaddr + 0x2000) & 7 : 0);
        !           488:        dev->init = vortex_probe1;
        !           489:        vp->product_name = "3c515";
        !           490:        vp->options = options;
        !           491:        if (options >= 0) {
        !           492:                vp->media_override = ((options & 7) == 2)  ?  0  :  options & 7;
        !           493:                vp->full_duplex = (options & 8) ? 1 : 0;
        !           494:                vp->bus_master = (options & 16) ? 1 : 0;
        !           495:        } else {
        !           496:                vp->media_override = 7;
        !           497:                vp->full_duplex = 0;
        !           498:                vp->bus_master = 0;
        !           499:        }
        !           500:        ether_setup(dev);
        !           501:        vp->next_module = root_vortex_dev;
        !           502:        root_vortex_dev = dev;
        !           503:        if (register_netdev(dev) != 0)
        !           504:                return 0;
        !           505: #else  /* not a MODULE */
        !           506:        if (dev) {
        !           507:                /* Caution: quad-word alignment required for rings! */
        !           508:                dev->priv = kmalloc(sizeof (struct vortex_private), GFP_KERNEL);
        !           509:                memset(dev->priv, 0, sizeof (struct vortex_private));
        !           510:        }
        !           511:        dev = init_etherdev(dev, sizeof(struct vortex_private));
        !           512:        dev->base_addr = ioaddr;
        !           513:        dev->irq = irq;
        !           514:        dev->dma = (product_index == CORKSCREW_ID ? inw(ioaddr + 0x2000) & 7 : 0);
        !           515:        vp  = (struct vortex_private *)dev->priv;
        !           516:        vp->product_name = "3c515";
        !           517:        vp->options = options;
        !           518:        if (options >= 0) {
        !           519:                vp->media_override = ((options & 7) == 2)  ?  0  :  options & 7;
        !           520:                vp->full_duplex = (options & 8) ? 1 : 0;
        !           521:                vp->bus_master = (options & 16) ? 1 : 0;
        !           522:        } else {
        !           523:                vp->media_override = 7;
        !           524:                vp->full_duplex = 0;
        !           525:                vp->bus_master = 0;
        !           526:        }
        !           527: 
        !           528:        vortex_probe1(dev);
        !           529: #endif /* MODULE */
        !           530:        return dev;
        !           531: }
        !           532: 
        !           533: static int vortex_probe1(struct device *dev)
        !           534: {
        !           535:        int ioaddr = dev->base_addr;
        !           536:        struct vortex_private *vp = (struct vortex_private *)dev->priv;
        !           537:        unsigned int eeprom[0x40], checksum = 0;                /* EEPROM contents */
        !           538:        int i;
        !           539: 
        !           540:        printk("%s: 3Com %s at %#3x,", dev->name,
        !           541:                   vp->product_name, ioaddr);
        !           542: 
        !           543:        /* Read the station address from the EEPROM. */
        !           544:        EL3WINDOW(0);
        !           545:        for (i = 0; i < 0x18; i++) {
        !           546:                short *phys_addr = (short *)dev->dev_addr;
        !           547:                int timer;
        !           548:                outw(EEPROM_Read + i, ioaddr + Wn0EepromCmd);
        !           549:                /* Pause for at least 162 us. for the read to take place. */
        !           550:                for (timer = 4; timer >= 0; timer--) {
        !           551:                        udelay(162);
        !           552:                        if ((inw(ioaddr + Wn0EepromCmd) & 0x0200) == 0)
        !           553:                                break;
        !           554:                }
        !           555:                eeprom[i] = inw(ioaddr + Wn0EepromData);
        !           556:                checksum ^= eeprom[i];
        !           557:                if (i < 3)
        !           558:                        phys_addr[i] = htons(eeprom[i]);
        !           559:        }
        !           560:        checksum = (checksum ^ (checksum >> 8)) & 0xff;
        !           561:        if (checksum != 0x00)
        !           562:                printk(" ***INVALID CHECKSUM %4.4x*** ", checksum);
        !           563:        for (i = 0; i < 6; i++)
        !           564:                printk("%c%2.2x", i ? ':' : ' ', dev->dev_addr[i]);
        !           565:        if (eeprom[16] == 0x11c7) {             /* Corkscrew */
        !           566:          if (request_dma(dev->dma, "3c515")) {
        !           567:                printk(", DMA %d allocation failed", dev->dma);
        !           568:                dev->dma = 0;
        !           569:          } else 
        !           570:                printk(", DMA %d", dev->dma);
        !           571:        }
        !           572:        printk(", IRQ %d\n", dev->irq);
        !           573:        /* Tell them about an invalid IRQ. */
        !           574:        if (vortex_debug && (dev->irq <= 0 || dev->irq > 15))
        !           575:                printk(" *** Warning: this IRQ is unlikely to work! ***\n");
        !           576: 
        !           577:        {
        !           578:                char *ram_split[] = {"5:3", "3:1", "1:1", "3:5"};
        !           579:                union wn3_config config;
        !           580:                EL3WINDOW(3);
        !           581:                vp->available_media = inw(ioaddr + Wn3_Options);
        !           582:                config.i = inl(ioaddr + Wn3_Config);
        !           583:                if (vortex_debug > 1)
        !           584:                        printk("  Internal config register is %4.4x, transceivers %#x.\n",
        !           585:                                   config.i, inw(ioaddr + Wn3_Options));
        !           586:                printk("  %dK %s-wide RAM %s Rx:Tx split, %s%s interface.\n",
        !           587:                           8 << config.u.ram_size,
        !           588:                           config.u.ram_width ? "word" : "byte",
        !           589:                           ram_split[config.u.ram_split],
        !           590:                           config.u.autoselect ? "autoselect/" : "",
        !           591:                           media_tbl[config.u.xcvr].name);
        !           592:                dev->if_port = config.u.xcvr;
        !           593:                vp->default_media = config.u.xcvr;
        !           594:                vp->autoselect = config.u.autoselect;
        !           595:        }
        !           596:        if (vp->media_override != 7) {
        !           597:                printk("  Media override to transceiver type %d (%s).\n",
        !           598:                           vp->media_override, media_tbl[vp->media_override].name);
        !           599:                dev->if_port = vp->media_override;
        !           600:        }
        !           601: 
        !           602:        vp->capabilities = eeprom[16];
        !           603:        vp->full_bus_master_tx = (vp->capabilities & 0x20) ? 1 : 0;
        !           604:        /* Rx is broken at 10mbps, so we always disable it. */
        !           605:        /* vp->full_bus_master_rx = 0;*/
        !           606:        vp->full_bus_master_rx = (vp->capabilities & 0x20) ? 1 : 0;
        !           607: 
        !           608:        /* We do a request_region() to register /proc/ioports info. */
        !           609:        request_region(ioaddr, CORKSCREW_TOTAL_SIZE, vp->product_name);
        !           610: 
        !           611:        /* The 3c59x-specific entries in the device structure. */
        !           612:        dev->open = &vortex_open;
        !           613:        dev->hard_start_xmit = &vortex_start_xmit;
        !           614:        dev->stop = &vortex_close;
        !           615:        dev->get_stats = &vortex_get_stats;
        !           616:        dev->set_multicast_list = &set_rx_mode;
        !           617: 
        !           618:        return 0;
        !           619: }
        !           620: 
        !           621: 
        !           622: static int
        !           623: vortex_open(struct device *dev)
        !           624: {
        !           625:        int ioaddr = dev->base_addr;
        !           626:        struct vortex_private *vp = (struct vortex_private *)dev->priv;
        !           627:        union wn3_config config;
        !           628:        int i;
        !           629: 
        !           630:        /* Before initializing select the active media port. */
        !           631:        EL3WINDOW(3);
        !           632:        if (vp->full_duplex)
        !           633:                outb(0x20, ioaddr + Wn3_MAC_Ctrl); /* Set the full-duplex bit. */
        !           634:        config.i = inl(ioaddr + Wn3_Config);
        !           635: 
        !           636:        if (vp->media_override != 7) {
        !           637:                if (vortex_debug > 1)
        !           638:                        printk("%s: Media override to transceiver %d (%s).\n",
        !           639:                                   dev->name, vp->media_override,
        !           640:                                   media_tbl[vp->media_override].name);
        !           641:                dev->if_port = vp->media_override;
        !           642:        } else if (vp->autoselect) {
        !           643:                /* Find first available media type, starting with 100baseTx. */
        !           644:                dev->if_port = 4;
        !           645:                while (! (vp->available_media & media_tbl[dev->if_port].mask))
        !           646:                        dev->if_port = media_tbl[dev->if_port].next;
        !           647: 
        !           648:                if (vortex_debug > 1)
        !           649:                        printk("%s: Initial media type %s.\n",
        !           650:                                   dev->name, media_tbl[dev->if_port].name);
        !           651: 
        !           652:                init_timer(&vp->timer);
        !           653:                vp->timer.expires = RUN_AT(media_tbl[dev->if_port].wait);
        !           654:                vp->timer.data = (unsigned long)dev;
        !           655:                vp->timer.function = &vortex_timer;    /* timer handler */
        !           656:                add_timer(&vp->timer);
        !           657:        } else
        !           658:                dev->if_port = vp->default_media;
        !           659: 
        !           660:        config.u.xcvr = dev->if_port;
        !           661:        outl(config.i, ioaddr + Wn3_Config);
        !           662: 
        !           663:        if (vortex_debug > 1) {
        !           664:                printk("%s: vortex_open() InternalConfig %8.8x.\n",
        !           665:                        dev->name, config.i);
        !           666:        }
        !           667: 
        !           668:        outw(TxReset, ioaddr + EL3_CMD);
        !           669:        for (i = 20; i >= 0 ; i--)
        !           670:                if ( ! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
        !           671:                        break;
        !           672: 
        !           673:        outw(RxReset, ioaddr + EL3_CMD);
        !           674:        /* Wait a few ticks for the RxReset command to complete. */
        !           675:        for (i = 20; i >= 0 ; i--)
        !           676:                if ( ! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
        !           677:                        break;
        !           678: 
        !           679:        outw(SetStatusEnb | 0x00, ioaddr + EL3_CMD);
        !           680: 
        !           681:        /* Use the now-standard shared IRQ implementation. */
        !           682:        if (vp->capabilities == 0x11c7) {
        !           683:          /* Corkscrew: Cannot share ISA resources. */
        !           684:          if (dev->irq == 0
        !           685:                  || dev->dma == 0
        !           686:                  || request_irq(dev->irq, &vortex_interrupt, 0,
        !           687:                                                 vp->product_name, dev))
        !           688:                return -EAGAIN;
        !           689:          enable_dma(dev->dma);
        !           690:          set_dma_mode(dev->dma, DMA_MODE_CASCADE);
        !           691:        } else if (request_irq(dev->irq, &vortex_interrupt, SA_SHIRQ,
        !           692:                                                   vp->product_name, dev)) {
        !           693:          return -EAGAIN;
        !           694:        }
        !           695: 
        !           696:        if (vortex_debug > 1) {
        !           697:                EL3WINDOW(4);
        !           698:                printk("%s: vortex_open() irq %d media status %4.4x.\n",
        !           699:                           dev->name, dev->irq, inw(ioaddr + Wn4_Media));
        !           700:        }
        !           701: 
        !           702:        /* Set the station address and mask in window 2 each time opened. */
        !           703:        EL3WINDOW(2);
        !           704:        for (i = 0; i < 6; i++)
        !           705:                outb(dev->dev_addr[i], ioaddr + i);
        !           706:        for (; i < 12; i+=2)
        !           707:                outw(0, ioaddr + i);
        !           708: 
        !           709:        if (dev->if_port == 3)
        !           710:                /* Start the thinnet transceiver. We should really wait 50ms...*/
        !           711:                outw(StartCoax, ioaddr + EL3_CMD);
        !           712:        EL3WINDOW(4);
        !           713:        outw((inw(ioaddr + Wn4_Media) & ~(Media_10TP|Media_SQE)) |
        !           714:                 media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
        !           715: 
        !           716:        /* Switch to the stats window, and clear all stats by reading. */
        !           717:        outw(StatsDisable, ioaddr + EL3_CMD);
        !           718:        EL3WINDOW(6);
        !           719:        for (i = 0; i < 10; i++)        
        !           720:                inb(ioaddr + i);
        !           721:        inw(ioaddr + 10);
        !           722:        inw(ioaddr + 12);
        !           723:        /* New: On the Vortex we must also clear the BadSSD counter. */
        !           724:        EL3WINDOW(4);
        !           725:        inb(ioaddr + 12);
        !           726:        /* ..and on the Boomerang we enable the extra statistics bits. */
        !           727:        outw(0x0040, ioaddr + Wn4_NetDiag);
        !           728: 
        !           729:        /* Switch to register set 7 for normal use. */
        !           730:        EL3WINDOW(7);
        !           731: 
        !           732:        if (vp->full_bus_master_rx) { /* Boomerang bus master. */
        !           733:                vp->cur_rx = vp->dirty_rx = 0;
        !           734:                if (vortex_debug > 2)
        !           735:                        printk("%s:  Filling in the Rx ring.\n", dev->name);
        !           736:                for (i = 0; i < RX_RING_SIZE; i++) {
        !           737:                        struct sk_buff *skb;
        !           738:                        if (i < (RX_RING_SIZE - 1))
        !           739:                          vp->rx_ring[i].next = virt_to_bus(&vp->rx_ring[i+1]);
        !           740:                        else
        !           741:                          vp->rx_ring[i].next = 0;
        !           742:                        vp->rx_ring[i].status = 0;      /* Clear complete bit. */
        !           743:                        vp->rx_ring[i].length = PKT_BUF_SZ | 0x80000000;
        !           744:                        skb = dev_alloc_skb(PKT_BUF_SZ);
        !           745:                        vp->rx_skbuff[i] = skb;
        !           746:                        if (skb == NULL)
        !           747:                                break;                  /* Bad news!  */
        !           748:                        skb->dev = dev;                 /* Mark as being used by this device. */
        !           749:                        skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
        !           750:                        vp->rx_ring[i].addr = virt_to_bus(skb->tail);
        !           751:                }
        !           752:                vp->rx_ring[i-1].next = virt_to_bus(&vp->rx_ring[0]); /* Wrap the ring. */
        !           753:                outl(virt_to_bus(&vp->rx_ring[0]), ioaddr + UpListPtr);
        !           754:        }
        !           755:        if (vp->full_bus_master_tx) {           /* Boomerang bus master Tx. */
        !           756:                vp->cur_tx = vp->dirty_tx = 0;
        !           757:                outb(PKT_BUF_SZ>>8, ioaddr + TxFreeThreshold); /* Room for a packet. */
        !           758:                /* Clear the Tx ring. */
        !           759:                for (i = 0; i < TX_RING_SIZE; i++)
        !           760:                        vp->tx_skbuff[i] = 0;
        !           761:                outl(0, ioaddr + DownListPtr);
        !           762:        }
        !           763:        /* Set reciever mode: presumably accept b-case and phys addr only. */
        !           764:        set_rx_mode(dev);
        !           765:        outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
        !           766: 
        !           767:        dev->tbusy = 0;
        !           768:        dev->interrupt = 0;
        !           769:        dev->start = 1;
        !           770: 
        !           771:        outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
        !           772:        outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
        !           773:        /* Allow status bits to be seen. */
        !           774:        outw(SetStatusEnb | AdapterFailure|IntReq|StatsFull | 
        !           775:                 (vp->full_bus_master_tx ? DownComplete : TxAvailable) |
        !           776:                 (vp->full_bus_master_rx ? UpComplete : RxComplete) | 
        !           777:                 (vp->bus_master ? DMADone : 0),
        !           778:                 ioaddr + EL3_CMD);
        !           779:        /* Ack all pending events, and set active indicator mask. */
        !           780:        outw(AckIntr | IntLatch | TxAvailable | RxEarly | IntReq,
        !           781:                 ioaddr + EL3_CMD);
        !           782:        outw(SetIntrEnb | IntLatch | TxAvailable | RxComplete | StatsFull
        !           783:                 | (vp->bus_master ? DMADone : 0) | UpComplete | DownComplete,
        !           784:                        ioaddr + EL3_CMD);
        !           785: 
        !           786:        MOD_INC_USE_COUNT;
        !           787: 
        !           788:        return 0;
        !           789: }
        !           790: 
        !           791: static void vortex_timer(unsigned long data)
        !           792: {
        !           793: #ifdef AUTOMEDIA
        !           794:        struct device *dev = (struct device *)data;
        !           795:        struct vortex_private *vp = (struct vortex_private *)dev->priv;
        !           796:        int ioaddr = dev->base_addr;
        !           797:        unsigned long flags;
        !           798:        int ok = 0;
        !           799: 
        !           800:        if (vortex_debug > 1)
        !           801:                printk("%s: Media selection timer tick happened, %s.\n",
        !           802:                           dev->name, media_tbl[dev->if_port].name);
        !           803: 
        !           804:        save_flags(flags);      cli(); {
        !           805:          int old_window = inw(ioaddr + EL3_CMD) >> 13;
        !           806:          int media_status;
        !           807:          EL3WINDOW(4);
        !           808:          media_status = inw(ioaddr + Wn4_Media);
        !           809:          switch (dev->if_port) {
        !           810:          case 0:  case 4:  case 5:             /* 10baseT, 100baseTX, 100baseFX  */
        !           811:                if (media_status & Media_LnkBeat) {
        !           812:                  ok = 1;
        !           813:                  if (vortex_debug > 1)
        !           814:                        printk("%s: Media %s has link beat, %x.\n",
        !           815:                                   dev->name, media_tbl[dev->if_port].name, media_status);
        !           816:                } else if (vortex_debug > 1)
        !           817:                  printk("%s: Media %s is has no link beat, %x.\n",
        !           818:                                   dev->name, media_tbl[dev->if_port].name, media_status);
        !           819:  
        !           820:                break;
        !           821:          default:                                      /* Other media types handled by Tx timeouts. */
        !           822:                if (vortex_debug > 1)
        !           823:                  printk("%s: Media %s is has no indication, %x.\n",
        !           824:                                 dev->name, media_tbl[dev->if_port].name, media_status);
        !           825:                ok = 1;
        !           826:          }
        !           827:          if ( ! ok) {
        !           828:                union wn3_config config;
        !           829: 
        !           830:                do {
        !           831:                        dev->if_port = media_tbl[dev->if_port].next;
        !           832:                } while ( ! (vp->available_media & media_tbl[dev->if_port].mask));
        !           833:                if (dev->if_port == 8) { /* Go back to default. */
        !           834:                  dev->if_port = vp->default_media;
        !           835:                  if (vortex_debug > 1)
        !           836:                        printk("%s: Media selection failing, using default %s port.\n",
        !           837:                                   dev->name, media_tbl[dev->if_port].name);
        !           838:                } else {
        !           839:                  if (vortex_debug > 1)
        !           840:                        printk("%s: Media selection failed, now trying %s port.\n",
        !           841:                                   dev->name, media_tbl[dev->if_port].name);
        !           842:                  vp->timer.expires = RUN_AT(media_tbl[dev->if_port].wait);
        !           843:                  add_timer(&vp->timer);
        !           844:                }
        !           845:                outw((media_status & ~(Media_10TP|Media_SQE)) |
        !           846:                         media_tbl[dev->if_port].media_bits, ioaddr + Wn4_Media);
        !           847: 
        !           848:                EL3WINDOW(3);
        !           849:                config.i = inl(ioaddr + Wn3_Config);
        !           850:                config.u.xcvr = dev->if_port;
        !           851:                outl(config.i, ioaddr + Wn3_Config);
        !           852: 
        !           853:                outw(dev->if_port == 3 ? StartCoax : StopCoax, ioaddr + EL3_CMD);
        !           854:          }
        !           855:          EL3WINDOW(old_window);
        !           856:        }   restore_flags(flags);
        !           857:        if (vortex_debug > 1)
        !           858:          printk("%s: Media selection timer finished, %s.\n",
        !           859:                         dev->name, media_tbl[dev->if_port].name);
        !           860: 
        !           861: #endif /* AUTOMEDIA*/
        !           862:        return;
        !           863: }
        !           864: 
        !           865: static int
        !           866: vortex_start_xmit(struct sk_buff *skb, struct device *dev)
        !           867: {
        !           868:        struct vortex_private *vp = (struct vortex_private *)dev->priv;
        !           869:        int ioaddr = dev->base_addr;
        !           870: 
        !           871:        if (dev->tbusy) {
        !           872:                int tickssofar = jiffies - dev->trans_start;
        !           873:                int i;
        !           874: 
        !           875:                /* Min. wait before assuming a Tx failed == 400ms. */
        !           876: 
        !           877:                if (tickssofar < 400*HZ/1000)           /* We probably aren't empty. */
        !           878:                        return 1;
        !           879:                printk("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
        !           880:                           dev->name, inb(ioaddr + TxStatus),
        !           881:                           inw(ioaddr + EL3_STATUS));
        !           882:                /* Slight code bloat to be user friendly. */
        !           883:                if ((inb(ioaddr + TxStatus) & 0x88) == 0x88)
        !           884:                        printk("%s: Transmitter encountered 16 collisions -- network"
        !           885:                                   " network cable problem?\n", dev->name);
        !           886: #ifndef final_version
        !           887:                printk("  Flags; bus-master %d, full %d; dirty %d current %d.\n",
        !           888:                           vp->full_bus_master_tx, vp->tx_full, vp->dirty_tx, vp->cur_tx);
        !           889:                printk("  Down list %8.8x vs. %p.\n", inl(ioaddr + DownListPtr),
        !           890:                           &vp->tx_ring[0]);
        !           891:                for (i = 0; i < TX_RING_SIZE; i++) {
        !           892:                        printk("  %d: %p  length %8.8x status %8.8x\n", i,
        !           893:                                   &vp->tx_ring[i],
        !           894:                                   vp->tx_ring[i].length,
        !           895:                                   vp->tx_ring[i].status);
        !           896:                }
        !           897: #endif
        !           898:                /* Issue TX_RESET and TX_START commands. */
        !           899:                outw(TxReset, ioaddr + EL3_CMD);
        !           900:                for (i = 20; i >= 0 ; i--)
        !           901:                        if ( ! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
        !           902:                                break;
        !           903:                outw(TxEnable, ioaddr + EL3_CMD);
        !           904:                dev->trans_start = jiffies;
        !           905:                /* dev->tbusy = 0;*/
        !           906:                vp->stats.tx_errors++;
        !           907:                vp->stats.tx_dropped++;
        !           908:                return 0;                       /* Yes, silently *drop* the packet! */
        !           909:        }
        !           910: 
        !           911:        /* Block a timer-based transmit from overlapping.  This could better be
        !           912:           done with atomic_swap(1, dev->tbusy), but set_bit() works as well.
        !           913:           If this ever occurs the queue layer is doing something evil! */
        !           914:        if (test_and_set_bit(0, (void*)&dev->tbusy) != 0) {
        !           915:                printk("%s: Transmitter access conflict.\n", dev->name);
        !           916:                return 1;
        !           917:        }
        !           918: 
        !           919:        if (vp->full_bus_master_tx) { /* BOOMERANG bus-master */
        !           920:                /* Calculate the next Tx descriptor entry. */
        !           921:                int entry = vp->cur_tx % TX_RING_SIZE;
        !           922:                struct boom_tx_desc *prev_entry;
        !           923:                unsigned long flags, i;
        !           924: 
        !           925:                if (vp->tx_full) /* No room to transmit with */
        !           926:                  return 1;
        !           927:                if (vp->cur_tx != 0)
        !           928:                  prev_entry = &vp->tx_ring[(vp->cur_tx-1) % TX_RING_SIZE];
        !           929:                else
        !           930:                  prev_entry = NULL;
        !           931:                if (vortex_debug > 3)
        !           932:                        printk("%s: Trying to send a packet, Tx index %d.\n",
        !           933:                                   dev->name, vp->cur_tx);
        !           934:                /* vp->tx_full = 1; */
        !           935:                vp->tx_skbuff[entry] = skb;
        !           936:                vp->tx_ring[entry].next = 0;
        !           937:                vp->tx_ring[entry].addr = virt_to_bus(skb->data);
        !           938:                vp->tx_ring[entry].length = skb->len | 0x80000000;
        !           939:                vp->tx_ring[entry].status = skb->len | 0x80000000;
        !           940: 
        !           941:                save_flags(flags);
        !           942:                cli();
        !           943:                outw(DownStall, ioaddr + EL3_CMD);
        !           944:                /* Wait for the stall to complete. */
        !           945:                for (i = 20; i >= 0 ; i--)
        !           946:                        if ( (inw(ioaddr + EL3_STATUS) & CmdInProgress) == 0)
        !           947:                                break;
        !           948:                if (prev_entry)
        !           949:                  prev_entry->next = virt_to_bus(&vp->tx_ring[entry]);
        !           950:                if (inl(ioaddr + DownListPtr) == 0) {
        !           951:                        outl(virt_to_bus(&vp->tx_ring[entry]), ioaddr + DownListPtr);
        !           952:                        queued_packet++;
        !           953:                }
        !           954:                outw(DownUnstall, ioaddr + EL3_CMD);
        !           955:                restore_flags(flags);
        !           956: 
        !           957:                vp->cur_tx++;
        !           958:                if (vp->cur_tx - vp->dirty_tx > TX_RING_SIZE - 1)
        !           959:                        vp->tx_full = 1;
        !           960:                else {                                  /* Clear previous interrupt enable. */
        !           961:                  if (prev_entry)
        !           962:                        prev_entry->status &= ~0x80000000;
        !           963:                  dev->tbusy = 0;
        !           964:                }
        !           965:                dev->trans_start = jiffies;
        !           966:                return 0;
        !           967:        }
        !           968:        /* Put out the doubleword header... */
        !           969:        outl(skb->len, ioaddr + TX_FIFO);
        !           970: #ifdef VORTEX_BUS_MASTER
        !           971:        if (vp->bus_master) {
        !           972:                /* Set the bus-master controller to transfer the packet. */
        !           973:                outl((int)(skb->data), ioaddr + Wn7_MasterAddr);
        !           974:                outw((skb->len + 3) & ~3, ioaddr + Wn7_MasterLen);
        !           975:                vp->tx_skb = skb;
        !           976:                outw(StartDMADown, ioaddr + EL3_CMD);
        !           977:                /* dev->tbusy will be cleared at the DMADone interrupt. */
        !           978:        } else {
        !           979:                /* ... and the packet rounded to a doubleword. */
        !           980:                outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
        !           981:                dev_kfree_skb (skb, FREE_WRITE);
        !           982:                if (inw(ioaddr + TxFree) > 1536) {
        !           983:                        dev->tbusy = 0;
        !           984:                } else
        !           985:                        /* Interrupt us when the FIFO has room for max-sized packet. */
        !           986:                        outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
        !           987:        }
        !           988: #else
        !           989:        /* ... and the packet rounded to a doubleword. */
        !           990:        outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
        !           991:        dev_kfree_skb (skb, FREE_WRITE);
        !           992:        if (inw(ioaddr + TxFree) > 1536) {
        !           993:                dev->tbusy = 0;
        !           994:        } else
        !           995:                /* Interrupt us when the FIFO has room for max-sized packet. */
        !           996:                outw(SetTxThreshold + (1536>>2), ioaddr + EL3_CMD);
        !           997: #endif  /* bus master */
        !           998: 
        !           999:        dev->trans_start = jiffies;
        !          1000: 
        !          1001:        /* Clear the Tx status stack. */
        !          1002:        {
        !          1003:                short tx_status;
        !          1004:                int i = 4;
        !          1005: 
        !          1006:                while (--i > 0  &&      (tx_status = inb(ioaddr + TxStatus)) > 0) {
        !          1007:                        if (tx_status & 0x3C) {         /* A Tx-disabling error occurred.  */
        !          1008:                                if (vortex_debug > 2)
        !          1009:                                  printk("%s: Tx error, status %2.2x.\n",
        !          1010:                                                 dev->name, tx_status);
        !          1011:                                if (tx_status & 0x04) vp->stats.tx_fifo_errors++;
        !          1012:                                if (tx_status & 0x38) vp->stats.tx_aborted_errors++;
        !          1013:                                if (tx_status & 0x30) {
        !          1014:                                        int j;
        !          1015:                                        outw(TxReset, ioaddr + EL3_CMD);
        !          1016:                                        for (j = 20; j >= 0 ; j--)
        !          1017:                                                if ( ! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
        !          1018:                                                        break;
        !          1019:                                }
        !          1020:                                outw(TxEnable, ioaddr + EL3_CMD);
        !          1021:                        }
        !          1022:                        outb(0x00, ioaddr + TxStatus); /* Pop the status stack. */
        !          1023:                }
        !          1024:        }
        !          1025:        return 0;
        !          1026: }
        !          1027: 
        !          1028: /* The interrupt handler does all of the Rx thread work and cleans up
        !          1029:    after the Tx thread. */
        !          1030: static void vortex_interrupt IRQ(int irq, void *dev_id, struct pt_regs *regs)
        !          1031: {
        !          1032:        /* Use the now-standard shared IRQ implementation. */
        !          1033:        struct device *dev = dev_id;
        !          1034:        struct vortex_private *lp;
        !          1035:        int ioaddr, status;
        !          1036:        int latency;
        !          1037:        int i = max_interrupt_work;
        !          1038: 
        !          1039:        if (test_and_set_bit(0, (void*)&dev->interrupt)) {
        !          1040:                printk("%s: Re-entering the interrupt handler.\n", dev->name);
        !          1041:                return;
        !          1042:        }
        !          1043: 
        !          1044:        ioaddr = dev->base_addr;
        !          1045:        latency = inb(ioaddr + Timer);
        !          1046:        lp = (struct vortex_private *)dev->priv;
        !          1047: 
        !          1048:        status = inw(ioaddr + EL3_STATUS);
        !          1049: 
        !          1050:        if (vortex_debug > 4)
        !          1051:                printk("%s: interrupt, status %4.4x, timer %d.\n", dev->name,
        !          1052:                           status, latency);
        !          1053:        if ((status & 0xE000) != 0xE000) {
        !          1054:                static int donedidthis=0;
        !          1055:                /* Some interrupt controllers store a bogus interrupt from boot-time.
        !          1056:                   Ignore a single early interrupt, but don't hang the machine for
        !          1057:                   other interrupt problems. */
        !          1058:                if (donedidthis++ > 100) {
        !          1059:                        printk("%s: Bogus interrupt, bailing. Status %4.4x, start=%d.\n",
        !          1060:                                   dev->name, status, dev->start);
        !          1061:                        FREE_IRQ(dev->irq, dev);
        !          1062:                }
        !          1063:        }
        !          1064: 
        !          1065:        do {
        !          1066:                if (vortex_debug > 5)
        !          1067:                                printk("%s: In interrupt loop, status %4.4x.\n",
        !          1068:                                           dev->name, status);
        !          1069:                if (status & RxComplete)
        !          1070:                        vortex_rx(dev);
        !          1071: 
        !          1072:                if (status & TxAvailable) {
        !          1073:                        if (vortex_debug > 5)
        !          1074:                                printk("        TX room bit was handled.\n");
        !          1075:                        /* There's room in the FIFO for a full-sized packet. */
        !          1076:                        outw(AckIntr | TxAvailable, ioaddr + EL3_CMD);
        !          1077:                        dev->tbusy = 0;
        !          1078:                        mark_bh(NET_BH);
        !          1079:                }
        !          1080:                if (status & DownComplete) {
        !          1081:                        unsigned int dirty_tx = lp->dirty_tx;
        !          1082: 
        !          1083:                        while (lp->cur_tx - dirty_tx > 0) {
        !          1084:                                int entry = dirty_tx % TX_RING_SIZE;
        !          1085:                                if (inl(ioaddr + DownListPtr) ==
        !          1086:                                        virt_to_bus(&lp->tx_ring[entry]))
        !          1087:                                        break;                  /* It still hasn't been processed. */
        !          1088:                                if (lp->tx_skbuff[entry]) {
        !          1089:                                        dev_kfree_skb(lp->tx_skbuff[entry], FREE_WRITE);
        !          1090:                                        lp->tx_skbuff[entry] = 0;
        !          1091:                                }
        !          1092:                                dirty_tx++;
        !          1093:                        }
        !          1094:                        lp->dirty_tx = dirty_tx;
        !          1095:                        outw(AckIntr | DownComplete, ioaddr + EL3_CMD);
        !          1096:                        if (lp->tx_full && (lp->cur_tx - dirty_tx <= TX_RING_SIZE - 1)) {
        !          1097:                                lp->tx_full= 0;
        !          1098:                                dev->tbusy = 0;
        !          1099:                                mark_bh(NET_BH);
        !          1100:                        }
        !          1101:                }
        !          1102: #ifdef VORTEX_BUS_MASTER
        !          1103:                if (status & DMADone) {
        !          1104:                        outw(0x1000, ioaddr + Wn7_MasterStatus); /* Ack the event. */
        !          1105:                        dev->tbusy = 0;
        !          1106:                        dev_kfree_skb (lp->tx_skb, FREE_WRITE); /* Release the transfered buffer */
        !          1107:                        mark_bh(NET_BH);
        !          1108:                }
        !          1109: #endif
        !          1110:                if (status & UpComplete) {
        !          1111:                        boomerang_rx(dev);
        !          1112:                        outw(AckIntr | UpComplete, ioaddr + EL3_CMD);
        !          1113:                }
        !          1114:                if (status & (AdapterFailure | RxEarly | StatsFull)) {
        !          1115:                        /* Handle all uncommon interrupts at once. */
        !          1116:                        if (status & RxEarly) {                         /* Rx early is unused. */
        !          1117:                                vortex_rx(dev);
        !          1118:                                outw(AckIntr | RxEarly, ioaddr + EL3_CMD);
        !          1119:                        }
        !          1120:                        if (status & StatsFull) {       /* Empty statistics. */
        !          1121:                                static int DoneDidThat = 0;
        !          1122:                                if (vortex_debug > 4)
        !          1123:                                        printk("%s: Updating stats.\n", dev->name);
        !          1124:                                update_stats(ioaddr, dev);
        !          1125:                                /* DEBUG HACK: Disable statistics as an interrupt source. */
        !          1126:                                /* This occurs when we have the wrong media type! */
        !          1127:                                if (DoneDidThat == 0  &&
        !          1128:                                        inw(ioaddr + EL3_STATUS) & StatsFull) {
        !          1129:                                        int win, reg;
        !          1130:                                        printk("%s: Updating stats failed, disabling stats as an"
        !          1131:                                                   " interrupt source.\n", dev->name);
        !          1132:                                        for (win = 0; win < 8; win++) {
        !          1133:                                                EL3WINDOW(win);
        !          1134:                                                printk("\n Vortex window %d:", win);
        !          1135:                                                for (reg = 0; reg < 16; reg++)
        !          1136:                                                        printk(" %2.2x", inb(ioaddr+reg));
        !          1137:                                        }
        !          1138:                                        EL3WINDOW(7);
        !          1139:                                        outw(SetIntrEnb | TxAvailable | RxComplete | AdapterFailure
        !          1140:                                                 | UpComplete | DownComplete | TxComplete,
        !          1141:                                                 ioaddr + EL3_CMD);
        !          1142:                                        DoneDidThat++;
        !          1143:                                }
        !          1144:                        }
        !          1145:                        if (status & AdapterFailure) {
        !          1146:                                /* Adapter failure requires Rx reset and reinit. */
        !          1147:                                outw(RxReset, ioaddr + EL3_CMD);
        !          1148:                                /* Set the Rx filter to the current state. */
        !          1149:                                set_rx_mode(dev);
        !          1150:                                outw(RxEnable, ioaddr + EL3_CMD); /* Re-enable the receiver. */
        !          1151:                                outw(AckIntr | AdapterFailure, ioaddr + EL3_CMD);
        !          1152:                        }
        !          1153:                }
        !          1154: 
        !          1155:                if (--i < 0) {
        !          1156:                        printk("%s: Too much work in interrupt, status %4.4x.  "
        !          1157:                                   "Disabling functions (%4.4x).\n",
        !          1158:                                   dev->name, status, SetStatusEnb | ((~status) & 0x7FE));
        !          1159:                        /* Disable all pending interrupts. */
        !          1160:                        outw(SetStatusEnb | ((~status) & 0x7FE), ioaddr + EL3_CMD);
        !          1161:                        outw(AckIntr | 0x7FF, ioaddr + EL3_CMD);
        !          1162:                        break;
        !          1163:                }
        !          1164:                /* Acknowledge the IRQ. */
        !          1165:                outw(AckIntr | IntReq | IntLatch, ioaddr + EL3_CMD);
        !          1166: 
        !          1167:        } while ((status = inw(ioaddr + EL3_STATUS)) & (IntLatch | RxComplete));
        !          1168: 
        !          1169:        if (vortex_debug > 4)
        !          1170:                printk("%s: exiting interrupt, status %4.4x.\n", dev->name, status);
        !          1171: 
        !          1172:        dev->interrupt = 0;
        !          1173:        return;
        !          1174: }
        !          1175: 
        !          1176: static int
        !          1177: vortex_rx(struct device *dev)
        !          1178: {
        !          1179:        struct vortex_private *vp = (struct vortex_private *)dev->priv;
        !          1180:        int ioaddr = dev->base_addr;
        !          1181:        int i;
        !          1182:        short rx_status;
        !          1183: 
        !          1184:        if (vortex_debug > 5)
        !          1185:                printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
        !          1186:                           inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
        !          1187:        while ((rx_status = inw(ioaddr + RxStatus)) > 0) {
        !          1188:                if (rx_status & 0x4000) { /* Error, update stats. */
        !          1189:                        unsigned char rx_error = inb(ioaddr + RxErrors);
        !          1190:                        if (vortex_debug > 2)
        !          1191:                                printk(" Rx error: status %2.2x.\n", rx_error);
        !          1192:                        vp->stats.rx_errors++;
        !          1193:                        if (rx_error & 0x01)  vp->stats.rx_over_errors++;
        !          1194:                        if (rx_error & 0x02)  vp->stats.rx_length_errors++;
        !          1195:                        if (rx_error & 0x04)  vp->stats.rx_frame_errors++;
        !          1196:                        if (rx_error & 0x08)  vp->stats.rx_crc_errors++;
        !          1197:                        if (rx_error & 0x10)  vp->stats.rx_length_errors++;
        !          1198:                } else {
        !          1199:                        /* The packet length: up to 4.5K!. */
        !          1200:                        short pkt_len = rx_status & 0x1fff;
        !          1201:                        struct sk_buff *skb;
        !          1202: 
        !          1203:                        skb = DEV_ALLOC_SKB(pkt_len + 5);
        !          1204:                        if (vortex_debug > 4)
        !          1205:                                printk("Receiving packet size %d status %4.4x.\n",
        !          1206:                                           pkt_len, rx_status);
        !          1207:                        if (skb != NULL) {
        !          1208:                                skb->dev = dev;
        !          1209: #if LINUX_VERSION_CODE >= 0x10300
        !          1210:                                skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
        !          1211:                                /* 'skb_put()' points to the start of sk_buff data area. */
        !          1212:                                insl(ioaddr + RX_FIFO, skb_put(skb, pkt_len),
        !          1213:                                         (pkt_len + 3) >> 2);
        !          1214:                                outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
        !          1215:                                skb->protocol = eth_type_trans(skb, dev);
        !          1216: #else
        !          1217:                                skb->len = pkt_len;
        !          1218:                                /* 'skb->data' points to the start of sk_buff data area. */
        !          1219:                                insl(ioaddr + RX_FIFO, skb->data, (pkt_len + 3) >> 2);
        !          1220:                                outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
        !          1221: #endif  /* KERNEL_1_3_0 */
        !          1222:                                netif_rx(skb);
        !          1223:                                dev->last_rx = jiffies;
        !          1224:                                vp->stats.rx_packets++;
        !          1225:                                /* Wait a limited time to go to next packet. */
        !          1226:                                for (i = 200; i >= 0; i--)
        !          1227:                                        if ( ! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
        !          1228:                                                break;
        !          1229:                                continue;
        !          1230:                        } else if (vortex_debug)
        !          1231:                                printk("%s: Couldn't allocate a sk_buff of size %d.\n",
        !          1232:                                           dev->name, pkt_len);
        !          1233:                }
        !          1234:                outw(RxDiscard, ioaddr + EL3_CMD);
        !          1235:                vp->stats.rx_dropped++;
        !          1236:                /* Wait a limited time to skip this packet. */
        !          1237:                for (i = 200; i >= 0; i--)
        !          1238:                        if ( ! (inw(ioaddr + EL3_STATUS) & CmdInProgress))
        !          1239:                                break;
        !          1240:        }
        !          1241: 
        !          1242:        return 0;
        !          1243: }
        !          1244: 
        !          1245: static int
        !          1246: boomerang_rx(struct device *dev)
        !          1247: {
        !          1248:        struct vortex_private *vp = (struct vortex_private *)dev->priv;
        !          1249:        int entry = vp->cur_rx % RX_RING_SIZE;
        !          1250:        int ioaddr = dev->base_addr;
        !          1251:        int rx_status;
        !          1252: 
        !          1253:        if (vortex_debug > 5)
        !          1254:                printk("   In boomerang_rx(), status %4.4x, rx_status %4.4x.\n",
        !          1255:                           inw(ioaddr+EL3_STATUS), inw(ioaddr+RxStatus));
        !          1256:        while ((rx_status = vp->rx_ring[entry].status) & RxDComplete) {
        !          1257:                if (rx_status & RxDError) { /* Error, update stats. */
        !          1258:                        unsigned char rx_error = rx_status >> 16;
        !          1259:                        if (vortex_debug > 2)
        !          1260:                                printk(" Rx error: status %2.2x.\n", rx_error);
        !          1261:                        vp->stats.rx_errors++;
        !          1262:                        if (rx_error & 0x01)  vp->stats.rx_over_errors++;
        !          1263:                        if (rx_error & 0x02)  vp->stats.rx_length_errors++;
        !          1264:                        if (rx_error & 0x04)  vp->stats.rx_frame_errors++;
        !          1265:                        if (rx_error & 0x08)  vp->stats.rx_crc_errors++;
        !          1266:                        if (rx_error & 0x10)  vp->stats.rx_length_errors++;
        !          1267:                } else {
        !          1268:                        /* The packet length: up to 4.5K!. */
        !          1269:                        short pkt_len = rx_status & 0x1fff;
        !          1270:                        struct sk_buff *skb;
        !          1271: 
        !          1272:                        if (vortex_debug > 4)
        !          1273:                                printk("Receiving packet size %d status %4.4x.\n",
        !          1274:                                           pkt_len, rx_status);
        !          1275: 
        !          1276:                        /* Check if the packet is long enough to just accept without
        !          1277:                           copying to a properly sized skbuff. */
        !          1278:                        if (pkt_len < rx_copybreak
        !          1279:                                && (skb = DEV_ALLOC_SKB(pkt_len + 2)) != 0) {
        !          1280:                                skb->dev = dev;
        !          1281:                                skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
        !          1282:                                /* 'skb_put()' points to the start of sk_buff data area. */
        !          1283:                                memcpy(skb_put(skb, pkt_len),
        !          1284:                                           bus_to_virt(vp->rx_ring[entry].addr),
        !          1285:                                           pkt_len);
        !          1286:                                rx_copy++;
        !          1287:                        } else{
        !          1288:                                void *temp;
        !          1289:                                /* Pass up the skbuff already on the Rx ring. */
        !          1290:                                skb = vp->rx_skbuff[entry];
        !          1291:                                vp->rx_skbuff[entry] = NULL;
        !          1292:                                temp = skb_put(skb, pkt_len);
        !          1293:                                /* Remove this checking code for final release. */
        !          1294:                                if (bus_to_virt(vp->rx_ring[entry].addr) != temp)
        !          1295:                                        printk("%s: Warning -- the skbuff addresses do not match"
        !          1296:                                                   " in boomerang_rx: %p vs. %p / %p.\n", dev->name,
        !          1297:                                                   bus_to_virt(vp->rx_ring[entry].addr),
        !          1298:                                                   skb->head, temp);
        !          1299:                                rx_nocopy++;
        !          1300:                        }
        !          1301: #if LINUX_VERSION_CODE > 0x10300
        !          1302:                        skb->protocol = eth_type_trans(skb, dev);
        !          1303: #else
        !          1304:                        skb->len = pkt_len;
        !          1305: #endif
        !          1306:                        netif_rx(skb);
        !          1307:                        dev->last_rx = jiffies;
        !          1308:                        vp->stats.rx_packets++;
        !          1309:                }
        !          1310:                entry = (++vp->cur_rx) % RX_RING_SIZE;
        !          1311:        }
        !          1312:        /* Refill the Rx ring buffers. */
        !          1313:        for (; vp->dirty_rx < vp->cur_rx; vp->dirty_rx++) {
        !          1314:                struct sk_buff *skb;
        !          1315:                entry = vp->dirty_rx % RX_RING_SIZE;
        !          1316:                if (vp->rx_skbuff[entry] == NULL) {
        !          1317:                        skb = dev_alloc_skb(PKT_BUF_SZ);
        !          1318:                        if (skb == NULL)
        !          1319:                                break;                  /* Bad news!  */
        !          1320:                        skb->dev = dev;                 /* Mark as being used by this device. */
        !          1321: #if LINUX_VERSION_CODE > 0x10300
        !          1322:                        skb_reserve(skb, 2);    /* Align IP on 16 byte boundaries */
        !          1323:                        vp->rx_ring[entry].addr = virt_to_bus(skb->tail);
        !          1324: #else
        !          1325:                        vp->rx_ring[entry].addr = virt_to_bus(skb->data);
        !          1326: #endif
        !          1327:                        vp->rx_skbuff[entry] = skb;
        !          1328:                }
        !          1329:                vp->rx_ring[entry].status = 0;  /* Clear complete bit. */
        !          1330:        }
        !          1331:        return 0;
        !          1332: }
        !          1333: 
        !          1334: static int
        !          1335: vortex_close(struct device *dev)
        !          1336: {
        !          1337:        struct vortex_private *vp = (struct vortex_private *)dev->priv;
        !          1338:        int ioaddr = dev->base_addr;
        !          1339:        int i;
        !          1340: 
        !          1341:        dev->start = 0;
        !          1342:        dev->tbusy = 1;
        !          1343: 
        !          1344:        if (vortex_debug > 1) {
        !          1345:                printk("%s: vortex_close() status %4.4x, Tx status %2.2x.\n",
        !          1346:                           dev->name, inw(ioaddr + EL3_STATUS), inb(ioaddr + TxStatus));
        !          1347:                printk("%s: vortex close stats: rx_nocopy %d rx_copy %d"
        !          1348:                           " tx_queued %d.\n",
        !          1349:                           dev->name, rx_nocopy, rx_copy, queued_packet);
        !          1350:        }
        !          1351: 
        !          1352:        del_timer(&vp->timer);
        !          1353: 
        !          1354:        /* Turn off statistics ASAP.  We update lp->stats below. */
        !          1355:        outw(StatsDisable, ioaddr + EL3_CMD);
        !          1356: 
        !          1357:        /* Disable the receiver and transmitter. */
        !          1358:        outw(RxDisable, ioaddr + EL3_CMD);
        !          1359:        outw(TxDisable, ioaddr + EL3_CMD);
        !          1360: 
        !          1361:        if (dev->if_port == XCVR_10base2)
        !          1362:                /* Turn off thinnet power.  Green! */
        !          1363:                outw(StopCoax, ioaddr + EL3_CMD);
        !          1364: 
        !          1365: #ifdef SA_SHIRQ
        !          1366:        free_irq(dev->irq, dev);
        !          1367: #else
        !          1368:        free_irq(dev->irq);
        !          1369:        irq2dev_map[dev->irq] = 0;
        !          1370: #endif
        !          1371: 
        !          1372:        outw(SetIntrEnb | 0x0000, ioaddr + EL3_CMD);
        !          1373: 
        !          1374:        update_stats(ioaddr, dev);
        !          1375:        if (vp->full_bus_master_rx) { /* Free Boomerang bus master Rx buffers. */
        !          1376:                outl(0, ioaddr + UpListPtr);
        !          1377:                for (i = 0; i < RX_RING_SIZE; i++)
        !          1378:                        if (vp->rx_skbuff[i]) {
        !          1379: #if LINUX_VERSION_CODE < 0x20100
        !          1380:                                vp->rx_skbuff[i]->free = 1;
        !          1381: #endif
        !          1382:                                dev_kfree_skb (vp->rx_skbuff[i], FREE_WRITE);
        !          1383:                                vp->rx_skbuff[i] = 0;
        !          1384:                        }
        !          1385:        }
        !          1386:        if (vp->full_bus_master_tx) { /* Free Boomerang bus master Tx buffers. */
        !          1387:                outl(0, ioaddr + DownListPtr);
        !          1388:                for (i = 0; i < TX_RING_SIZE; i++)
        !          1389:                        if (vp->tx_skbuff[i]) {
        !          1390:                                dev_kfree_skb(vp->tx_skbuff[i], FREE_WRITE);
        !          1391:                                vp->tx_skbuff[i] = 0;
        !          1392:                        }
        !          1393:        }
        !          1394: 
        !          1395:        MOD_DEC_USE_COUNT;
        !          1396: 
        !          1397:        return 0;
        !          1398: }
        !          1399: 
        !          1400: static struct enet_statistics *
        !          1401: vortex_get_stats(struct device *dev)
        !          1402: {
        !          1403:        struct vortex_private *vp = (struct vortex_private *)dev->priv;
        !          1404:        unsigned long flags;
        !          1405: 
        !          1406:        if (dev->start) {
        !          1407:                save_flags(flags);
        !          1408:                cli();
        !          1409:                update_stats(dev->base_addr, dev);
        !          1410:                restore_flags(flags);
        !          1411:        }
        !          1412:        return &vp->stats;
        !          1413: }
        !          1414: 
        !          1415: /*  Update statistics.
        !          1416:        Unlike with the EL3 we need not worry about interrupts changing
        !          1417:        the window setting from underneath us, but we must still guard
        !          1418:        against a race condition with a StatsUpdate interrupt updating the
        !          1419:        table.  This is done by checking that the ASM (!) code generated uses
        !          1420:        atomic updates with '+='.
        !          1421:        */
        !          1422: static void update_stats(int ioaddr, struct device *dev)
        !          1423: {
        !          1424:        struct vortex_private *vp = (struct vortex_private *)dev->priv;
        !          1425: 
        !          1426:        /* Unlike the 3c5x9 we need not turn off stats updates while reading. */
        !          1427:        /* Switch to the stats window, and read everything. */
        !          1428:        EL3WINDOW(6);
        !          1429:        vp->stats.tx_carrier_errors             += inb(ioaddr + 0);
        !          1430:        vp->stats.tx_heartbeat_errors   += inb(ioaddr + 1);
        !          1431:        /* Multiple collisions. */              inb(ioaddr + 2);
        !          1432:        vp->stats.collisions                    += inb(ioaddr + 3);
        !          1433:        vp->stats.tx_window_errors              += inb(ioaddr + 4);
        !          1434:        vp->stats.rx_fifo_errors                += inb(ioaddr + 5);
        !          1435:        vp->stats.tx_packets                    += inb(ioaddr + 6);
        !          1436:        vp->stats.tx_packets                    += (inb(ioaddr + 9)&0x30) << 4;
        !          1437:        /* Rx packets   */                              inb(ioaddr + 7);   /* Must read to clear */
        !          1438:        /* Tx deferrals */                              inb(ioaddr + 8);
        !          1439:        /* Don't bother with register 9, an extension of registers 6&7.
        !          1440:           If we do use the 6&7 values the atomic update assumption above
        !          1441:           is invalid. */
        !          1442:        inw(ioaddr + 10);       /* Total Rx and Tx octets. */
        !          1443:        inw(ioaddr + 12);
        !          1444:        /* New: On the Vortex we must also clear the BadSSD counter. */
        !          1445:        EL3WINDOW(4);
        !          1446:        inb(ioaddr + 12);
        !          1447: 
        !          1448:        /* We change back to window 7 (not 1) with the Vortex. */
        !          1449:        EL3WINDOW(7);
        !          1450:        return;
        !          1451: }
        !          1452: 
        !          1453: /* This new version of set_rx_mode() supports v1.4 kernels.
        !          1454:    The Vortex chip has no documented multicast filter, so the only
        !          1455:    multicast setting is to receive all multicast frames.  At least
        !          1456:    the chip has a very clean way to set the mode, unlike many others. */
        !          1457: static void
        !          1458: set_rx_mode(struct device *dev)
        !          1459: {
        !          1460:        int ioaddr = dev->base_addr;
        !          1461:        short new_mode;
        !          1462: 
        !          1463:        if (dev->flags & IFF_PROMISC) {
        !          1464:                if (vortex_debug > 3)
        !          1465:                        printk("%s: Setting promiscuous mode.\n", dev->name);
        !          1466:                new_mode = SetRxFilter|RxStation|RxMulticast|RxBroadcast|RxProm;
        !          1467:        } else  if ((dev->mc_list)  ||  (dev->flags & IFF_ALLMULTI)) {
        !          1468:                new_mode = SetRxFilter|RxStation|RxMulticast|RxBroadcast;
        !          1469:        } else
        !          1470:                new_mode = SetRxFilter | RxStation | RxBroadcast;
        !          1471: 
        !          1472:        outw(new_mode, ioaddr + EL3_CMD);
        !          1473: }
        !          1474: 
        !          1475: #ifdef MODULE
        !          1476: void
        !          1477: cleanup_module(void)
        !          1478: {
        !          1479:        struct device *next_dev;
        !          1480: 
        !          1481:        /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
        !          1482:        while (root_vortex_dev) {
        !          1483:                next_dev = ((struct vortex_private *)root_vortex_dev->priv)->next_module;
        !          1484:                if (root_vortex_dev->dma)
        !          1485:                  free_dma(root_vortex_dev->dma);
        !          1486:                unregister_netdev(root_vortex_dev);
        !          1487:                outw(TotalReset, root_vortex_dev->base_addr + EL3_CMD);
        !          1488:                release_region(root_vortex_dev->base_addr, CORKSCREW_TOTAL_SIZE);
        !          1489:                kfree(root_vortex_dev);
        !          1490:                root_vortex_dev = next_dev;
        !          1491:        }
        !          1492: }
        !          1493: #endif /* MODULE */
        !          1494: 
        !          1495: /*
        !          1496:  * Local variables:
        !          1497:  *  compile-command: "gcc -DMODULE -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -c 3c515.c"
        !          1498:  *  c-indent-level: 4
        !          1499:  *  tab-width: 4
        !          1500:  * End:
        !          1501:  */

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