Return to smc9194.c CVS log

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

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

1.1     ! root        1: /*------------------------------------------------------------------------
        !             2:  . smc9194.c
        !             3:  . This is a driver for SMC's 9000 series of Ethernet cards. 
        !             4:  .
        !             5:  . Copyright (C) 1996 by Erik Stahlman
        !             6:  . This software may be used and distributed according to the terms
        !             7:  . of the GNU Public License, incorporated herein by reference.
        !             8:  .
        !             9:  . "Features" of the SMC chip:  
        !            10:  .   4608 byte packet memory. ( for the 91C92.  Others have more ) 
        !            11:  .   EEPROM for configuration
        !            12:  .   AUI/TP selection  ( mine has 10Base2/10BaseT select )
        !            13:  .
        !            14:  . Arguments:
        !            15:  .     io               = for the base address
        !            16:  .     irq      = for the IRQ 
        !            17:  .     ifport = 0 for autodetect, 1 for TP, 2 for AUI ( or 10base2 )   
        !            18:  .
        !            19:  . author:  
        !            20:  .     Erik Stahlman                           ( [email protected] )
        !            21:  .   
        !            22:  . Hardware multicast code from Peter Cammaert ( [email protected] )
        !            23:  .
        !            24:  . Sources:
        !            25:  .    o   SMC databook
        !            26:  .    o   skeleton.c by Donald Becker ( [email protected] )
        !            27:  .    o   ( a LOT of advice from Becker as well )
        !            28:  .
        !            29:  . History:
        !            30:  .     12/07/95  Erik Stahlman  written, got receive/xmit handled 
        !            31:  .     01/03/96  Erik Stahlman  worked out some bugs, actually usable!!! :-)
        !            32:  .     01/06/96  Erik Stahlman  cleaned up some, better testing, etc 
        !            33:  .     01/29/96  Erik Stahlman  fixed autoirq, added multicast
        !            34:  .     02/01/96  Erik Stahlman  1. disabled all interrupts in smc_reset
        !            35:  .                              2. got rid of post-decrementing bug -- UGH.  
        !            36:  .     02/13/96  Erik Stahlman  Tried to fix autoirq failure.  Added more
        !            37:  .                              descriptive error messages.
        !            38:  .     02/15/96  Erik Stahlman  Fixed typo that caused detection failure
        !            39:  .     02/23/96  Erik Stahlman  Modified it to fit into kernel tree  
        !            40:  .                              Added support to change hardware address
        !            41:  .                              Cleared stats on opens
        !            42:  .     02/26/96  Erik Stahlman  Trial support for Kernel 1.2.13
        !            43:  .                              Kludge for automatic IRQ detection
        !            44:  .     03/04/96  Erik Stahlman  Fixed kernel 1.3.70 + 
        !            45:  .                              Fixed bug reported by Gardner Buchanan in 
        !            46:  .                                smc_enable, with outw instead of outb
        !            47:  .     03/06/96  Erik Stahlman  Added hardware multicast from Peter Cammaert
        !            48:  ----------------------------------------------------------------------------*/
        !            49: 
        !            50: static const char *version =
        !            51:        "smc9194.c:v0.12 03/06/96 by Erik Stahlman ([email protected])\n";  
        !            52: 
        !            53: #ifdef MODULE
        !            54: #include <linux/module.h>
        !            55: #include <linux/version.h>
        !            56: #endif 
        !            57: 
        !            58: #include <linux/kernel.h>
        !            59: #include <linux/sched.h>
        !            60: #include <linux/types.h>
        !            61: #include <linux/fcntl.h>
        !            62: #include <linux/interrupt.h>
        !            63: #include <linux/ptrace.h>
        !            64: #include <linux/ioport.h>
        !            65: #include <linux/in.h>
        !            66: #include <linux/malloc.h>
        !            67: #include <linux/string.h>
        !            68: #include <linux/ioport.h>
        !            69: #include <asm/bitops.h>
        !            70: #include <asm/io.h>
        !            71: #include <linux/errno.h>
        !            72: 
        !            73: #include <linux/netdevice.h>
        !            74: #include <linux/etherdevice.h>
        !            75: #include <linux/skbuff.h>
        !            76: 
        !            77: #include "smc9194.h"
        !            78: /*------------------------------------------------------------------------
        !            79:  .  
        !            80:  . Configuration options, for the experienced user to change. 
        !            81:  .
        !            82:  -------------------------------------------------------------------------*/
        !            83: 
        !            84: /* 
        !            85:  . this is for kernels > 1.2.70 
        !            86: */
        !            87: #define REALLY_NEW_KERNEL 
        !            88: #ifndef REALLY_NEW_KERNEL
        !            89: #define free_irq( x, y ) free_irq( x )
        !            90: #define request_irq( x, y, z, u, v ) request_irq( x, y, z, u )
        !            91: #endif
        !            92: 
        !            93: /*
        !            94:  . Do you want to use this with old kernels.  
        !            95:  . WARNING: this is not well tested.  
        !            96: #define SUPPORT_OLD_KERNEL
        !            97: */
        !            98: 
        !            99: 
        !           100: /*
        !           101:  . Do you want to use 32 bit xfers?  This should work on all chips, as
        !           102:  . the chipset is designed to accommodate them.   
        !           103: */
        !           104: #define USE_32_BIT 1
        !           105: 
        !           106: /* 
        !           107:  .the SMC9194 can be at any of the following port addresses.  To change,
        !           108:  .for a slightly different card, you can add it to the array.  Keep in 
        !           109:  .mind that the array must end in zero.
        !           110: */
        !           111: static unsigned int smc_portlist[] =
        !           112:    { 0x200, 0x220, 0x240, 0x260, 0x280, 0x2A0, 0x2C0, 0x2E0,
        !           113:          0x300, 0x320, 0x340, 0x360, 0x380, 0x3A0, 0x3C0, 0x3E0, 0};
        !           114: 
        !           115: /* 
        !           116:  . Wait time for memory to be free.  This probably shouldn't be 
        !           117:  . tuned that much, as waiting for this means nothing else happens 
        !           118:  . in the system 
        !           119: */
        !           120: #define MEMORY_WAIT_TIME 16
        !           121: 
        !           122: /*
        !           123:  . DEBUGGING LEVELS
        !           124:  . 
        !           125:  . 0 for normal operation
        !           126:  . 1 for slightly more details
        !           127:  . >2 for various levels of increasingly useless information
        !           128:  .    2 for interrupt tracking, status flags
        !           129:  .    3 for packet dumps, etc.
        !           130: */
        !           131: #define SMC_DEBUG 0
        !           132: 
        !           133: #if (SMC_DEBUG > 2 )
        !           134: #define PRINTK3(x) printk x 
        !           135: #else 
        !           136: #define PRINTK3(x) 
        !           137: #endif
        !           138: 
        !           139: #if SMC_DEBUG > 1 
        !           140: #define PRINTK2(x) printk x 
        !           141: #else
        !           142: #define PRINTK2(x)
        !           143: #endif
        !           144: 
        !           145: #ifdef SMC_DEBUG
        !           146: #define PRINTK(x) printk x
        !           147: #else
        !           148: #define PRINTK(x)
        !           149: #endif 
        !           150: 
        !           151: 
        !           152: /* the older versions of the kernel cannot support autoprobing */
        !           153: #ifdef SUPPORT_OLD_KERNEL
        !           154: #define NO_AUTOPROBE
        !           155: #endif
        !           156: 
        !           157: 
        !           158: /*------------------------------------------------------------------------
        !           159:  .
        !           160:  . The internal workings of the driver.  If you are changing anything 
        !           161:  . here with the SMC stuff, you should have the datasheet and known 
        !           162:  . what you are doing.  
        !           163:  .  
        !           164:  -------------------------------------------------------------------------*/
        !           165: #define CARDNAME "SMC9194"
        !           166: 
        !           167: #ifdef SUPPORT_OLD_KERNEL
        !           168: char kernel_version[] = UTS_RELEASE;
        !           169: #endif 
        !           170: 
        !           171: /* store this information for the driver.. */ 
        !           172: struct smc_local {
        !           173:        /*
        !           174:           these are things that the kernel wants me to keep, so users
        !           175:           can find out semi-useless statistics of how well the card is
        !           176:           performing 
        !           177:        */
        !           178:        struct enet_statistics stats;
        !           179:        
        !           180:        /* 
        !           181:           If I have to wait until memory is available to send
        !           182:           a packet, I will store the skbuff here, until I get the
        !           183:           desired memory.  Then, I'll send it out and free it.    
        !           184:        */
        !           185:        struct sk_buff * saved_skb;
        !           186: 
        !           187:        /*
        !           188:         . This keeps track of how many packets that I have
        !           189:         . sent out.  When an TX_EMPTY interrupt comes, I know
        !           190:         . that all of these have been sent.
        !           191:        */
        !           192:        int     packets_waiting;
        !           193: };
        !           194: 
        !           195: 
        !           196: /*-----------------------------------------------------------------
        !           197:  .
        !           198:  .  The driver can be entered at any of the following entry points.
        !           199:  . 
        !           200:  .------------------------------------------------------------------  */
        !           201: 
        !           202: /*
        !           203:  . This is called by  register_netdev().  It is responsible for 
        !           204:  . checking the portlist for the SMC9000 series chipset.  If it finds 
        !           205:  . one, then it will initialize the device, find the hardware information,
        !           206:  . and sets up the appropriate device parameters.   
        !           207:  . NOTE: Interrupts are *OFF* when this procedure is called.
        !           208:  .
        !           209:  . NB:This shouldn't be static since it is referred to externally.
        !           210: */
        !           211: int smc_init(struct device *dev);
        !           212: 
        !           213: /*
        !           214:  . The kernel calls this function when someone wants to use the device,
        !           215:  . typically 'ifconfig ethX up'.   
        !           216: */
        !           217: static int smc_open(struct device *dev);
        !           218: 
        !           219: /*
        !           220:  . This is called by the kernel to send a packet out into the net.  it's
        !           221:  . responsible for doing a best-effort send, but if it's simply not possible
        !           222:  . to send it, the packet gets dropped. 
        !           223: */  
        !           224: static int smc_send_packet(struct sk_buff *skb, struct device *dev);
        !           225: 
        !           226: /* 
        !           227:  . This is called by the kernel in response to 'ifconfig ethX down'.  It
        !           228:  . is responsible for cleaning up everything that the open routine 
        !           229:  . does, and maybe putting the card into a powerdown state. 
        !           230: */
        !           231: static int smc_close(struct device *dev);
        !           232: 
        !           233: /*
        !           234:  . This routine allows the proc file system to query the driver's 
        !           235:  . statistics.  
        !           236: */
        !           237: static struct enet_statistics * smc_query_statistics( struct device *dev);
        !           238: 
        !           239: /*
        !           240:  . Finally, a call to set promiscuous mode ( for TCPDUMP and related 
        !           241:  . programs ) and multicast modes.
        !           242: */
        !           243: #ifdef SUPPORT_OLD_KERNEL
        !           244: static void smc_set_multicast_list(struct device *dev, int num_addrs,
        !           245:                                 void *addrs);
        !           246: #else
        !           247: static void smc_set_multicast_list(struct device *dev);
        !           248: #endif 
        !           249: 
        !           250: /*---------------------------------------------------------------
        !           251:  . 
        !           252:  . Interrupt level calls.. 
        !           253:  .
        !           254:  ----------------------------------------------------------------*/
        !           255: 
        !           256: /*
        !           257:  . Handles the actual interrupt 
        !           258: */
        !           259: #ifdef REALLY_NEW_KERNEL
        !           260: static void smc_interrupt(int irq, void *, struct pt_regs *regs);
        !           261: #else
        !           262: static void smc_interrupt(int irq, struct pt_regs *regs);
        !           263: #endif 
        !           264: /*
        !           265:  . This is a separate procedure to handle the receipt of a packet, to
        !           266:  . leave the interrupt code looking slightly cleaner 
        !           267: */ 
        !           268: inline static void smc_rcv( struct device *dev );
        !           269: /*
        !           270:  . This handles a TX interrupt, which is only called when an error
        !           271:  . relating to a packet is sent.  
        !           272: */
        !           273: inline static void smc_tx( struct device * dev );
        !           274: 
        !           275: /*
        !           276:  ------------------------------------------------------------
        !           277:  . 
        !           278:  . Internal routines
        !           279:  .
        !           280:  ------------------------------------------------------------
        !           281: */
        !           282: 
        !           283: /*
        !           284:  . Test if a given location contains a chip, trying to cause as 
        !           285:  . little damage as possible if it's not a SMC chip.
        !           286: */
        !           287: static int smc_probe( int ioaddr );
        !           288: 
        !           289: /*
        !           290:  . this routine initializes the cards hardware, prints out the configuration
        !           291:  . to the system log as well as the vanity message, and handles the setup
        !           292:  . of a device parameter. 
        !           293:  . It will give an error if it can't initialize the card.
        !           294: */
        !           295: static int smc_initcard( struct device *, int ioaddr ); 
        !           296: 
        !           297: /*
        !           298:  . A rather simple routine to print out a packet for debugging purposes.
        !           299: */ 
        !           300: #if SMC_DEBUG > 2 
        !           301: static void print_packet( byte *, int );
        !           302: #endif  
        !           303: 
        !           304: #define tx_done(dev) 1
        !           305: 
        !           306: /* this is called to actually send the packet to the chip */ 
        !           307: static void smc_hardware_send_packet( struct device * dev );
        !           308: 
        !           309: /* Since I am not sure if I will have enough room in the chip's ram
        !           310:  . to store the packet, I call this routine, which either sends it 
        !           311:  . now, or generates an interrupt when the card is ready for the 
        !           312:  . packet */
        !           313: static int  smc_wait_to_send_packet( struct sk_buff * skb, struct device *dev );
        !           314: 
        !           315: /* this does a soft reset on the device */
        !           316: static void smc_reset( int ioaddr );
        !           317: 
        !           318: /* Enable Interrupts, Receive, and Transmit */
        !           319: static void smc_enable( int ioaddr );
        !           320: 
        !           321: /* this puts the device in an inactive state */
        !           322: static void smc_shutdown( int ioaddr );
        !           323: 
        !           324: #ifndef NO_AUTOPROBE
        !           325: /* This routine will find the IRQ of the driver if one is not
        !           326:  . specified in the input to the device.  */
        !           327: static int smc_findirq( int ioaddr );
        !           328: #endif
        !           329: 
        !           330: /*
        !           331:   this routine will set the hardware multicast table to the specified 
        !           332:   values given it by the higher level routines
        !           333: */
        !           334: #ifndef SUPPORT_OLD_KERNEL
        !           335: static void smc_setmulticast( int ioaddr, int count, struct dev_mc_list *  );
        !           336: static int crc32( char *, int );
        !           337: #endif
        !           338: 
        !           339: #ifdef SUPPORT_OLD_KERNEL
        !           340: extern struct device *init_etherdev(struct device *dev, int sizeof_private,
        !           341:                        unsigned long *mem_startp );
        !           342: #endif 
        !           343: 
        !           344: /*
        !           345:  . Function: smc_reset( int ioaddr )
        !           346:  . Purpose:
        !           347:  .     This sets the SMC91xx chip to its normal state, hopefully from whatever
        !           348:  .     mess that any other DOS driver has put it in.   
        !           349:  . 
        !           350:  . Maybe I should reset more registers to defaults in here?  SOFTRESET  should
        !           351:  . do that for me.  
        !           352:  . 
        !           353:  . Method:
        !           354:  .     1.  send a SOFT RESET 
        !           355:  .     2.  wait for it to finish
        !           356:  .     3.  enable autorelease mode
        !           357:  .     4.  reset the memory management unit
        !           358:  .     5.  clear all interrupts
        !           359:  .
        !           360: */  
        !           361: static void smc_reset( int ioaddr ) 
        !           362: { 
        !           363:        /* This resets the registers mostly to defaults, but doesn't
        !           364:           affect EEPROM.  That seems unnecessary */
        !           365:        SMC_SELECT_BANK( 0 );
        !           366:        outw( RCR_SOFTRESET, ioaddr + RCR ); 
        !           367:        
        !           368:        /* this should pause enough for the chip to be happy */
        !           369:        SMC_DELAY( );
        !           370: 
        !           371:        /* Set the transmit and receive configuration registers to 
        !           372:           default values */
        !           373:        outw( RCR_CLEAR, ioaddr + RCR );
        !           374:        outw( TCR_CLEAR, ioaddr + TCR );
        !           375: 
        !           376:        /* set the control register to automatically
        !           377:           release successfully transmitted packets, to make the best 
        !           378:           use out of our limited memory */
        !           379:        SMC_SELECT_BANK( 1 );
        !           380:        outw( inw( ioaddr + CONTROL ) | CTL_AUTO_RELEASE , ioaddr + CONTROL );  
        !           381: 
        !           382:        /* Reset the MMU */
        !           383:        SMC_SELECT_BANK( 2 );
        !           384:        outw( MC_RESET, ioaddr + MMU_CMD );
        !           385: 
        !           386:        /* Note:  It doesn't seem that waiting for the MMU busy is needed here, 
        !           387:           but this is a place where future chipsets _COULD_ break.  Be wary
        !           388:           of issuing another MMU command right after this */
        !           389: 
        !           390:        outb( 0, ioaddr + INT_MASK );
        !           391: }
        !           392: 
        !           393: /* 
        !           394:  . Function: smc_enable
        !           395:  . Purpose: let the chip talk to the outside work
        !           396:  . Method: 
        !           397:  .     1.  Enable the transmitter
        !           398:  .     2.  Enable the receiver
        !           399:  .     3.  Enable interrupts
        !           400: */
        !           401: static void smc_enable( int ioaddr ) 
        !           402: {
        !           403:        SMC_SELECT_BANK( 0 );
        !           404:        /* see the header file for options in TCR/RCR NORMAL*/
        !           405:        outw( TCR_NORMAL, ioaddr + TCR );
        !           406:        outw( RCR_NORMAL, ioaddr + RCR );
        !           407: 
        !           408:        /* now, enable interrupts */
        !           409:        SMC_SELECT_BANK( 2 );
        !           410:        outb( SMC_INTERRUPT_MASK, ioaddr + INT_MASK );
        !           411: }      
        !           412:        
        !           413: /*
        !           414:  . Function: smc_shutdown
        !           415:  . Purpose:  closes down the SMC91xxx chip.
        !           416:  . Method:   
        !           417:  .     1. zero the interrupt mask
        !           418:  .     2. clear the enable receive flag
        !           419:  .     3. clear the enable xmit flags
        !           420:  .
        !           421:  . TODO: 
        !           422:  .   (1) maybe utilize power down mode.
        !           423:  .     Why not yet?  Because while the chip will go into power down mode,
        !           424:  .     the manual says that it will wake up in response to any I/O requests
        !           425:  .     in the register space.   Empirical results do not show this working.
        !           426: */
        !           427: static void smc_shutdown( int ioaddr ) 
        !           428: {
        !           429:        /* no more interrupts for me */
        !           430:        SMC_SELECT_BANK( 2 );
        !           431:        outb( 0, ioaddr + INT_MASK );
        !           432: 
        !           433:        /* and tell the card to stay away from that nasty outside world */
        !           434:        SMC_SELECT_BANK( 0 );
        !           435:        outb( RCR_CLEAR, ioaddr + RCR );
        !           436:        outb( TCR_CLEAR, ioaddr + TCR );
        !           437: #if 0 
        !           438:        /* finally, shut the chip down */
        !           439:        SMC_SELECT_BANK( 1 ); 
        !           440:        outw( inw( ioaddr + CONTROL ), CTL_POWERDOWN, ioaddr + CONTROL  );
        !           441: #endif 
        !           442: }
        !           443: 
        !           444: 
        !           445: #ifndef SUPPORT_OLD_KERNEL 
        !           446: /* 
        !           447:  . Function: smc_setmulticast( int ioaddr, int count, dev_mc_list * adds )
        !           448:  . Purpose:
        !           449:  .    This sets the internal hardware table to filter out unwanted multicast
        !           450:  .    packets before they take up memory.  
        !           451:  .    
        !           452:  .    The SMC chip uses a hash table where the high 6 bits of the CRC of
        !           453:  .    address are the offset into the table.  If that bit is 1, then the 
        !           454:  .    multicast packet is accepted.  Otherwise, it's dropped silently.
        !           455:  .  
        !           456:  .    To use the 6 bits as an offset into the table, the high 3 bits are the
        !           457:  .    number of the 8 bit register, while the low 3 bits are the bit within
        !           458:  .    that register.
        !           459:  .
        !           460:  . This routine is based very heavily on the one provided by Peter Cammaert. 
        !           461: */
        !           462: 
        !           463: 
        !           464: static void smc_setmulticast( int ioaddr, int count, struct dev_mc_list * addrs ) {
        !           465:        int                     i;
        !           466:        unsigned char           multicast_table[ 8 ];
        !           467:        struct dev_mc_list      * cur_addr;
        !           468:        /* table for flipping the order of 3 bits */  
        !           469:        unsigned char invert3[] = { 0, 4, 2, 6, 1, 5, 3, 7 };
        !           470: 
        !           471:        /* start with a table of all zeros: reject all */       
        !           472:        memset( multicast_table, 0, sizeof( multicast_table ) );
        !           473: 
        !           474:        cur_addr = addrs;
        !           475:        for ( i = 0; i < count ; i ++, cur_addr = cur_addr->next  ) {
        !           476:                int position;
        !           477:                
        !           478:                /* do we have a pointer here? */
        !           479:                if ( !cur_addr ) 
        !           480:                        break;
        !           481:                /* make sure this is a multicast address - shouldn't this
        !           482:                   be a given if we have it here ? */   
        !           483:                if ( !( *cur_addr->dmi_addr & 1 ) )     
        !           484:                        continue;       
        !           485: 
        !           486:                /* only use the low order bits */       
        !           487:                position = crc32( cur_addr->dmi_addr, 6 ) & 0x3f;
        !           488:                                
        !           489:                /* do some messy swapping to put the bit in the right spot */
        !           490:                multicast_table[invert3[position&7]] |= 
        !           491:                                        (1<<invert3[(position>>3)&7]);
        !           492: 
        !           493:        }
        !           494:        /* now, the table can be loaded into the chipset */
        !           495:        SMC_SELECT_BANK( 3 );
        !           496:        
        !           497:        for ( i = 0; i < 8 ; i++ ) {
        !           498:                outb( multicast_table[i], ioaddr + MULTICAST1 + i );
        !           499:        }
        !           500: }
        !           501: 
        !           502: /*
        !           503:   Finds the CRC32 of a set of bytes.
        !           504:   Again, from Peter Cammaert's code. 
        !           505: */
        !           506: static int crc32( char * s, int length ) { 
        !           507:        /* indices */
        !           508:        int perByte;
        !           509:        int perBit;
        !           510:        /* crc polynomial for Ethernet */
        !           511:        const unsigned long poly = 0xedb88320;
        !           512:        /* crc value - preinitialized to all 1's */
        !           513:        unsigned long crc_value = 0xffffffff; 
        !           514: 
        !           515:        for ( perByte = 0; perByte < length; perByte ++ ) {
        !           516:                unsigned char   c;
        !           517:        
        !           518:                c = *(s++);
        !           519:                for ( perBit = 0; perBit < 8; perBit++ ) {
        !           520:                        crc_value = (crc_value>>1)^
        !           521:                                (((crc_value^c)&0x01)?poly:0);
        !           522:                        c >>= 1;
        !           523:                }
        !           524:        }
        !           525:        return  crc_value;
        !           526: } 
        !           527: 
        !           528: #endif 
        !           529: 
        !           530: 
        !           531: /* 
        !           532:  . Function: smc_wait_to_send_packet( struct sk_buff * skb, struct device * ) 
        !           533:  . Purpose: 
        !           534:  .    Attempt to allocate memory for a packet, if chip-memory is not
        !           535:  .    available, then tell the card to generate an interrupt when it 
        !           536:  .    is available.
        !           537:  .
        !           538:  . Algorithm:
        !           539:  .
        !           540:  . o   if the saved_skb is not currently null, then drop this packet
        !           541:  .     on the floor.  This should never happen, because of TBUSY.
        !           542:  . o   if the saved_skb is null, then replace it with the current packet,
        !           543:  . o   See if I can sending it now. 
        !           544:  . o   (NO): Enable interrupts and let the interrupt handler deal with it.
        !           545:  . o   (YES):Send it now.
        !           546: */
        !           547: static int smc_wait_to_send_packet( struct sk_buff * skb, struct device * dev )
        !           548: { 
        !           549:        struct smc_local *lp    = (struct smc_local *)dev->priv;
        !           550:        unsigned short ioaddr   = dev->base_addr;
        !           551:        word                    length;
        !           552:        unsigned short          numPages;
        !           553:        word                    time_out;       
        !           554:        
        !           555:        if ( lp->saved_skb) {
        !           556:                /* THIS SHOULD NEVER HAPPEN. */
        !           557:                lp->stats.tx_aborted_errors++;
        !           558:                printk(CARDNAME": Bad Craziness - sent packet while busy.\n" );
        !           559:                return 1;
        !           560:        }
        !           561:        lp->saved_skb = skb;
        !           562: 
        !           563:        length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
        !           564:                
        !           565:        /*
        !           566:        . the MMU wants the number of pages to be the number of 256 bytes 
        !           567:        . 'pages', minus 1 ( since a packet can't ever have 0 pages :) ) 
        !           568:        */
        !           569:        numPages = length / 256;
        !           570: 
        !           571:        if (numPages > 7 ) {
        !           572:                printk(CARDNAME": Far too big packet error. \n");
        !           573:                /* freeing the packet is a good thing here... but should                
        !           574:                 . any packets of this size get down here?   */
        !           575:                dev_kfree_skb (skb, FREE_WRITE);
        !           576:                lp->saved_skb = NULL;
        !           577:                /* this IS an error, but, i don't want the skb saved */
        !           578:                return 0; 
        !           579:        }
        !           580:        /* either way, a packet is waiting now */
        !           581:        lp->packets_waiting++;
        !           582:         
        !           583:        /* now, try to allocate the memory */
        !           584:        SMC_SELECT_BANK( 2 );
        !           585:        outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );
        !           586:        /*
        !           587:        . Performance Hack
        !           588:        .  
        !           589:        . wait a short amount of time.. if I can send a packet now, I send
        !           590:        . it now.  Otherwise, I enable an interrupt and wait for one to be
        !           591:        . available. 
        !           592:        .
        !           593:        . I could have handled this a slightly different way, by checking to
        !           594:        . see if any memory was available in the FREE MEMORY register.  However,
        !           595:        . either way, I need to generate an allocation, and the allocation works
        !           596:        . no matter what, so I saw no point in checking free memory.   
        !           597:        */ 
        !           598:        time_out = MEMORY_WAIT_TIME;
        !           599:        do { 
        !           600:                word    status;
        !           601: 
        !           602:                status = inb( ioaddr + INTERRUPT );
        !           603:                if ( status & IM_ALLOC_INT ) { 
        !           604:                        /* acknowledge the interrupt */
        !           605:                        outb( IM_ALLOC_INT, ioaddr + INTERRUPT );
        !           606:                        break;  
        !           607:                }
        !           608:        } while ( -- time_out );
        !           609: 
        !           610:        if ( !time_out ) {
        !           611:                /* oh well, wait until the chip finds memory later */ 
        !           612:                SMC_ENABLE_INT( IM_ALLOC_INT );
        !           613:                PRINTK2((CARDNAME": memory allocation deferred. \n"));
        !           614:                /* it's deferred, but I'll handle it later */
        !           615:                return 0;
        !           616:        }
        !           617:        /* or YES! I can send the packet now.. */
        !           618:        smc_hardware_send_packet(dev);
        !           619:        
        !           620:        return 0;
        !           621: }      
        !           622: 
        !           623: /*
        !           624:  . Function:  smc_hardware_send_packet(struct device * )
        !           625:  . Purpose:    
        !           626:  .     This sends the actual packet to the SMC9xxx chip.   
        !           627:  . 
        !           628:  . Algorithm:
        !           629:  .     First, see if a saved_skb is available.    
        !           630:  .             ( this should NOT be called if there is no 'saved_skb'
        !           631:  .     Now, find the packet number that the chip allocated
        !           632:  .     Point the data pointers at it in memory 
        !           633:  .     Set the length word in the chip's memory
        !           634:  .     Dump the packet to chip memory
        !           635:  .     Check if a last byte is needed ( odd length packet )
        !           636:  .             if so, set the control flag right 
        !           637:  .     Tell the card to send it 
        !           638:  .     Enable the transmit interrupt, so I know if it failed
        !           639:  .     Free the kernel data if I actually sent it.
        !           640: */
        !           641: static void smc_hardware_send_packet( struct device * dev ) 
        !           642: {
        !           643:        struct smc_local *lp = (struct smc_local *)dev->priv;
        !           644:        byte                    packet_no;
        !           645:        struct sk_buff *        skb = lp->saved_skb;
        !           646:        word                    length; 
        !           647:        unsigned short          ioaddr;
        !           648:        byte                    * buf;
        !           649: 
        !           650:        ioaddr = dev->base_addr;        
        !           651: 
        !           652:        if ( !skb ) {
        !           653:                PRINTK((CARDNAME": In XMIT with no packet to send \n"));
        !           654:                return;
        !           655:        }
        !           656:        length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
        !           657:        buf = skb->data;
        !           658: 
        !           659:        /* If I get here, I _know_ there is a packet slot waiting for me */
        !           660:        packet_no = inb( ioaddr + PNR_ARR + 1 ); 
        !           661:        if ( packet_no & 0x80 ) { 
        !           662:                /* or isn't there?  BAD CHIP! */
        !           663:                printk(KERN_DEBUG CARDNAME": Memory allocation failed. \n");
        !           664:                kfree(skb);
        !           665:                lp->saved_skb = NULL;
        !           666:                dev->tbusy = 0;
        !           667:                return;
        !           668:        }
        !           669: 
        !           670:        /* we have a packet address, so tell the card to use it */
        !           671:        outb( packet_no, ioaddr + PNR_ARR );
        !           672: 
        !           673:        /* point to the beginning of the packet */      
        !           674:        outw( PTR_AUTOINC , ioaddr + POINTER );
        !           675: 
        !           676:        PRINTK3((CARDNAME": Trying to xmit packet of length %x\n", length ));
        !           677: #if SMC_DEBUG > 2
        !           678:        print_packet( buf, length );
        !           679: #endif
        !           680: 
        !           681:        /* send the packet length ( +6 for status, length and ctl byte ) 
        !           682:           and the status word ( set to zeros ) */ 
        !           683: #ifdef USE_32_BIT
        !           684:        outl(  (length +6 ) << 16 , ioaddr + DATA_1 );
        !           685: #else
        !           686:        outw( 0, ioaddr + DATA_1 );      
        !           687:        /* send the packet length ( +6 for status words, length, and ctl*/              
        !           688:        outb( (length+6) & 0xFF,ioaddr + DATA_1 );
        !           689:        outb( (length+6) >> 8 , ioaddr + DATA_1 );
        !           690: #endif 
        !           691: 
        !           692:        /* send the actual data 
        !           693:         . I _think_ it's faster to send the longs first, and then 
        !           694:         . mop up by sending the last word.  It depends heavily 
        !           695:         . on alignment, at least on the 486.  Maybe it would be 
        !           696:         . a good idea to check which is optimal?  But that could take
        !           697:         . almost as much time as is saved? 
        !           698:        */      
        !           699: #ifdef USE_32_BIT 
        !           700:        if ( length & 0x2  ) {  
        !           701:                outsl(ioaddr + DATA_1, buf,  length >> 2 ); 
        !           702:                outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
        !           703:        }
        !           704:        else
        !           705:                outsl(ioaddr + DATA_1, buf,  length >> 2 ); 
        !           706: #else
        !           707:        outsw(ioaddr + DATA_1 , buf, (length ) >> 1);
        !           708: #endif
        !           709:        /* Send the last byte, if there is one.   */
        !           710:        
        !           711:        if ( (length & 1) == 0 ) {
        !           712:                outw( 0, ioaddr + DATA_1 );
        !           713:        } else {
        !           714:                outb( buf[length -1 ], ioaddr + DATA_1 );
        !           715:                outb( 0x20, ioaddr + DATA_1);
        !           716:        }
        !           717: 
        !           718:        /* enable the interrupts */
        !           719:        SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );
        !           720: 
        !           721:        /* and let the chipset deal with it */
        !           722:        outw( MC_ENQUEUE , ioaddr + MMU_CMD );
        !           723: 
        !           724:        PRINTK2((CARDNAME": Sent packet of length %d \n",length)); 
        !           725: 
        !           726:        lp->saved_skb = NULL;
        !           727:        dev_kfree_skb (skb, FREE_WRITE);
        !           728: 
        !           729:        dev->trans_start = jiffies;
        !           730: 
        !           731:        /* we can send another packet */
        !           732:        dev->tbusy = 0;
        !           733: 
        !           734: 
        !           735:        return;
        !           736: }
        !           737: 
        !           738: /*-------------------------------------------------------------------------
        !           739:  |
        !           740:  | smc_init( struct device * dev )  
        !           741:  |   Input parameters: 
        !           742:  |     dev->base_addr == 0, try to find all possible locations
        !           743:  |     dev->base_addr == 1, return failure code
        !           744:  |     dev->base_addr == 2, always allocate space,  and return success
        !           745:  |     dev->base_addr == <anything else>   this is the address to check 
        !           746:  |
        !           747:  |   Output: 
        !           748:  |     0 --> there is a device
        !           749:  |     anything else, error 
        !           750:  | 
        !           751:  ---------------------------------------------------------------------------
        !           752: */ 
        !           753: int smc_init(struct device *dev)
        !           754: {
        !           755:        int i;
        !           756:        int base_addr = dev ? dev->base_addr : 0;
        !           757: 
        !           758:        /*  try a specific location */
        !           759:        if (base_addr > 0x1ff)  {                
        !           760:                int     error; 
        !           761:                error = smc_probe(base_addr);
        !           762:                if ( 0 == error ) {
        !           763:                        return smc_initcard( dev, base_addr );
        !           764:                }
        !           765:                return error; 
        !           766:        } else {
        !           767:                if ( 0 != base_addr ) {
        !           768:                        return -ENXIO;
        !           769:                }
        !           770:        }
        !           771:        
        !           772:        /* check every ethernet address */
        !           773:        for (i = 0; smc_portlist[i]; i++) {
        !           774:                int ioaddr = smc_portlist[i];
        !           775: 
        !           776:                /* check if the area is available */
        !           777:                if (check_region( ioaddr , SMC_IO_EXTENT))
        !           778:                        continue;
        !           779: 
        !           780:                /* check this specific address */
        !           781:                if ( smc_probe( ioaddr ) == 0)  {  
        !           782:                        return smc_initcard( dev, ioaddr  ); 
        !           783:                }
        !           784:        }
        !           785: 
        !           786:        /* couldn't find anything */
        !           787:        return -ENODEV;
        !           788: }
        !           789: 
        !           790: #ifndef NO_AUTOPROBE
        !           791: /*----------------------------------------------------------------------
        !           792:  . smc_findirq 
        !           793:  . 
        !           794:  . This routine has a simple purpose -- make the SMC chip generate an 
        !           795:  . interrupt, so an auto-detect routine can detect it, and find the IRQ,
        !           796:  ------------------------------------------------------------------------
        !           797: */
        !           798: int smc_findirq( int ioaddr ) 
        !           799: {
        !           800:        int     timeout = 20;
        !           801: 
        !           802: 
        !           803:        /* I have to do a STI() here, because this is called from
        !           804:           a routine that does an CLI during this process, making it 
        !           805:           rather difficult to get interrupts for auto detection */
        !           806:        sti();
        !           807: 
        !           808:        autoirq_setup( 0 );
        !           809: 
        !           810:        /*
        !           811:         * What I try to do here is trigger an ALLOC_INT. This is done
        !           812:         * by allocating a small chunk of memory, which will give an interrupt
        !           813:         * when done.
        !           814:         */
        !           815: 
        !           816:          
        !           817:        SMC_SELECT_BANK(2);     
        !           818:        /* enable ALLOCation interrupts ONLY */
        !           819:        outb( IM_ALLOC_INT, ioaddr + INT_MASK );        
        !           820: 
        !           821:        /*
        !           822:         . Allocate 512 bytes of memory.  Note that the chip was just 
        !           823:         . reset so all the memory is available
        !           824:        */
        !           825:        outw( MC_ALLOC | 1, ioaddr + MMU_CMD );         
        !           826: 
        !           827:        /*
        !           828:         . Wait until positive that the interrupt has been generated
        !           829:        */
        !           830:        while ( timeout ) {
        !           831:                byte    int_status;
        !           832: 
        !           833:                int_status = inb( ioaddr + INTERRUPT );
        !           834: 
        !           835:                if ( int_status & IM_ALLOC_INT )        
        !           836:                        break;          /* got the interrupt */
        !           837:                timeout--;
        !           838:        }
        !           839:        /* there is really nothing that I can do here if timeout fails,
        !           840:           as autoirq_report will return a 0 anyway, which is what I
        !           841:           want in this case.   Plus, the clean up is needed in both
        !           842:           cases.  */
        !           843: 
        !           844:        /* DELAY HERE!
        !           845:           On a fast machine, the status might change before the interrupt
        !           846:           is given to the processor.  This means that the interrupt was 
        !           847:           never detected, and autoirq_report fails to report anything.  
        !           848:           This should fix autoirq_* problems. 
        !           849:        */
        !           850:        SMC_DELAY();
        !           851:        SMC_DELAY();            
        !           852:        
        !           853:        /* and disable all interrupts again */
        !           854:        outb( 0, ioaddr + INT_MASK );
        !           855: 
        !           856:        /* clear hardware interrupts again, because that's how it
        !           857:           was when I was called... */
        !           858:        cli();
        !           859: 
        !           860:        /* and return what I found */
        !           861:        return autoirq_report( 0 );     
        !           862: }
        !           863: #endif
        !           864:  
        !           865: /*----------------------------------------------------------------------
        !           866:  . Function: smc_probe( int ioaddr )
        !           867:  . 
        !           868:  . Purpose:  
        !           869:  .     Tests to see if a given ioaddr points to an SMC9xxx chip.
        !           870:  .     Returns a 0 on success  
        !           871:  . 
        !           872:  . Algorithm:
        !           873:  .     (1) see if the high byte of BANK_SELECT is 0x33
        !           874:  .     (2) compare the ioaddr with the base register's address
        !           875:  .     (3) see if I recognize the chip ID in the appropriate register
        !           876:  . 
        !           877:  .---------------------------------------------------------------------
        !           878:  */ 
        !           879: 
        !           880: static int smc_probe( int ioaddr ) 
        !           881: {
        !           882:        unsigned int    bank;
        !           883:        word    revision_register;      
        !           884:        word  base_address_register;
        !           885: 
        !           886:        /* First, see if the high byte is 0x33 */
        !           887:        bank = inw( ioaddr + BANK_SELECT );
        !           888:        if ( (bank & 0xFF00) != 0x3300 ) {
        !           889:                return -ENODEV;
        !           890:        }
        !           891:        /* The above MIGHT indicate a device, but I need to write to further
        !           892:                test this.  */
        !           893:        outw( 0x0, ioaddr + BANK_SELECT );
        !           894:        bank = inw( ioaddr + BANK_SELECT );
        !           895:        if ( (bank & 0xFF00 ) != 0x3300 ) {
        !           896:                return -ENODEV;
        !           897:        }
        !           898:        /* well, we've already written once, so hopefully another time won't
        !           899:           hurt.  This time, I need to switch the bank register to bank 1, 
        !           900:           so I can access the base address register */
        !           901:        SMC_SELECT_BANK(1);
        !           902:        base_address_register = inw( ioaddr + BASE );
        !           903:        if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) )  {
        !           904:                printk(CARDNAME ": IOADDR %x doesn't match configuration (%x)." 
        !           905:                        "Probably not a SMC chip\n",
        !           906:                        ioaddr, base_address_register >> 3 & 0x3E0 );
        !           907:                /* well, the base address register didn't match.  Must not have
        !           908:                   been a SMC chip after all. */
        !           909:                return -ENODEV;
        !           910:        }
        !           911: 
        !           912:        /*  check if the revision register is something that I recognize.  
        !           913:            These might need to be added to later, as future revisions 
        !           914:            could be added.  */
        !           915:        SMC_SELECT_BANK(3);
        !           916:        revision_register  = inw( ioaddr + REVISION );
        !           917:        if ( !chip_ids[ ( revision_register  >> 4 ) & 0xF  ] ) { 
        !           918:                /* I don't recognize this chip, so... */
        !           919:                printk(CARDNAME ": IO %x: Unrecognized revision register:"
        !           920:                        " %x, Contact author. \n", ioaddr, revision_register );
        !           921: 
        !           922:                return -ENODEV;
        !           923:        }
        !           924: 
        !           925:        /* at this point I'll assume that the chip is an SMC9xxx.   
        !           926:           It might be prudent to check a listing of MAC addresses 
        !           927:           against the hardware address, or do some other tests. */     
        !           928:        return 0;
        !           929: }
        !           930: 
        !           931: /*---------------------------------------------------------------
        !           932:  . Here I do typical initialization tasks. 
        !           933:  . 
        !           934:  . o  Initialize the structure if needed
        !           935:  . o  print out my vanity message if not done so already
        !           936:  . o  print out what type of hardware is detected
        !           937:  . o  print out the ethernet address
        !           938:  . o  find the IRQ 
        !           939:  . o  set up my private data 
        !           940:  . o  configure the dev structure with my subroutines
        !           941:  . o  actually GRAB the irq.
        !           942:  . o  GRAB the region 
        !           943:  .-----------------------------------------------------------------
        !           944: */
        !           945: static int  smc_initcard(struct device *dev, int ioaddr)
        !           946: {
        !           947:        int i;
        !           948: 
        !           949:        static unsigned version_printed = 0;
        !           950: 
        !           951:        /* registers */
        !           952:        word    revision_register;      
        !           953:        word    configuration_register; 
        !           954:        word    memory_info_register;
        !           955:        word    memory_cfg_register;
        !           956: 
        !           957:        const char *    version_string;
        !           958:        const char *    if_string;
        !           959:        int     memory;
        !           960: 
        !           961:        int   irqval;
        !           962: 
        !           963:        /* see if I need to initialize the ethernet card structure */
        !           964:        if (dev == NULL) {
        !           965: #ifdef SUPPORT_OLD_KERNEL
        !           966: #ifndef MODULE
        !           967: /* note: the old module interface does not support this call */
        !           968:                dev = init_etherdev( 0, sizeof( struct smc_local ), 0 );
        !           969: #endif 
        !           970: #else
        !           971:                dev = init_etherdev(0, 0);
        !           972: #endif 
        !           973:                if (dev == NULL)
        !           974:                        return -ENOMEM;
        !           975:        }
        !           976: 
        !           977:        if (version_printed++ == 0)
        !           978:                printk("%s", version);
        !           979: 
        !           980:        /* fill in some of the fields */
        !           981:        dev->base_addr = ioaddr;
        !           982: 
        !           983:        /*
        !           984:         . Get the MAC address ( bank 1, regs 4 - 9 )
        !           985:        */
        !           986:        SMC_SELECT_BANK( 1 );
        !           987:        for ( i = 0; i < 6; i += 2 ) { 
        !           988:                word    address;
        !           989: 
        !           990:                address = inw( ioaddr + ADDR0 + i  );
        !           991:                dev->dev_addr[ i + 1] = address >> 8;
        !           992:                dev->dev_addr[ i ] = address & 0xFF;    
        !           993:        }
        !           994: 
        !           995:        /* get the memory information */
        !           996: 
        !           997:        SMC_SELECT_BANK( 0 );
        !           998:        memory_info_register = inw( ioaddr + MIR );
        !           999:        memory_cfg_register  = inw( ioaddr + MCR );
        !          1000:        memory = ( memory_cfg_register >> 9 )  & 0x7;  /* multiplier */
        !          1001:        memory *= 256 * ( memory_info_register & 0xFF );
        !          1002: 
        !          1003:        /* 
        !          1004:         Now, I want to find out more about the chip.  This is sort of
        !          1005:         redundant, but it's cleaner to have it in both, rather than having
        !          1006:         one VERY long probe procedure.
        !          1007:        */      
        !          1008:        SMC_SELECT_BANK(3);
        !          1009:        revision_register  = inw( ioaddr + REVISION );
        !          1010:        version_string = chip_ids[ ( revision_register  >> 4 ) & 0xF  ];
        !          1011:        if ( !version_string ) {
        !          1012:                /* I shouldn't get here because this call was done before.... */ 
        !          1013:                return -ENODEV;
        !          1014:        }
        !          1015: 
        !          1016:        /* is it using AUI or 10BaseT ? */
        !          1017:        if ( dev->if_port == 0 ) {
        !          1018:                SMC_SELECT_BANK(1);
        !          1019:                configuration_register = inw( ioaddr + CONFIG );
        !          1020:                if ( configuration_register & CFG_AUI_SELECT )  
        !          1021:                        dev->if_port = 2;
        !          1022:                else
        !          1023:                        dev->if_port = 1;
        !          1024:        }
        !          1025:        if_string = interfaces[ dev->if_port - 1 ];
        !          1026: 
        !          1027:        /* now, reset the chip, and put it into a known state */
        !          1028:        smc_reset( ioaddr );
        !          1029: 
        !          1030:        /*
        !          1031:         . If dev->irq is 0, then the device has to be banged on to see
        !          1032:         . what the IRQ is. 
        !          1033:         . 
        !          1034:         . This banging doesn't always detect the IRQ, for unknown reasons.
        !          1035:         . a workaround is to reset the chip and try again.  
        !          1036:         .    
        !          1037:         . Interestingly, the DOS packet driver *SETS* the IRQ on the card to
        !          1038:         . be what is requested on the command line.   I don't do that, mostly
        !          1039:         . because the card that I have uses a non-standard method of accessing
        !          1040:         . the IRQs, and because this _should_ work in most configurations.
        !          1041:         .
        !          1042:         . Specifying an IRQ is done with the assumption that the user knows 
        !          1043:         . what (s)he is doing.  No checking is done!!!!
        !          1044:         .
        !          1045:        */
        !          1046: #ifndef NO_AUTOPROBE
        !          1047:        if ( dev->irq < 2 ) {
        !          1048:                int     trials;
        !          1049: 
        !          1050:                trials = 3;
        !          1051:                while ( trials-- ) { 
        !          1052:                        dev->irq = smc_findirq( ioaddr );
        !          1053:                        if ( dev->irq ) 
        !          1054:                                break;
        !          1055:                        /* kick the card and try again */
        !          1056:                        smc_reset( ioaddr );
        !          1057:                }
        !          1058:        } 
        !          1059:        if (dev->irq == 0 ) {
        !          1060:                printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n");
        !          1061:                return -ENODEV;
        !          1062:        }
        !          1063: #else
        !          1064:        if (dev->irq == 0 ) {
        !          1065:                printk(CARDNAME
        !          1066:                ": Autoprobing IRQs is not supported for old kernels.\n");
        !          1067:                return -ENODEV;
        !          1068:        }
        !          1069: #endif
        !          1070:        if (dev->irq == 2) {
        !          1071:                /* Fixup for users that don't know that IRQ 2 is really IRQ 9,
        !          1072:                 * or don't know which one to set.
        !          1073:                 */
        !          1074:                dev->irq = 9;
        !          1075:        }
        !          1076: 
        !          1077:        /* now, print out the card info, in a short format.. */
        !          1078:        
        !          1079:        printk(CARDNAME ": %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ",
        !          1080:                version_string, revision_register & 0xF, ioaddr, dev->irq, 
        !          1081:                if_string, memory );
        !          1082:        /*
        !          1083:         . Print the Ethernet address 
        !          1084:        */
        !          1085:        printk("ADDR: ");
        !          1086:        for (i = 0; i < 5; i++)
        !          1087:                printk("%2.2x:", dev->dev_addr[i] );
        !          1088:        printk("%2.2x \n", dev->dev_addr[5] );
        !          1089: 
        !          1090: 
        !          1091:        /* Initialize the private structure. */
        !          1092:        if (dev->priv == NULL) {
        !          1093:                dev->priv = kmalloc(sizeof(struct smc_local), GFP_KERNEL);
        !          1094:                if (dev->priv == NULL)
        !          1095:                        return -ENOMEM;
        !          1096:        }
        !          1097:        /* set the private data to zero by default */
        !          1098:        memset(dev->priv, 0, sizeof(struct smc_local));
        !          1099: 
        !          1100:        /* Fill in the fields of the device structure with ethernet values. */
        !          1101:        ether_setup(dev);
        !          1102: 
        !          1103:        /* Grab the IRQ */
        !          1104:        irqval = request_irq(dev->irq, &smc_interrupt, 0, CARDNAME, NULL);
        !          1105:        if (irqval) {
        !          1106:                  printk(CARDNAME": unable to get IRQ %d (irqval=%d).\n",
        !          1107:                dev->irq, irqval);
        !          1108:                  return -EAGAIN;
        !          1109:        }
        !          1110:        irq2dev_map[dev->irq] = dev;
        !          1111: 
        !          1112:        /* Grab the region so that no one else tries to probe our ioports. */
        !          1113:        request_region(ioaddr, SMC_IO_EXTENT, CARDNAME);
        !          1114: 
        !          1115:        dev->open                       = smc_open;
        !          1116:        dev->stop                       = smc_close;
        !          1117:        dev->hard_start_xmit            = smc_send_packet;
        !          1118:        dev->get_stats                  = smc_query_statistics;
        !          1119: #ifdef HAVE_MULTICAST
        !          1120:        dev->set_multicast_list         = &smc_set_multicast_list;
        !          1121: #endif
        !          1122: 
        !          1123:        return 0;
        !          1124: }
        !          1125: 
        !          1126: #if SMC_DEBUG > 2
        !          1127: static void print_packet( byte * buf, int length ) 
        !          1128: { 
        !          1129: #if 0
        !          1130:        int i;
        !          1131:        int remainder;
        !          1132:        int lines;
        !          1133:        
        !          1134:        printk("Packet of length %d \n", length );
        !          1135:        lines = length / 16;
        !          1136:        remainder = length % 16;
        !          1137: 
        !          1138:        for ( i = 0; i < lines ; i ++ ) { 
        !          1139:                int cur;
        !          1140: 
        !          1141:                for ( cur = 0; cur < 8; cur ++ ) { 
        !          1142:                        byte a, b;
        !          1143: 
        !          1144:                        a = *(buf ++ );
        !          1145:                        b = *(buf ++ );
        !          1146:                        printk("%02x%02x ", a, b );
        !          1147:                }
        !          1148:                printk("\n");
        !          1149:        }
        !          1150:        for ( i = 0; i < remainder/2 ; i++ ) {
        !          1151:                byte a, b;
        !          1152: 
        !          1153:                a = *(buf ++ );
        !          1154:                b = *(buf ++ );
        !          1155:                printk("%02x%02x ", a, b );
        !          1156:        }
        !          1157:        printk("\n");
        !          1158: #endif
        !          1159: }
        !          1160: #endif 
        !          1161: 
        !          1162: 
        !          1163: /*
        !          1164:  * Open and Initialize the board
        !          1165:  * 
        !          1166:  * Set up everything, reset the card, etc ..
        !          1167:  *
        !          1168:  */
        !          1169: static int smc_open(struct device *dev)
        !          1170: {
        !          1171:        int     ioaddr = dev->base_addr;
        !          1172: 
        !          1173:        int     i;      /* used to set hw ethernet address */ 
        !          1174: 
        !          1175:        /* clear out all the junk that was put here before... */
        !          1176:        memset(dev->priv, 0, sizeof(struct smc_local));
        !          1177: 
        !          1178:        dev->tbusy      = 0;
        !          1179:        dev->interrupt  = 0;
        !          1180:        dev->start      = 1;
        !          1181: #ifdef MODULE
        !          1182:        MOD_INC_USE_COUNT;
        !          1183: #endif
        !          1184: 
        !          1185:        /* reset the hardware */
        !          1186: 
        !          1187:        smc_reset( ioaddr );
        !          1188:        smc_enable( ioaddr );
        !          1189: 
        !          1190:        /* Select which interface to use */
        !          1191:         
        !          1192:        SMC_SELECT_BANK( 1 );
        !          1193:        if ( dev->if_port == 1 ) {      
        !          1194:                outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT, 
        !          1195:                        ioaddr + CONFIG );                                                      
        !          1196:        } 
        !          1197:        else if ( dev->if_port == 2 ) { 
        !          1198:                outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT, 
        !          1199:                        ioaddr + CONFIG );                                                      
        !          1200:        }
        !          1201: 
        !          1202:        /*
        !          1203:                According to Becker, I have to set the hardware address
        !          1204:                at this point, because the (l)user can set it with an
        !          1205:                ioctl.  Easily done... 
        !          1206:        */
        !          1207:        SMC_SELECT_BANK( 1 );
        !          1208:        for ( i = 0; i < 6; i += 2 ) { 
        !          1209:                word    address;
        !          1210:                
        !          1211:                address = dev->dev_addr[ i + 1 ] << 8 ;
        !          1212:                address  |= dev->dev_addr[ i ];
        !          1213:                outw( address, ioaddr + ADDR0 + i );
        !          1214:        }
        !          1215:        return 0;
        !          1216: }
        !          1217: 
        !          1218: /*--------------------------------------------------------
        !          1219:  . Called by the kernel to send a packet out into the void
        !          1220:  . of the net.  This routine is largely based on 
        !          1221:  . skeleton.c, from Becker.   
        !          1222:  .--------------------------------------------------------
        !          1223: */
        !          1224: static int smc_send_packet(struct sk_buff *skb, struct device *dev)
        !          1225: {
        !          1226:        if (dev->tbusy) {
        !          1227:                /* If we get here, some higher level has decided we are broken.
        !          1228:                   There should really be a "kick me" function call instead. */
        !          1229:                int tickssofar = jiffies - dev->trans_start;
        !          1230:                if (tickssofar < 5)
        !          1231:                        return 1;
        !          1232:                printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n",
        !          1233:                        tx_done(dev) ? "IRQ conflict" : 
        !          1234:                        "network cable problem");
        !          1235:                /* "kick" the adaptor */
        !          1236:                smc_reset( dev->base_addr );
        !          1237:                smc_enable( dev->base_addr );
        !          1238: 
        !          1239:                dev->tbusy = 0;
        !          1240:                dev->trans_start = jiffies;
        !          1241:                /* clear anything saved */
        !          1242:                ((struct smc_local *)dev->priv)->saved_skb = NULL;
        !          1243:        }
        !          1244: 
        !          1245:        /* If some higher layer thinks we've missed an tx-done interrupt
        !          1246:           we are passed NULL. Caution: dev_tint() handles the cli()/sti()
        !          1247:           itself. */
        !          1248:        if (skb == NULL) {
        !          1249:                dev_tint(dev);
        !          1250:                return 0;
        !          1251:        }
        !          1252: 
        !          1253:        /* Block a timer-based transmit from overlapping.  This could better be
        !          1254:           done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
        !          1255:        if (set_bit(0, (void*)&dev->tbusy) != 0) {
        !          1256:                printk(KERN_WARNING CARDNAME": Transmitter access conflict.\n");
        !          1257:                dev_kfree_skb (skb, FREE_WRITE);
        !          1258:        } else {
        !          1259:                /* Well, I want to send the packet.. but I don't know 
        !          1260:                   if I can send it right now...  */    
        !          1261:                return smc_wait_to_send_packet( skb, dev );
        !          1262:        }
        !          1263:        return 0;
        !          1264: }
        !          1265: 
        !          1266: /*--------------------------------------------------------------------
        !          1267:  .
        !          1268:  . This is the main routine of the driver, to handle the device when
        !          1269:  . it needs some attention.
        !          1270:  .
        !          1271:  . So:
        !          1272:  .   first, save state of the chipset
        !          1273:  .   branch off into routines to handle each case, and acknowledge 
        !          1274:  .         each to the interrupt register
        !          1275:  .   and finally restore state. 
        !          1276:  .  
        !          1277:  ---------------------------------------------------------------------*/
        !          1278: #ifdef REALLY_NEW_KERNEL
        !          1279: static void smc_interrupt(int irq, void * dev_id,  struct pt_regs * regs)
        !          1280: #else 
        !          1281: static void smc_interrupt(int irq, struct pt_regs * regs)
        !          1282: #endif 
        !          1283: {
        !          1284:        struct device *dev      = (struct device *)(irq2dev_map[irq]);
        !          1285:        int ioaddr              = dev->base_addr;
        !          1286:        struct smc_local *lp    = (struct smc_local *)dev->priv;
        !          1287: 
        !          1288:        byte    status;
        !          1289:        word    card_stats;
        !          1290:        byte    mask;
        !          1291:        int     timeout;
        !          1292:        /* state registers */
        !          1293:        word    saved_bank;
        !          1294:        word    saved_pointer;
        !          1295: 
        !          1296: 
        !          1297:        
        !          1298:        PRINTK3((CARDNAME": SMC interrupt started \n"));
        !          1299: 
        !          1300:        if (dev == NULL) {
        !          1301:                printk(KERN_WARNING  CARDNAME": irq %d for unknown device.\n", 
        !          1302:                        irq);
        !          1303:                return;
        !          1304:        }
        !          1305: 
        !          1306: /* will Linux let this happen ??  If not, this costs some speed */
        !          1307:        if ( dev->interrupt ) { 
        !          1308:                printk(KERN_WARNING CARDNAME": interrupt inside interrupt.\n");
        !          1309:                return;
        !          1310:        }
        !          1311:                
        !          1312:        dev->interrupt = 1;
        !          1313: 
        !          1314:        saved_bank = inw( ioaddr + BANK_SELECT );
        !          1315: 
        !          1316:        SMC_SELECT_BANK(2);
        !          1317:        saved_pointer = inw( ioaddr + POINTER );
        !          1318: 
        !          1319:        mask = inb( ioaddr + INT_MASK );
        !          1320:        /* clear all interrupts */
        !          1321:        outb( 0, ioaddr + INT_MASK );
        !          1322: 
        !          1323: 
        !          1324:        /* set a timeout value, so I don't stay here forever */
        !          1325:        timeout = 4;
        !          1326: 
        !          1327:        PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x \n", mask ));
        !          1328:        do {    
        !          1329:                /* read the status flag, and mask it */
        !          1330:                status = inb( ioaddr + INTERRUPT ) & mask;
        !          1331:                if (!status )
        !          1332:                        break;
        !          1333: 
        !          1334:                PRINTK3((KERN_WARNING CARDNAME
        !          1335:                        ": Handling interrupt status %x \n", status )); 
        !          1336: 
        !          1337:                if (status & IM_RCV_INT) {
        !          1338:                        /* Got a packet(s). */
        !          1339:                        PRINTK2((KERN_WARNING CARDNAME
        !          1340:                                ": Receive Interrupt\n"));
        !          1341:                        smc_rcv(dev);
        !          1342:                } else if (status & IM_TX_INT ) {
        !          1343:                        PRINTK2((KERN_WARNING CARDNAME
        !          1344:                                ": TX ERROR handled\n"));
        !          1345:                        smc_tx(dev);
        !          1346:                        outb(IM_TX_INT, ioaddr + INTERRUPT ); 
        !          1347:                } else if (status & IM_TX_EMPTY_INT ) {
        !          1348:                        /* update stats */
        !          1349:                        SMC_SELECT_BANK( 0 );
        !          1350:                        card_stats = inw( ioaddr + COUNTER );
        !          1351:                        /* single collisions */
        !          1352:                        lp->stats.collisions += card_stats & 0xF;
        !          1353:                        card_stats >>= 4;
        !          1354:                        /* multiple collisions */
        !          1355:                        lp->stats.collisions += card_stats & 0xF;
        !          1356: 
        !          1357:                        /* these are for when linux supports these statistics */
        !          1358: #if 0 
        !          1359:                        card_stats >>= 4;
        !          1360:                        /* deferred */
        !          1361:                        card_stats >>= 4;
        !          1362:                        /* excess deferred */
        !          1363: #endif 
        !          1364:                        SMC_SELECT_BANK( 2 );
        !          1365:                        PRINTK2((KERN_WARNING CARDNAME 
        !          1366:                                ": TX_BUFFER_EMPTY handled\n"));
        !          1367:                        outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
        !          1368:                        mask &= ~IM_TX_EMPTY_INT;
        !          1369:                        lp->stats.tx_packets += lp->packets_waiting;
        !          1370:                        lp->packets_waiting = 0;
        !          1371: 
        !          1372:                } else if (status & IM_ALLOC_INT ) {
        !          1373:                        PRINTK2((KERN_DEBUG CARDNAME
        !          1374:                                ": Allocation interrupt \n"));
        !          1375:                        /* clear this interrupt so it doesn't happen again */
        !          1376:                        mask &= ~IM_ALLOC_INT;
        !          1377:                
        !          1378:                        smc_hardware_send_packet( dev );
        !          1379:                        
        !          1380:                        /* enable xmit interrupts based on this */
        !          1381:                        mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
        !          1382: 
        !          1383:                        /* and let the card send more packets to me */
        !          1384:                        mark_bh( NET_BH );
        !          1385: 
        !          1386:                        PRINTK2((CARDNAME": Handoff done successfully.\n"));    
        !          1387:                } else if (status & IM_RX_OVRN_INT ) {
        !          1388:                        lp->stats.rx_errors++;
        !          1389:                        lp->stats.rx_fifo_errors++;                     
        !          1390:                        outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
        !          1391:                } else if (status & IM_EPH_INT ) {
        !          1392:                        PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT \n"));
        !          1393:                } else if (status & IM_ERCV_INT ) {
        !          1394:                        PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT \n"));
        !          1395:                        outb( IM_ERCV_INT, ioaddr + INTERRUPT );
        !          1396:                }
        !          1397:        } while ( timeout -- ); 
        !          1398: 
        !          1399:        
        !          1400:        /* restore state register */
        !          1401:        SMC_SELECT_BANK( 2 );
        !          1402:        outb( mask, ioaddr + INT_MASK );
        !          1403:        
        !          1404:        PRINTK3(( KERN_WARNING CARDNAME ": MASK is now %x \n", mask ));
        !          1405:        outw( saved_pointer, ioaddr + POINTER );
        !          1406: 
        !          1407:        SMC_SELECT_BANK( saved_bank );
        !          1408: 
        !          1409:        dev->interrupt = 0;
        !          1410:        PRINTK3((CARDNAME ": Interrupt done\n"));
        !          1411:        return;
        !          1412: }
        !          1413: 
        !          1414: /*-------------------------------------------------------------
        !          1415:  .
        !          1416:  . smc_rcv -  receive a packet from the card
        !          1417:  .
        !          1418:  . There is ( at least ) a packet waiting to be read from
        !          1419:  . chip-memory.
        !          1420:  . 
        !          1421:  . o Read the status 
        !          1422:  . o If an error, record it  
        !          1423:  . o otherwise, read in the packet 
        !          1424:  --------------------------------------------------------------
        !          1425: */
        !          1426: static void smc_rcv(struct device *dev)
        !          1427: {
        !          1428:        struct smc_local *lp = (struct smc_local *)dev->priv;
        !          1429:        int     ioaddr = dev->base_addr;
        !          1430:        int     packet_number;
        !          1431:        word    status;
        !          1432:        word    packet_length; 
        !          1433:        
        !          1434:        /* assume bank 2 */
        !          1435: 
        !          1436:        packet_number = inw( ioaddr + FIFO_PORTS );
        !          1437: 
        !          1438:        if ( packet_number & FP_RXEMPTY ) {
        !          1439:                /* we got called , but nothing was on the FIFO */
        !          1440:                PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO. \n"));
        !          1441:                /* don't need to restore anything */
        !          1442:                return;
        !          1443:        }
        !          1444:                
        !          1445:        /*  start reading from the start of the packet */
        !          1446:        outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );
        !          1447: 
        !          1448:        /* First two words are status and packet_length */      
        !          1449:        status          = inw( ioaddr + DATA_1 );
        !          1450:        packet_length   = inw( ioaddr + DATA_1 );
        !          1451:        
        !          1452:        packet_length &= 0x07ff;  /* mask off top bits */
        !          1453: 
        !          1454:        PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));
        !          1455:        /* 
        !          1456:         . the packet length contains 3 extra words : 
        !          1457:         . status, length, and a extra word with an odd byte .
        !          1458:        */
        !          1459:        packet_length -= 6; 
        !          1460:        
        !          1461:        if ( !(status & RS_ERRORS ) ){                  
        !          1462:                /* do stuff to make a new packet */
        !          1463:                struct sk_buff  * skb;
        !          1464:                byte            * data;
        !          1465: 
        !          1466:                /* read one extra byte */
        !          1467:                if ( status & RS_ODDFRAME )     
        !          1468:                        packet_length++;        
        !          1469: 
        !          1470:                /* set multicast stats */ 
        !          1471:                if ( status & RS_MULTICAST )
        !          1472:                        lp->stats.multicast++;
        !          1473: 
        !          1474: #ifdef SUPPORT_OLD_KERNEL
        !          1475:                skb = alloc_skb( packet_length + 5, GFP_ATOMIC );
        !          1476: #else  
        !          1477:                skb = dev_alloc_skb( packet_length + 5); 
        !          1478: #endif
        !          1479: 
        !          1480:                if ( skb == NULL ) {    
        !          1481:                        printk(KERN_NOTICE CARDNAME
        !          1482:                        ": Low memory, packet dropped.\n");
        !          1483:                        lp->stats.rx_dropped++;
        !          1484:                }
        !          1485: 
        !          1486:                /* 
        !          1487:                 ! This should work without alignment, but it could be
        !          1488:                 ! in the worse case 
        !          1489:                */
        !          1490: #ifndef SUPPORT_OLD_KERNEL
        !          1491:                /* TODO: Should I use 32bit alignment here ? */
        !          1492:                skb_reserve( skb, 2 );   /* 16 bit alignment */
        !          1493: #endif
        !          1494: 
        !          1495:                skb->dev = dev;
        !          1496: #ifdef SUPPORT_OLD_KERNEL
        !          1497:                skb->len = packet_length;
        !          1498:                data = skb->data;
        !          1499: #else
        !          1500:                data = skb_put( skb, packet_length);
        !          1501: #endif
        !          1502: #ifdef USE_32_BIT
        !          1503:                /* QUESTION:  Like in the TX routine, do I want                 
        !          1504:                   to send the DWORDs or the bytes first, or some
        !          1505:                   mixture.  A mixture might improve already slow PIO
        !          1506:                   performance  */
        !          1507:                PRINTK3((" Reading %d dwords (and %d bytes) \n", 
        !          1508:                        packet_length >> 2, packet_length & 3 ));
        !          1509:                insl(ioaddr + DATA_1 , data, packet_length >> 2 ); 
        !          1510:                /* read the left over bytes */
        !          1511:                insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC), 
        !          1512:                        packet_length & 0x3  );
        !          1513: #else
        !          1514:                PRINTK3((" Reading %d words and %d byte(s) \n", 
        !          1515:                        (packet_length >> 1 ), packet_length & 1 );
        !          1516:                if ( packet_length & 1 ) 
        !          1517:                        *(data++) = inb( ioaddr + DATA_1 ); 
        !          1518:                insw(ioaddr + DATA_1 , data, (packet_length + 1 ) >> 1);
        !          1519:                if ( packet_length & 1 ) {
        !          1520:                        data += packet_length & ~1;
        !          1521:                        *((data++) = inb( ioaddr + DATA_1 ); 
        !          1522:                }
        !          1523: #endif                 
        !          1524: #if    SMC_DEBUG > 2   
        !          1525:                        print_packet( data, packet_length );
        !          1526: #endif
        !          1527: 
        !          1528: #ifndef SUPPORT_OLD_KERNEL
        !          1529:                skb->protocol = eth_type_trans(skb, dev ); 
        !          1530: #endif
        !          1531:                netif_rx(skb);
        !          1532:                lp->stats.rx_packets++;
        !          1533:        } else {
        !          1534:                /* error ... */
        !          1535:                lp->stats.rx_errors++;
        !          1536:                        
        !          1537:                if ( status & RS_ALGNERR )  lp->stats.rx_frame_errors++;  
        !          1538:                if ( status & (RS_TOOSHORT | RS_TOOLONG ) )  
        !          1539:                        lp->stats.rx_length_errors++;
        !          1540:                if ( status & RS_BADCRC)        lp->stats.rx_crc_errors++;
        !          1541:        }
        !          1542:        /*  error or good, tell the card to get rid of this packet */
        !          1543:        outw( MC_RELEASE, ioaddr + MMU_CMD );
        !          1544: 
        !          1545: 
        !          1546:        return;
        !          1547: }
        !          1548: 
        !          1549: 
        !          1550: /************************************************************************* 
        !          1551:  . smc_tx
        !          1552:  . 
        !          1553:  . Purpose:  Handle a transmit error message.   This will only be called
        !          1554:  .   when an error, because of the AUTO_RELEASE mode. 
        !          1555:  . 
        !          1556:  . Algorithm:
        !          1557:  .     Save pointer and packet no
        !          1558:  .     Get the packet no from the top of the queue
        !          1559:  .     check if it's valid ( if not, is this an error??? )
        !          1560:  .     read the status word 
        !          1561:  .     record the error
        !          1562:  .     ( resend?  Not really, since we don't want old packets around )
        !          1563:  .     Restore saved values 
        !          1564:  ************************************************************************/ 
        !          1565: static void smc_tx( struct device * dev ) 
        !          1566: {
        !          1567:        int     ioaddr = dev->base_addr;
        !          1568:        struct smc_local *lp = (struct smc_local *)dev->priv;
        !          1569:        byte saved_packet;
        !          1570:        byte packet_no;
        !          1571:        word tx_status;
        !          1572: 
        !          1573: 
        !          1574:        /* assume bank 2  */
        !          1575: 
        !          1576:        saved_packet = inb( ioaddr + PNR_ARR );
        !          1577:        packet_no = inw( ioaddr + FIFO_PORTS );
        !          1578:        packet_no &= 0x7F;
        !          1579: 
        !          1580:        /* select this as the packet to read from */
        !          1581:        outb( packet_no, ioaddr + PNR_ARR ); 
        !          1582:        
        !          1583:        /* read the first word from this packet */      
        !          1584:        outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
        !          1585: 
        !          1586:        tx_status = inw( ioaddr + DATA_1 );
        !          1587:        PRINTK3((CARDNAME": TX DONE STATUS: %4x \n", tx_status ));
        !          1588:        
        !          1589:        lp->stats.tx_errors++;
        !          1590:        if ( tx_status & TS_LOSTCAR ) lp->stats.tx_carrier_errors++;
        !          1591:        if ( tx_status & TS_LATCOL  ) {
        !          1592:                printk(KERN_DEBUG CARDNAME 
        !          1593:                        ": Late collision occurred on last xmit.\n");
        !          1594:                lp->stats.tx_window_errors++;
        !          1595:        }
        !          1596: #if 0
        !          1597:                if ( tx_status & TS_16COL ) { ... }
        !          1598: #endif 
        !          1599: 
        !          1600:        if ( tx_status & TS_SUCCESS ) {  
        !          1601:                printk(CARDNAME": Successful packet caused interrupt \n");
        !          1602:        } 
        !          1603:        /* re-enable transmit */
        !          1604:        SMC_SELECT_BANK( 0 );
        !          1605:        outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
        !          1606: 
        !          1607:        /* kill the packet */                   
        !          1608:        SMC_SELECT_BANK( 2 );
        !          1609:        outw( MC_FREEPKT, ioaddr + MMU_CMD );
        !          1610: 
        !          1611:        /* one less packet waiting for me */
        !          1612:        lp->packets_waiting--;
        !          1613:                
        !          1614:        outb( saved_packet, ioaddr + PNR_ARR );
        !          1615:        return;
        !          1616: }
        !          1617: 
        !          1618: /*----------------------------------------------------
        !          1619:  . smc_close
        !          1620:  . 
        !          1621:  . this makes the board clean up everything that it can
        !          1622:  . and not talk to the outside world.   Caused by
        !          1623:  . an 'ifconfig ethX down'
        !          1624:  .
        !          1625:  -----------------------------------------------------*/
        !          1626: static int smc_close(struct device *dev)
        !          1627: {
        !          1628:        dev->tbusy = 1;
        !          1629:        dev->start = 0;
        !          1630: 
        !          1631:        /* clear everything */
        !          1632:        smc_shutdown( dev->base_addr );
        !          1633: 
        !          1634:        /* Update the statistics here. */
        !          1635: #ifdef MODULE
        !          1636:        MOD_DEC_USE_COUNT;
        !          1637: #endif
        !          1638: 
        !          1639:        return 0;
        !          1640: }
        !          1641: 
        !          1642: /*------------------------------------------------------------
        !          1643:  . Get the current statistics. 
        !          1644:  . This may be called with the card open or closed. 
        !          1645:  .-------------------------------------------------------------*/
        !          1646: static struct enet_statistics * smc_query_statistics(struct device *dev) {
        !          1647:        struct smc_local *lp = (struct smc_local *)dev->priv;
        !          1648: 
        !          1649:        return &lp->stats;
        !          1650: }
        !          1651: 
        !          1652: /*-----------------------------------------------------------
        !          1653:  . smc_set_multicast_list
        !          1654:  .  
        !          1655:  . This routine will, depending on the values passed to it,
        !          1656:  . either make it accept multicast packets, go into 
        !          1657:  . promiscuous mode ( for TCPDUMP and cousins ) or accept
        !          1658:  . a select set of multicast packets  
        !          1659: */
        !          1660: #ifdef SUPPORT_OLD_KERNEL
        !          1661: static void smc_set_multicast_list( struct device * dev, 
        !          1662:                        int num_addrs, void * addrs )   
        !          1663: #else
        !          1664: static void smc_set_multicast_list(struct device *dev) 
        !          1665: #endif 
        !          1666: {
        !          1667:        short ioaddr = dev->base_addr;
        !          1668: 
        !          1669:        SMC_SELECT_BANK(0);
        !          1670: #ifdef  SUPPORT_OLD_KERNEL
        !          1671:        if ( num_addrs < 0 )  
        !          1672: #else
        !          1673:        if ( dev->flags & IFF_PROMISC ) 
        !          1674: #endif 
        !          1675:                outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
        !          1676: 
        !          1677: /* BUG?  I never disable promiscuous mode if multicasting was turned on. 
        !          1678:    Now, I turn off promiscuous mode, but I don't do anything to multicasting
        !          1679:    when promiscuous mode is turned on. 
        !          1680: */
        !          1681: 
        !          1682:        /* Here, I am setting this to accept all multicast packets.  
        !          1683:           I don't need to zero the multicast table, because the flag is
        !          1684:           checked before the table is 
        !          1685:        */
        !          1686: #ifdef  SUPPORT_OLD_KERNEL 
        !          1687:        else if ( num_addrs > 20 )      /* arbitrary constant */
        !          1688: #else
        !          1689:        else if (dev->flags & IFF_ALLMULTI)  
        !          1690: #endif 
        !          1691:                outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR ); 
        !          1692: 
        !          1693:        /* We just get all multicast packets even if we only want them
        !          1694:         . from one source.  This will be changed at some future
        !          1695:         . point. */
        !          1696: #ifdef  SUPPORT_OLD_KERNEL
        !          1697:        else if (num_addrs > 0 ) { 
        !          1698: /* the old kernel support will not have hardware multicast support. It would
        !          1699:    involve more kludges, and make the multicast setting code even worse.  
        !          1700:    Instead, just use the ALMUL method.   This is reasonable, considering that
        !          1701:    it is seldom used
        !          1702: */
        !          1703:                outw( inw( ioaddr + RCR ) & ~RCR_PROMISC, ioaddr + RCR );
        !          1704:                outw( inw( ioadddr + RCR ) | RCR_ALMUL, ioadddr + RCR );
        !          1705:        }
        !          1706: #else
        !          1707:        else if (dev->mc_count )  { 
        !          1708:                /* support hardware multicasting */
        !          1709:                
        !          1710:                /* be sure I get rid of flags I might have set */       
        !          1711:                outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL), 
        !          1712:                        ioaddr + RCR );
        !          1713:                /* NOTE: this has to set the bank, so make sure it is the
        !          1714:                   last thing called.  The bank is set to zero at the top */
        !          1715:                smc_setmulticast( ioaddr, dev->mc_count, dev->mc_list );
        !          1716:        }
        !          1717: #endif
        !          1718:        else  {
        !          1719:                outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL), 
        !          1720:                        ioaddr + RCR );
        !          1721: 
        !          1722:                /* 
        !          1723:                  since I'm disabling all multicast entirely, I need to 
        !          1724:                  clear the multicast list 
        !          1725:                */
        !          1726:                SMC_SELECT_BANK( 3 );
        !          1727:                outw( 0, ioaddr + MULTICAST1 ); 
        !          1728:                outw( 0, ioaddr + MULTICAST2 ); 
        !          1729:                outw( 0, ioaddr + MULTICAST3 ); 
        !          1730:                outw( 0, ioaddr + MULTICAST4 ); 
        !          1731:        }
        !          1732: }
        !          1733: 
        !          1734: #ifdef MODULE
        !          1735: 
        !          1736: static char devicename[9] = { 0, };
        !          1737: static struct device devSMC9194 = {
        !          1738:        devicename, /* device name is inserted by linux/drivers/net/net_init.c */
        !          1739:        0, 0, 0, 0,
        !          1740:        0, 0,  /* I/O address, IRQ */
        !          1741:        0, 0, 0, NULL, smc_init };
        !          1742: 
        !          1743: int io = 0;
        !          1744: int irq = 0;
        !          1745: int ifport = 0;
        !          1746: 
        !          1747: int init_module(void)
        !          1748: {
        !          1749:        int result;
        !          1750: 
        !          1751:        if (io == 0)
        !          1752:                printk(KERN_WARNING 
        !          1753:                CARDNAME": You shouldn't use auto-probing with insmod!\n" );
        !          1754: 
        !          1755:        /* copy the parameters from insmod into the device structure */
        !          1756:        devSMC9194.base_addr = io;
        !          1757:        devSMC9194.irq       = irq;
        !          1758:        devSMC9194.if_port      = ifport;
        !          1759:        if ((result = register_netdev(&devSMC9194)) != 0)
        !          1760:                return result;
        !          1761: 
        !          1762:        return 0;
        !          1763: }
        !          1764: 
        !          1765: void cleanup_module(void)
        !          1766: {
        !          1767:        /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
        !          1768:        unregister_netdev(&devSMC9194);
        !          1769: 
        !          1770:        free_irq(devSMC9194.irq, NULL );
        !          1771:        irq2dev_map[devSMC9194.irq] = NULL;
        !          1772:        release_region(devSMC9194.base_addr, SMC_IO_EXTENT);
        !          1773: 
        !          1774:        if (devSMC9194.priv)
        !          1775:                kfree_s(devSMC9194.priv, sizeof(struct smc_local));
        !          1776: }
        !          1777: 
        !          1778: #endif /* MODULE */
        !          1779: 

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