/*------------------------------------------------------------------------
 . smc9194.c
 . This is a driver for SMC's 9000 series of Ethernet cards. 
 .
 . Copyright (C) 1996 by Erik Stahlman
 . This software may be used and distributed according to the terms
 . of the GNU Public License, incorporated herein by reference.
 .
 . "Features" of the SMC chip:  
 .   4608 byte packet memory. ( for the 91C92.  Others have more ) 
 .   EEPROM for configuration
 .   AUI/TP selection  ( mine has 10Base2/10BaseT select )
 .
 . Arguments:
 . 	io		 = for the base address
 .	irq	 = for the IRQ 
 .	ifport = 0 for autodetect, 1 for TP, 2 for AUI ( or 10base2 )   
 .
 . author:  
 . 	Erik Stahlman				( erik@vt.edu )
 .   
 . Hardware multicast code from Peter Cammaert ( pc@denkart.be )
 .
 . Sources:
 .    o   SMC databook
 .    o   skeleton.c by Donald Becker ( becker@cesdis.gsfc.nasa.gov )
 .    o   ( a LOT of advice from Becker as well )
 .
 . History:
 .	12/07/95  Erik Stahlman  written, got recieve/xmit handled 
 . 	01/03/96  Erik Stahlman  worked out some bugs, actually useable!!! :-)
 .	01/06/96  Erik Stahlman	 cleaned up some, better testing, etc 
 .	01/29/96  Erik Stahlman	 fixed autoirq, added multicast
 . 	02/01/96  Erik Stahlman	 1. disabled all interrupts in smc_reset
 .		   		 2. got rid of post-decrementing bug -- UGH.  
 .	02/13/96  Erik Stahlman  Tried to fix autoirq failure.  Added more
 .				 descriptive error messages.
 .	02/15/96  Erik Stahlman  Fixed typo that caused detection failure
 . 	02/23/96  Erik Stahlman	 Modified it to fit into kernel tree  
 .				 Added support to change hardware address
 .				 Cleared stats on opens
 .	02/26/96  Erik Stahlman	 Trial support for Kernel 1.2.13
 .				 Kludge for automatic IRQ detection
 .	03/04/96  Erik Stahlman	 Fixed kernel 1.3.70 + 
 .				 Fixed bug reported by Gardner Buchanan in 
 .				   smc_enable, with outw instead of outb
 .	03/06/96  Erik Stahlman  Added hardware multicast from Peter Cammaert
 ----------------------------------------------------------------------------*/

static const char *version =
	"smc9194.c:v0.12 03/06/96 by Erik Stahlman (erik@vt.edu)\n";  

#ifdef MODULE
#include <linux/module.h>
#include <linux/version.h>
#endif 

#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/types.h>
#include <linux/fcntl.h>
#include <linux/interrupt.h>
#include <linux/ptrace.h>
#include <linux/ioport.h>
#include <linux/in.h>
#include <linux/malloc.h>
#include <linux/string.h>
#include <linux/ioport.h>
#include <asm/bitops.h>
#include <asm/io.h>
#include <linux/errno.h>

#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>

#include "smc9194.h"
/*------------------------------------------------------------------------
 .  
 . Configuration options, for the experienced user to change. 
 .
 -------------------------------------------------------------------------*/

/* 
 . this is for kernels > 1.2.70 
*/
#define REALLY_NEW_KERNEL 
#ifndef REALLY_NEW_KERNEL
#define free_irq( x, y ) free_irq( x )
#define request_irq( x, y, z, u, v ) request_irq( x, y, z, u )
#endif

/*
 . Do you want to use this with old kernels.  
 . WARNING: this is not well tested.  
#define SUPPORT_OLD_KERNEL
*/


/*
 . Do you want to use 32 bit xfers?  This should work on all chips, as
 . the chipset is designed to accomodate them.   
*/
#define USE_32_BIT 1

/* 
 .the SMC9194 can be at any of the following port addresses.  To change,
 .for a slightly different card, you can add it to the array.  Keep in 
 .mind that the array must end in zero.
*/
static unsigned int smc_portlist[] =
   { 0x200, 0x220, 0x240, 0x260, 0x280, 0x2A0, 0x2C0, 0x2E0,
	  0x300, 0x320, 0x340, 0x360, 0x380, 0x3A0, 0x3C0, 0x3E0, 0};

/* 
 . Wait time for memory to be free.  This probably shouldn't be 
 . tuned that much, as waiting for this means nothing else happens 
 . in the system 
*/
#define MEMORY_WAIT_TIME 16

/*
 . DEBUGGING LEVELS
 . 
 . 0 for normal operation
 . 1 for slightly more details
 . >2 for various levels of increasingly useless information
 .    2 for interrupt tracking, status flags
 .    3 for packet dumps, etc.
*/
#define SMC_DEBUG 0

#if (SMC_DEBUG > 2 )
#define PRINTK3(x) printk x 
#else 
#define PRINTK3(x) 
#endif

#if SMC_DEBUG > 1 
#define PRINTK2(x) printk x 
#else
#define PRINTK2(x)
#endif

#ifdef SMC_DEBUG
#define PRINTK(x) printk x
#else
#define PRINTK(x)
#endif 


/* the older versions of the kernel cannot support autoprobing */
#ifdef SUPPORT_OLD_KERNEL
#define NO_AUTOPROBE
#endif


/*------------------------------------------------------------------------
 .
 . The internal workings of the driver.  If you are changing anything 
 . here with the SMC stuff, you should have the datasheet and known 
 . what you are doing.  
 .  
 -------------------------------------------------------------------------*/
#define CARDNAME "SMC9194"

#ifdef SUPPORT_OLD_KERNEL
char kernel_version[] = UTS_RELEASE;
#endif 

/* store this information for the driver.. */ 
struct smc_local {
	/*
 	   these are things that the kernel wants me to keep, so users
	   can find out semi-useless statistics of how well the card is
	   performing 
 	*/
	struct enet_statistics stats;
	
	/* 
	   If I have to wait until memory is available to send
	   a packet, I will store the skbuff here, until I get the
	   desired memory.  Then, I'll send it out and free it.    
	*/
	struct sk_buff * saved_skb;

	/*
 	 . This keeps track of how many packets that I have
 	 . sent out.  When an TX_EMPTY interrupt comes, I know
	 . that all of these have been sent.
	*/
	int	packets_waiting;
};


/*-----------------------------------------------------------------
 .
 .  The driver can be entered at any of the following entry points.
 . 
 .------------------------------------------------------------------  */

/*
 . This is called by  register_netdev().  It is responsible for 
 . checking the portlist for the SMC9000 series chipset.  If it finds 
 . one, then it will initialize the device, find the hardware information,
 . and sets up the appropriate device parameters.   
 . NOTE: Interrupts are *OFF* when this procedure is called.
 .
 . NB:This shouldn't be static since it is refered to externally.
*/
int smc_init(struct device *dev);

/*
 . The kernel calls this function when someone wants to use the device,
 . typically 'ifconfig ethX up'.   
*/
static int smc_open(struct device *dev);

/*
 . This is called by the kernel to send a packet out into the net.  it's
 . responsible for doing a best-effort send, but if it's simply not possible
 . to send it, the packet gets dropped. 
*/  
static int smc_send_packet(struct sk_buff *skb, struct device *dev);

/* 
 . This is called by the kernel in response to 'ifconfig ethX down'.  It
 . is responsible for cleaning up everything that the open routine 
 . does, and maybe putting the card into a powerdown state. 
*/
static int smc_close(struct device *dev);

/*
 . This routine allows the proc file system to query the driver's 
 . statistics.  
*/
static struct enet_statistics * smc_query_statistics( struct device *dev);

/*
 . Finally, a call to set promiscuous mode ( for TCPDUMP and related 
 . programs ) and multicast modes.
*/
#ifdef SUPPORT_OLD_KERNEL
static void smc_set_multicast_list(struct device *dev, int num_addrs,
				 void *addrs);
#else
static void smc_set_multicast_list(struct device *dev);
#endif 

/*---------------------------------------------------------------
 . 
 . Interrupt level calls.. 
 .
 ----------------------------------------------------------------*/

/*
 . Handles the actual interrupt 
*/
#ifdef REALLY_NEW_KERNEL
static void smc_interrupt(int irq, void *, struct pt_regs *regs);
#else
static void smc_interrupt(int irq, struct pt_regs *regs);
#endif 
/*
 . This is a seperate procedure to handle the receipt of a packet, to
 . leave the interrupt code looking slightly cleaner 
*/ 
inline static void smc_rcv( struct device *dev );
/*
 . This handles a TX interrupt, which is only called when an error
 . relating to a packet is sent.  
*/
inline static void smc_tx( struct device * dev );

/*
 ------------------------------------------------------------
 . 
 . Internal routines
 .
 ------------------------------------------------------------
*/

/*
 . Test if a given location contains a chip, trying to cause as 
 . little damage as possible if it's not a SMC chip.
*/
static int smc_probe( int ioaddr );

/*
 . this routine initializes the cards hardware, prints out the configuration
 . to the system log as well as the vanity message, and handles the setup
 . of a device parameter. 
 . It will give an error if it can't initialize the card.
*/
static int smc_initcard( struct device *, int ioaddr ); 

/*
 . A rather simple routine to print out a packet for debugging purposes.
*/ 
#if SMC_DEBUG > 2 
static void print_packet( byte *, int );
#endif  

#define tx_done(dev) 1

/* this is called to actually send the packet to the chip */ 
static void smc_hardware_send_packet( struct device * dev );

/* Since I am not sure if I will have enough room in the chip's ram
 . to store the packet, I call this routine, which either sends it 
 . now, or generates an interrupt when the card is ready for the 
 . packet */
static int  smc_wait_to_send_packet( struct sk_buff * skb, struct device *dev );

/* this does a soft reset on the device */
static void smc_reset( int ioaddr );

/* Enable Interrupts, Receive, and Transmit */
static void smc_enable( int ioaddr );

/* this puts the device in an inactve state */
static void smc_shutdown( int ioaddr );

#ifndef NO_AUTOPROBE
/* This routine will find the IRQ of the driver if one is not
 . specified in the input to the device.  */
static int smc_findirq( int ioaddr );
#endif

/*
  this routine will set the hardware multicast table to the specified 
  values given it by the higher level routines
*/
#ifndef SUPPORT_OLD_KERNEL
static void smc_setmulticast( int ioaddr, int count, struct dev_mc_list *  );
static int crc32( char *, int );
#endif

#ifdef SUPPORT_OLD_KERNEL
extern struct device *init_etherdev(struct device *dev, int sizeof_private,
 			unsigned long *mem_startp );
#endif 

/*
 . Function: smc_reset( int ioaddr )
 . Purpose:
 .  	This sets the SMC91xx chip to its normal state, hopefully from whatever
 . 	mess that any other DOS driver has put it in.   
 . 
 . Maybe I should reset more registers to defaults in here?  SOFTRESET  should
 . do that for me.  
 . 
 . Method:
 .	1.  send a SOFT RESET 
 .	2.  wait for it to finish
 .	3.  enable autorelease mode
 .	4.  reset the memory management unit
 .	5.  clear all interrupts
 .
*/  
static void smc_reset( int ioaddr ) 
{ 
	/* This resets the registers mostly to defaults, but doesn't
	   affect EEPROM.  That seems unnecessary */
	SMC_SELECT_BANK( 0 );
	outw( RCR_SOFTRESET, ioaddr + RCR ); 
	
	/* this should pause enough for the chip to be happy */
	SMC_DELAY( );

	/* Set the transmit and receive configuration registers to 
	   default values */
	outw( RCR_CLEAR, ioaddr + RCR );
	outw( TCR_CLEAR, ioaddr + TCR );

	/* set the control register to automatically
	   release succesfully transmitted packets, to make the best 
	   use out of our limitted memory */
	SMC_SELECT_BANK( 1 );
	outw( inw( ioaddr + CONTROL ) | CTL_AUTO_RELEASE , ioaddr + CONTROL );	

	/* Reset the MMU */
	SMC_SELECT_BANK( 2 );
	outw( MC_RESET, ioaddr + MMU_CMD );

	/* Note:  It doesn't seem that waiting for the MMU busy is needed here, 
	   but this is a place where future chipsets _COULD_ break.  Be wary
 	   of issuing another MMU command right after this */

	outb( 0, ioaddr + INT_MASK );
}

/* 
 . Function: smc_enable
 . Purpose: let the chip talk to the outside work
 . Method: 
 .	1.  Enable the transmitter
 .	2.  Enable the receiver
 .	3.  Enable interrupts
*/
static void smc_enable( int ioaddr ) 
{
	SMC_SELECT_BANK( 0 );
	/* see the header file for options in TCR/RCR NORMAL*/
	outw( TCR_NORMAL, ioaddr + TCR );
	outw( RCR_NORMAL, ioaddr + RCR );

	/* now, enable interrupts */
	SMC_SELECT_BANK( 2 );
	outb( SMC_INTERRUPT_MASK, ioaddr + INT_MASK );
} 	
	
/*
 . Function: smc_shutdown
 . Purpose:  closes down the SMC91xxx chip.
 . Method:   
 .	1. zero the interrupt mask
 .	2. clear the enable recieve flag
 .	3. clear the enable xmit flags
 .
 . TODO: 
 .   (1) maybe utilize power down mode.
 .	Why not yet?  Because while the chip will go into power down mode,
 .	the manual says that it will wake up in response to any I/O requests
 .	in the register space.   Empirical results do not show this working.
*/
static void smc_shutdown( int ioaddr ) 
{
	/* no more interrupts for me */
	SMC_SELECT_BANK( 2 );
	outb( 0, ioaddr + INT_MASK );

	/* and tell the card to stay away from that nasty outside world */
	SMC_SELECT_BANK( 0 );
	outb( RCR_CLEAR, ioaddr + RCR );
	outb( TCR_CLEAR, ioaddr + TCR );
#if 0 
	/* finally, shut the chip down */
	SMC_SELECT_BANK( 1 ); 
	outw( inw( ioaddr + CONTROL ), CTL_POWERDOWN, ioaddr + CONTROL  );
#endif 
}


#ifndef SUPPORT_OLD_KERNEL 
/* 
 . Function: smc_setmulticast( int ioaddr, int count, dev_mc_list * adds )
 . Purpose:
 .    This sets the internal hardware table to filter out unwanted multicast
 .    packets before they take up memory.  
 .    
 .    The SMC chip uses a hash table where the high 6 bits of the CRC of
 .    address are the offset into the table.  If that bit is 1, then the 
 .    multicast packet is accepted.  Otherwise, it's dropped silently.
 .  
 .    To use the 6 bits as an offset into the table, the high 3 bits are the
 .    number of the 8 bit register, while the low 3 bits are the bit within
 .    that register.
 .
 . This routine is based very heavily on the one provided by Peter Cammaert. 
*/


static void smc_setmulticast( int ioaddr, int count, struct dev_mc_list * addrs ) {
	int			i;
	unsigned char		multicast_table[ 8 ];
	struct dev_mc_list	* cur_addr;
	/* table for flipping the order of 3 bits */  
	unsigned char invert3[] = { 0, 4, 2, 6, 1, 5, 3, 7 };

	/* start with a table of all zeros: reject all */	
	memset( multicast_table, 0, sizeof( multicast_table ) );

	cur_addr = addrs;
	for ( i = 0; i < count ; i ++, cur_addr = cur_addr->next  ) {
		int position;
		
		/* do we have a pointer here? */
		if ( !cur_addr ) 
			break;
		/* make sure this is a multicast address - shouldn't this
		   be a given if we have it here ? */	
		if ( !( *cur_addr->dmi_addr & 1 ) ) 	
			continue;	

		/* only use the low order bits */	
		position = crc32( cur_addr->dmi_addr, 6 ) & 0x3f;
				
		/* do some messy swapping to put the bit in the right spot */
		multicast_table[invert3[position&7]] |= 
					(1<<invert3[(position>>3)&7]);

	}
	/* now, the table can be loaded into the chipset */
	SMC_SELECT_BANK( 3 );
	
	for ( i = 0; i < 8 ; i++ ) {
		outb( multicast_table[i], ioaddr + MULTICAST1 + i );
	}
}

/*
  Finds the CRC32 of a set of bytes.
  Again, from Peter Cammaert's code. 
*/
static int crc32( char * s, int length ) { 
	/* indices */
	int perByte;
	int perBit;
	/* crc polynomial for Ethernet */
	const unsigned long poly = 0xedb88320;
	/* crc value - preinitialized to all 1's */
	unsigned long crc_value = 0xffffffff; 

	for ( perByte = 0; perByte < length; perByte ++ ) {
		unsigned char	c;
	
		c = *(s++);
		for ( perBit = 0; perBit < 8; perBit++ ) {
			crc_value = (crc_value>>1)^
				(((crc_value^c)&0x01)?poly:0);
			c >>= 1;
		}
	}
	return	crc_value;
} 

#endif 


/* 
 . Function: smc_wait_to_send_packet( struct sk_buff * skb, struct device * ) 
 . Purpose: 
 .    Attempt to allocate memory for a packet, if chip-memory is not
 .    available, then tell the card to generate an interrupt when it 
 .    is available.
 .
 . Algorithm:
 .
 . o	if the saved_skb is not currently null, then drop this packet
 .	on the floor.  This should never happen, because of TBUSY.
 . o	if the saved_skb is null, then replace it with the current packet,
 . o	See if I can sending it now. 
 . o 	(NO): Enable interrupts and let the interrupt handler deal with it.
 . o	(YES):Send it now.
*/
static int smc_wait_to_send_packet( struct sk_buff * skb, struct device * dev )
{ 
	struct smc_local *lp 	= (struct smc_local *)dev->priv;
	unsigned short ioaddr 	= dev->base_addr;
	word 			length;
	unsigned short 		numPages;
	word			time_out;	
	
	if ( lp->saved_skb) {
		/* THIS SHOULD NEVER HAPPEN. */
		lp->stats.tx_aborted_errors++;
		printk(CARDNAME": Bad Craziness - sent packet while busy.\n" );
		return 1;
	}
	lp->saved_skb = skb;

	length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
		
	/*
	. the MMU wants the number of pages to be the number of 256 bytes 
    	. 'pages', minus 1 ( since a packet can't ever have 0 pages :) ) 
	*/
	numPages = length / 256;

	if (numPages > 7 ) {
		printk(CARDNAME": Far too big packet error. \n");
		/* freeing the packet is a good thing here... but should 		
		 . any packets of this size get down here?   */
		dev_kfree_skb (skb, FREE_WRITE);
		lp->saved_skb = NULL;
		/* this IS an error, but, i don't want the skb saved */
		return 0; 
	}
	/* either way, a packet is waiting now */
	lp->packets_waiting++;
	 
	/* now, try to allocate the memory */
	SMC_SELECT_BANK( 2 );
	outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );
	/*
 	. Performance Hack
	.  
 	. wait a short amount of time.. if I can send a packet now, I send
	. it now.  Otherwise, I enable an interrupt and wait for one to be
	. available. 
	.
	. I could have handled this a slightly different way, by checking to
	. see if any memory was available in the FREE MEMORY register.  However,
	. either way, I need to generate an allocation, and the allocation works
	. no matter what, so I saw no point in checking free memory.   
	*/ 
	time_out = MEMORY_WAIT_TIME;
	do { 
		word	status;

		status = inb( ioaddr + INTERRUPT );
		if ( status & IM_ALLOC_INT ) { 
			/* acknowledge the interrupt */
			outb( IM_ALLOC_INT, ioaddr + INTERRUPT );
  			break;	
		}
   	} while ( -- time_out );

   	if ( !time_out ) {
		/* oh well, wait until the chip finds memory later */ 
		SMC_ENABLE_INT( IM_ALLOC_INT );
      		PRINTK2((CARDNAME": memory allocation deferred. \n"));
		/* it's deferred, but I'll handle it later */
      		return 0;
   	}
	/* or YES! I can send the packet now.. */
	smc_hardware_send_packet(dev);
	
	return 0;
}	

/*
 . Function:  smc_hardware_send_packet(struct device * )
 . Purpose:	
 .	This sends the actual packet to the SMC9xxx chip.   
 . 
 . Algorithm:
 . 	First, see if a saved_skb is available.    
 .		( this should NOT be called if there is no 'saved_skb'
 .	Now, find the packet number that the chip allocated
 .	Point the data pointers at it in memory 
 .	Set the length word in the chip's memory
 .	Dump the packet to chip memory
 .	Check if a last byte is needed ( odd length packet )
 .		if so, set the control flag right 
 . 	Tell the card to send it 
 .	Enable the transmit interrupt, so I know if it failed
 . 	Free the kernel data if I actually sent it.
*/
static void smc_hardware_send_packet( struct device * dev ) 
{
	struct smc_local *lp = (struct smc_local *)dev->priv;
	byte	 		packet_no;
	struct sk_buff * 	skb = lp->saved_skb;
	word			length;	
	unsigned short		ioaddr;
	byte			* buf;

	ioaddr = dev->base_addr;	

	if ( !skb ) {
		PRINTK((CARDNAME": In XMIT with no packet to send \n"));
		return;
	}
	length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
	buf = skb->data;

	/* If I get here, I _know_ there is a packet slot waiting for me */
	packet_no = inb( ioaddr + PNR_ARR + 1 ); 
	if ( packet_no & 0x80 ) { 
		/* or isn't there?  BAD CHIP! */
		printk(KERN_DEBUG CARDNAME": Memory allocation failed. \n");
		kfree(skb);
		lp->saved_skb = NULL;
		dev->tbusy = 0;
		return;
	}

	/* we have a packet address, so tell the card to use it */
	outb( packet_no, ioaddr + PNR_ARR );

	/* point to the beginning of the packet */	
	outw( PTR_AUTOINC , ioaddr + POINTER );

   	PRINTK3((CARDNAME": Trying to xmit packet of length %x\n", length ));
#if SMC_DEBUG > 2
	print_packet( buf, length );
#endif

	/* send the packet length ( +6 for status, length and ctl byte ) 
 	   and the status word ( set to zeros ) */ 
#ifdef USE_32_BIT
	outl(  (length +6 ) << 16 , ioaddr + DATA_1 );
#else
	outw( 0, ioaddr + DATA_1 );	 
	/* send the packet length ( +6 for status words, length, and ctl*/		
	outb( (length+6) & 0xFF,ioaddr + DATA_1 );
	outb( (length+6) >> 8 , ioaddr + DATA_1 );
#endif 

	/* send the actual data 
	 . I _think_ it's faster to send the longs first, and then 
	 . mop up by sending the last word.  It depends heavily 
 	 . on alignment, at least on the 486.  Maybe it would be 
 	 . a good idea to check which is optimal?  But that could take
	 . almost as much time as is saved? 
	*/	
#ifdef USE_32_BIT 
	if ( length & 0x2  ) {	
		outsl(ioaddr + DATA_1, buf,  length >> 2 ); 
		outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
	}
	else
		outsl(ioaddr + DATA_1, buf,  length >> 2 ); 
#else
	outsw(ioaddr + DATA_1 , buf, (length ) >> 1);
#endif
	/* Send the last byte, if there is one.   */
	
	if ( (length & 1) == 0 ) {
		outw( 0, ioaddr + DATA_1 );
	} else {
		outb( buf[length -1 ], ioaddr + DATA_1 );
		outb( 0x20, ioaddr + DATA_1);
	}

	/* enable the interrupts */
	SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );

	/* and let the chipset deal with it */
	outw( MC_ENQUEUE , ioaddr + MMU_CMD );

	PRINTK2((CARDNAME": Sent packet of length %d \n",length)); 

	lp->saved_skb = NULL;
	dev_kfree_skb (skb, FREE_WRITE);

	dev->trans_start = jiffies;

	/* we can send another packet */
	dev->tbusy = 0;


	return;
}

/*-------------------------------------------------------------------------
 |
 | smc_init( struct device * dev )  
 |   Input parameters: 
 |	dev->base_addr == 0, try to find all possible locations
 |	dev->base_addr == 1, return failure code
 |	dev->base_addr == 2, always allocate space,  and return sucess
 |	dev->base_addr == <anything else>   this is the address to check 
 |
 |   Output: 
 |	0 --> there is a device
 |	anything else, error 
 | 
 ---------------------------------------------------------------------------
*/ 
int smc_init(struct device *dev)
{
	int i;
	int base_addr = dev ? dev->base_addr : 0;

	/*  try a specific location */
	if (base_addr > 0x1ff)	{		 
		int	error; 
		error = smc_probe(base_addr);
		if ( 0 == error ) {
			return smc_initcard( dev, base_addr );
		}
		return error; 
	} else {
		if ( 0 != base_addr ) {
			return -ENXIO;
		}
	}
	
	/* check every ethernet address */
	for (i = 0; smc_portlist[i]; i++) {
		int ioaddr = smc_portlist[i];

		/* check if the area is available */
		if (check_region( ioaddr , SMC_IO_EXTENT))
			continue;

		/* check this specific address */
		if ( smc_probe( ioaddr ) == 0)  {  
			return smc_initcard( dev, ioaddr  ); 
		}
	}

	/* couldn't find anything */
	return -ENODEV;
}

#ifndef NO_AUTOPROBE
/*----------------------------------------------------------------------
 . smc_findirq 
 . 
 . This routine has a simple purpose -- make the SMC chip generate an 
 . interrupt, so an auto-detect routine can detect it, and find the IRQ,
 ------------------------------------------------------------------------
*/
int smc_findirq( int ioaddr ) 
{
	int	timeout = 20;


	/* I have to do a STI() here, because this is called from
	   a routine that does an CLI during this process, making it 
	   rather difficult to get interrupts for auto detection */
	sti();

	autoirq_setup( 0 );

	/*
	 * What I try to do here is trigger an ALLOC_INT. This is done
	 * by allocating a small chunk of memory, which will give an interrupt
	 * when done.
	 */

	  
	SMC_SELECT_BANK(2);	
	/* enable ALLOCation interrupts ONLY */
	outb( IM_ALLOC_INT, ioaddr + INT_MASK );	

	/*
 	 . Allocate 512 bytes of memory.  Note that the chip was just 
	 . reset so all the memory is available
	*/
	outw( MC_ALLOC | 1, ioaddr + MMU_CMD );		

	/*
	 . Wait until positive that the interrupt has been generated
	*/
	while ( timeout ) {
		byte	int_status;

		int_status = inb( ioaddr + INTERRUPT );

		if ( int_status & IM_ALLOC_INT ) 	
			break;		/* got the interrupt */
		timeout--;
	}
	/* there is really nothing that I can do here if timeout fails,
	   as autoirq_report will return a 0 anyway, which is what I
	   want in this case.   Plus, the clean up is needed in both
	   cases.  */

	/* DELAY HERE!
	   On a fast machine, the status might change before the interrupt
	   is given to the processor.  This means that the interrupt was 
	   never detected, and autoirq_report fails to report anything.  
	   This should fix autoirq_* problems. 
	*/
	SMC_DELAY();
	SMC_DELAY();		
	
	/* and disable all interrupts again */
	outb( 0, ioaddr + INT_MASK );

	/* clear hardware interrupts again, because that's how it
	   was when I was called... */
	cli();

	/* and return what I found */
	return autoirq_report( 0 );	
}
#endif
 
/*----------------------------------------------------------------------
 . Function: smc_probe( int ioaddr )
 . 
 . Purpose:  
 .	Tests to see if a given ioaddr points to an SMC9xxx chip.
 .	Returns a 0 on success 	
 . 
 . Algorithm:
 .	(1) see if the high byte of BANK_SELECT is 0x33
 . 	(2) compare the ioaddr with the base register's address
 .	(3) see if I recognize the chip ID in the appropriate register
 . 
 .---------------------------------------------------------------------
 */ 

static int smc_probe( int ioaddr ) 
{
	unsigned int	bank;
	word	revision_register;	
	word  base_address_register;

	/* First, see if the high byte is 0x33 */
	bank = inw( ioaddr + BANK_SELECT );
	if ( (bank & 0xFF00) != 0x3300 ) {
		return -ENODEV;
	}
	/* The above MIGHT indicate a device, but I need to write to further
 	 	test this.  */
	outw( 0x0, ioaddr + BANK_SELECT );
	bank = inw( ioaddr + BANK_SELECT );
	if ( (bank & 0xFF00 ) != 0x3300 ) {
		return -ENODEV;
	}
	/* well, we've already written once, so hopefully another time won't
 	   hurt.  This time, I need to switch the bank register to bank 1, 
	   so I can access the base address register */
	SMC_SELECT_BANK(1);
	base_address_register = inw( ioaddr + BASE );
	if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) )  {
		printk(CARDNAME ": IOADDR %x doesn't match configuration (%x)." 
			"Probably not a SMC chip\n",
			ioaddr, base_address_register >> 3 & 0x3E0 );
		/* well, the base address register didn't match.  Must not have
		   been a SMC chip after all. */
		return -ENODEV;
	}

	/*  check if the revision register is something that I recognize.  
	    These might need to be added to later, as future revisions 
	    could be added.  */
	SMC_SELECT_BANK(3);
	revision_register  = inw( ioaddr + REVISION );
	if ( !chip_ids[ ( revision_register  >> 4 ) & 0xF  ] ) { 
		/* I don't regonize this chip, so... */
		printk(CARDNAME ": IO %x: Unrecognized revision register:"
			" %x, Contact author. \n", ioaddr, revision_register );

		return -ENODEV;
	}

	/* at this point I'll assume that the chip is an SMC9xxx.   
	   It might be prudent to check a listing of MAC addresses 
	   against the hardware address, or do some other tests. */ 	
	return 0;
}

/*---------------------------------------------------------------
 . Here I do typical initialization tasks. 
 . 
 . o  Initialize the structure if needed
 . o  print out my vanity message if not done so already
 . o  print out what type of hardware is detected
 . o  print out the ethernet address
 . o  find the IRQ 
 . o  set up my private data 
 . o  configure the dev structure with my subroutines
 . o  actually GRAB the irq.
 . o  GRAB the region 
 .-----------------------------------------------------------------
*/
static int  smc_initcard(struct device *dev, int ioaddr)
{
	int i;

	static unsigned version_printed = 0;

	/* registers */
	word	revision_register;	
	word	configuration_register;	
	word  	memory_info_register;
	word 	memory_cfg_register;

	const char *	version_string;
	const char *	if_string;
	int	memory;

	int   irqval;

	/* see if I need to initialize the ethernet card structure */
	if (dev == NULL) {
#ifdef SUPPORT_OLD_KERNEL
#ifndef MODULE
/* note: the old module interface does not support this call */
		dev = init_etherdev( 0, sizeof( struct smc_local ), 0 );
#endif 
#else
		dev = init_etherdev(0, 0);
#endif 
		if (dev == NULL)
			return -ENOMEM;
	}

	if (version_printed++ == 0)
		printk("%s", version);

	/* fill in some of the fields */
	dev->base_addr = ioaddr;

	/*
 	 . Get the MAC address ( bank 1, regs 4 - 9 )
	*/
	SMC_SELECT_BANK( 1 );
	for ( i = 0; i < 6; i += 2 ) { 
		word	address;

		address = inw( ioaddr + ADDR0 + i  );
		dev->dev_addr[ i + 1] = address >> 8;
		dev->dev_addr[ i ] = address & 0xFF;	
	}

	/* get the memory information */

	SMC_SELECT_BANK( 0 );
	memory_info_register = inw( ioaddr + MIR );
	memory_cfg_register  = inw( ioaddr + MCR );
	memory = ( memory_cfg_register >> 9 )  & 0x7;  /* multiplier */
	memory *= 256 * ( memory_info_register & 0xFF );

	/* 
	 Now, I want to find out more about the chip.  This is sort of
 	 redundant, but it's cleaner to have it in both, rather than having
 	 one VERY long probe procedure.
	*/	
	SMC_SELECT_BANK(3);
	revision_register  = inw( ioaddr + REVISION );
	version_string = chip_ids[ ( revision_register  >> 4 ) & 0xF  ];
	if ( !version_string ) {
		/* I shouldnt' get here because this call was done before.... */ 
		return -ENODEV;
	}

	/* is it using AUI or 10BaseT ? */
	if ( dev->if_port == 0 ) {
		SMC_SELECT_BANK(1);
		configuration_register = inw( ioaddr + CONFIG );
		if ( configuration_register & CFG_AUI_SELECT )  
			dev->if_port = 2;
		else
			dev->if_port = 1;
	}
	if_string = interfaces[ dev->if_port - 1 ];

	/* now, reset the chip, and put it into a known state */
	smc_reset( ioaddr );

	/*
	 . If dev->irq is 0, then the device has to be banged on to see
	 . what the IRQ is. 
 	 . 
	 . This banging doesn't always detect the IRQ, for unknown reasons.
	 . a workaround is to reset the chip and try again.  
	 .    
	 . Interestingly, the DOS packet driver *SETS* the IRQ on the card to
	 . be what is requested on the command line.   I don't do that, mostly
	 . because the card that I have uses a non-standard method of accessing
	 . the IRQs, and because this _should_ work in most configurations.
	 .
	 . Specifying an IRQ is done with the assumption that the user knows 
	 . what (s)he is doing.  No checking is done!!!!
 	 .
	*/
#ifndef NO_AUTOPROBE
	if ( dev->irq < 2 ) {
		int	trials;

		trials = 3;
		while ( trials-- ) { 
			dev->irq = smc_findirq( ioaddr );
			if ( dev->irq ) 
				break;
			/* kick the card and try again */
			smc_reset( ioaddr );
		}
	} 
	if (dev->irq == 0 ) {
		printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n");
		return -ENODEV;
	}
#else
	if (dev->irq == 0 ) {
		printk(CARDNAME
		": Autoprobing IRQs is not supported for old kernels.\n");
		return -ENODEV;
	}
#endif
	if (dev->irq == 2) {
		/* Fixup for users that don't know that IRQ 2 is really IRQ 9,
		 * or don't know which one to set.
		 */
		dev->irq = 9;
	}

	/* now, print out the card info, in a short format.. */
	
	printk(CARDNAME ": %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ",
		version_string, revision_register & 0xF, ioaddr, dev->irq, 
		if_string, memory );
	/*
	 . Print the Ethernet address 
	*/
	printk("ADDR: ");
	for (i = 0; i < 5; i++)
		printk("%2.2x:", dev->dev_addr[i] );
	printk("%2.2x \n", dev->dev_addr[5] );


	/* Initialize the private structure. */
	if (dev->priv == NULL) {
		dev->priv = kmalloc(sizeof(struct smc_local), GFP_KERNEL);
		if (dev->priv == NULL)
			return -ENOMEM;
	}
	/* set the private data to zero by default */
	memset(dev->priv, 0, sizeof(struct smc_local));

	/* Fill in the fields of the device structure with ethernet values. */
	ether_setup(dev);

	/* Grab the IRQ */
      	irqval = request_irq(dev->irq, &smc_interrupt, 0, CARDNAME, NULL);
      	if (irqval) {
       	  printk(CARDNAME": unable to get IRQ %d (irqval=%d).\n",
		dev->irq, irqval);
       	  return -EAGAIN;
      	}
	irq2dev_map[dev->irq] = dev;

	/* Grab the region so that no one else tries to probe our ioports. */
	request_region(ioaddr, SMC_IO_EXTENT, CARDNAME);

	dev->open		        = smc_open;
	dev->stop		        = smc_close;
	dev->hard_start_xmit    	= smc_send_packet;
	dev->get_stats			= smc_query_statistics;
#ifdef	HAVE_MULTICAST
	dev->set_multicast_list 	= &smc_set_multicast_list;
#endif

	return 0;
}

#if SMC_DEBUG > 2
static void print_packet( byte * buf, int length ) 
{ 
#if 0
	int i;
	int remainder;
	int lines;
	
	printk("Packet of length %d \n", length );
	lines = length / 16;
	remainder = length % 16;

	for ( i = 0; i < lines ; i ++ ) { 
		int cur;

		for ( cur = 0; cur < 8; cur ++ ) { 
			byte a, b;

			a = *(buf ++ );
			b = *(buf ++ );
			printk("%02x%02x ", a, b );
		}
		printk("\n");
	}
	for ( i = 0; i < remainder/2 ; i++ ) {
		byte a, b;

		a = *(buf ++ );
		b = *(buf ++ );
		printk("%02x%02x ", a, b );
	}
	printk("\n");
#endif
}
#endif	


/*
 * Open and Initialize the board
 * 
 * Set up everything, reset the card, etc ..
 *
 */
static int smc_open(struct device *dev)
{
	int	ioaddr = dev->base_addr;

	int	i;	/* used to set hw ethernet address */ 

	/* clear out all the junk that was put here before... */
	memset(dev->priv, 0, sizeof(struct smc_local));

	dev->tbusy 	= 0;
	dev->interrupt  = 0;
	dev->start 	= 1;
#ifdef MODULE
	MOD_INC_USE_COUNT;
#endif

	/* reset the hardware */

	smc_reset( ioaddr );
	smc_enable( ioaddr );

	/* Select which interface to use */
 	 
	SMC_SELECT_BANK( 1 );
	if ( dev->if_port == 1 ) { 	
		outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT, 
			ioaddr + CONFIG );							
	} 
	else if ( dev->if_port == 2 ) { 
		outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT, 
			ioaddr + CONFIG );							
	}

	/*
  		According to Becker, I have to set the hardware address
		at this point, because the (l)user can set it with an
		ioctl.  Easily done... 
	*/
	SMC_SELECT_BANK( 1 );
	for ( i = 0; i < 6; i += 2 ) { 
		word	address;
		
		address = dev->dev_addr[ i + 1 ] << 8 ;
		address  |= dev->dev_addr[ i ];
		outw( address, ioaddr + ADDR0 + i );
	}
	return 0;
}

/*--------------------------------------------------------
 . Called by the kernel to send a packet out into the void
 . of the net.  This routine is largely based on 
 . skeleton.c, from Becker.   
 .--------------------------------------------------------
*/
static int smc_send_packet(struct sk_buff *skb, struct device *dev)
{
	if (dev->tbusy) {
		/* If we get here, some higher level has decided we are broken.
		   There should really be a "kick me" function call instead. */
		int tickssofar = jiffies - dev->trans_start;
		if (tickssofar < 5)
			return 1;
		printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n",
			tx_done(dev) ? "IRQ conflict" : 
			"network cable problem");
		/* "kick" the adaptor */
		smc_reset( dev->base_addr );
		smc_enable( dev->base_addr );

		dev->tbusy = 0;
		dev->trans_start = jiffies;
		/* clear anything saved */
		((struct smc_local *)dev->priv)->saved_skb = NULL;
	}

	/* If some higher layer thinks we've missed an tx-done interrupt
	   we are passed NULL. Caution: dev_tint() handles the cli()/sti()
	   itself. */
	if (skb == NULL) {
		dev_tint(dev);
		return 0;
	}

	/* Block a timer-based transmit from overlapping.  This could better be
	   done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */
	if (set_bit(0, (void*)&dev->tbusy) != 0) {
		printk(KERN_WARNING CARDNAME": Transmitter access conflict.\n");
		dev_kfree_skb (skb, FREE_WRITE);
	} else {
		/* Well, I want to send the packet.. but I don't know 
		   if I can send it right now...  */	
		return smc_wait_to_send_packet( skb, dev );
	}
	return 0;
}

/*--------------------------------------------------------------------
 .
 . This is the main routine of the driver, to handle the device when
 . it needs some attention.
 .
 . So:
 .   first, save state of the chipset
 .   branch off into routines to handle each case, and acknowledge 
 .	    each to the interrupt register
 .   and finally restore state. 
 .  
 ---------------------------------------------------------------------*/
#ifdef REALLY_NEW_KERNEL
static void smc_interrupt(int irq, void * dev_id,  struct pt_regs * regs)
#else 
static void smc_interrupt(int irq, struct pt_regs * regs)
#endif 
{
	struct device *dev 	= (struct device *)(irq2dev_map[irq]);
	int ioaddr 		= dev->base_addr;
	struct smc_local *lp 	= (struct smc_local *)dev->priv;

	byte	status;
	word	card_stats;
	byte	mask;
	int	timeout;
	/* state registers */
	word	saved_bank;
	word	saved_pointer;


	
	PRINTK3((CARDNAME": SMC interrupt started \n"));

	if (dev == NULL) {
		printk(KERN_WARNING  CARDNAME": irq %d for unknown device.\n", 
			irq);
		return;
	}

/* will Linux let this happen ??  If not, this costs some speed */
	if ( dev->interrupt ) { 
		printk(KERN_WARNING CARDNAME": interrupt inside interrupt.\n");
		return;
	}
		
	dev->interrupt = 1;

	saved_bank = inw( ioaddr + BANK_SELECT );

	SMC_SELECT_BANK(2);
	saved_pointer = inw( ioaddr + POINTER );

	mask = inb( ioaddr + INT_MASK );
	/* clear all interrupts */
	outb( 0, ioaddr + INT_MASK );


	/* set a timeout value, so I don't stay here forever */
	timeout = 4;

	PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x \n", mask ));
	do { 	
		/* read the status flag, and mask it */
		status = inb( ioaddr + INTERRUPT ) & mask;
		if (!status )
			break;

		PRINTK3((KERN_WARNING CARDNAME
			": Handling interrupt status %x \n", status )); 

		if (status & IM_RCV_INT) {
			/* Got a packet(s). */
			PRINTK2((KERN_WARNING CARDNAME
				": Recieve Interrupt\n"));
			smc_rcv(dev);
		} else if (status & IM_TX_INT ) {
			PRINTK2((KERN_WARNING CARDNAME
				": TX ERROR handled\n"));
			smc_tx(dev);
			outb(IM_TX_INT, ioaddr + INTERRUPT ); 
		} else if (status & IM_TX_EMPTY_INT ) {
			/* update stats */
			SMC_SELECT_BANK( 0 );
			card_stats = inw( ioaddr + COUNTER );
			/* single collisions */
			lp->stats.collisions += card_stats & 0xF;
			card_stats >>= 4;
			/* multiple collisions */
			lp->stats.collisions += card_stats & 0xF;

			/* these are for when linux supports these statistics */
#if 0 
			card_stats >>= 4;
			/* deferred */
			card_stats >>= 4;
			/* excess deferred */
#endif 
			SMC_SELECT_BANK( 2 );
			PRINTK2((KERN_WARNING CARDNAME 
				": TX_BUFFER_EMPTY handled\n"));
			outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
			mask &= ~IM_TX_EMPTY_INT;
			lp->stats.tx_packets += lp->packets_waiting;
			lp->packets_waiting = 0;

		} else if (status & IM_ALLOC_INT ) {
			PRINTK2((KERN_DEBUG CARDNAME
				": Allocation interrupt \n"));
			/* clear this interrupt so it doesn't happen again */
			mask &= ~IM_ALLOC_INT;
		
			smc_hardware_send_packet( dev );
			
			/* enable xmit interrupts based on this */
			mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );

			/* and let the card send more packets to me */
			mark_bh( NET_BH );

			PRINTK2((CARDNAME": Handoff done successfully.\n"));	
		} else if (status & IM_RX_OVRN_INT ) {
			lp->stats.rx_errors++;
			lp->stats.rx_fifo_errors++;			
			outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
		} else if (status & IM_EPH_INT ) {
			PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT \n"));
		} else if (status & IM_ERCV_INT ) {
			PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT \n"));
			outb( IM_ERCV_INT, ioaddr + INTERRUPT );
		}
	} while ( timeout -- ); 

	
	/* restore state register */
	SMC_SELECT_BANK( 2 );
	outb( mask, ioaddr + INT_MASK );
	
	PRINTK3(( KERN_WARNING CARDNAME ": MASK is now %x \n", mask ));
	outw( saved_pointer, ioaddr + POINTER );

	SMC_SELECT_BANK( saved_bank );

	dev->interrupt = 0;
	PRINTK3((CARDNAME ": Interrupt done\n"));
	return;
}

/*-------------------------------------------------------------
 .
 . smc_rcv -  receive a packet from the card
 .
 . There is ( at least ) a packet waiting to be read from
 . chip-memory.
 . 
 . o Read the status 
 . o If an error, record it  
 . o otherwise, read in the packet 
 --------------------------------------------------------------
*/
static void smc_rcv(struct device *dev)
{
	struct smc_local *lp = (struct smc_local *)dev->priv;
	int 	ioaddr = dev->base_addr;
	int 	packet_number;
	word	status;
	word	packet_length; 
	
	/* assume bank 2 */

	packet_number = inw( ioaddr + FIFO_PORTS );

	if ( packet_number & FP_RXEMPTY ) {
		/* we got called , but nothing was on the FIFO */
		PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO. \n"));
		/* don't need to restore anything */
		return;
	}
		
	/*  start reading from the start of the packet */
	outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );

	/* First two words are status and packet_length */	
	status 		= inw( ioaddr + DATA_1 );
	packet_length 	= inw( ioaddr + DATA_1 );
	
	packet_length &= 0x07ff;  /* mask off top bits */

	PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));
	/* 
	 . the packet length contains 3 extra words : 
	 . status, length, and a extra word with an odd byte .
	*/
	packet_length -= 6; 
	
	if ( !(status & RS_ERRORS ) ){			
		/* do stuff to make a new packet */
		struct sk_buff  * skb;
		byte		* data;

		/* read one extra byte */
		if ( status & RS_ODDFRAME ) 	
			packet_length++; 	

		/* set multicast stats */ 
		if ( status & RS_MULTICAST )
			lp->stats.multicast++;

#ifdef SUPPORT_OLD_KERNEL
		skb = alloc_skb( packet_length + 5, GFP_ATOMIC );
#else	
		skb = dev_alloc_skb( packet_length + 5); 
#endif

		if ( skb == NULL ) {	
			printk(KERN_NOTICE CARDNAME
			": Low memory, packet dropped.\n");
			lp->stats.rx_dropped++;
		}

		/* 
		 ! This should work without alignment, but it could be
		 ! in the worse case 
		*/
#ifndef SUPPORT_OLD_KERNEL
		/* TODO: Should I use 32bit alignment here ? */
		skb_reserve( skb, 2 );   /* 16 bit alignment */
#endif

		skb->dev = dev;
#ifdef SUPPORT_OLD_KERNEL
		skb->len = packet_length;
		data = skb->data;
#else
		data = skb_put( skb, packet_length);
#endif
#ifdef USE_32_BIT
		/* QUESTION:  Like in the TX routine, do I want 		
		   to send the DWORDs or the bytes first, or some
		   mixture.  A mixture might improve already slow PIO
		   performance  */
		PRINTK3((" Reading %d dwords (and %d bytes) \n", 
			packet_length >> 2, packet_length & 3 ));
		insl(ioaddr + DATA_1 , data, packet_length >> 2 ); 
		/* read the left over bytes */
		insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC), 
			packet_length & 0x3  );
#else
		PRINTK3((" Reading %d words and %d byte(s) \n", 
			(packet_length >> 1 ), packet_length & 1 );
		if ( packet_length & 1 ) 
			*(data++) = inb( ioaddr + DATA_1 ); 
		insw(ioaddr + DATA_1 , data, (packet_length + 1 ) >> 1);
		if ( packet_length & 1 ) {
			data += packet_length & ~1;
			*((data++) = inb( ioaddr + DATA_1 ); 
		}
#endif 		
#if	SMC_DEBUG > 2 	
			print_packet( data, packet_length );
#endif

#ifndef SUPPORT_OLD_KERNEL
		skb->protocol = eth_type_trans(skb, dev ); 
#endif
		netif_rx(skb);
		lp->stats.rx_packets++;
	} else {
		/* error ... */
		lp->stats.rx_errors++;
			
		if ( status & RS_ALGNERR )  lp->stats.rx_frame_errors++;  
		if ( status & (RS_TOOSHORT | RS_TOOLONG ) )  
			lp->stats.rx_length_errors++;
		if ( status & RS_BADCRC)	lp->stats.rx_crc_errors++;
	}
	/*  error or good, tell the card to get rid of this packet */
	outw( MC_RELEASE, ioaddr + MMU_CMD );


	return;
}


/************************************************************************* 
 . smc_tx
 . 
 . Purpose:  Handle a transmit error message.   This will only be called
 .   when an error, because of the AUTO_RELEASE mode. 
 . 
 . Algorithm:
 .	Save pointer and packet no
 .	Get the packet no from the top of the queue
 .	check if it's valid ( if not, is this an error??? )
 .	read the status word 
 .	record the error
 .	( resend?  Not really, since we don't want old packets around )
 .	Restore saved values 
 ************************************************************************/ 
static void smc_tx( struct device * dev ) 
{
	int	ioaddr = dev->base_addr;
	struct smc_local *lp = (struct smc_local *)dev->priv;
	byte saved_packet;
	byte packet_no;
	word tx_status;


	/* assume bank 2  */

	saved_packet = inb( ioaddr + PNR_ARR );
	packet_no = inw( ioaddr + FIFO_PORTS );
	packet_no &= 0x7F;

	/* select this as the packet to read from */
	outb( packet_no, ioaddr + PNR_ARR ); 
	
	/* read the first word from this packet */	
	outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );

	tx_status = inw( ioaddr + DATA_1 );
	PRINTK3((CARDNAME": TX DONE STATUS: %4x \n", tx_status ));
	
	lp->stats.tx_errors++;
	if ( tx_status & TS_LOSTCAR ) lp->stats.tx_carrier_errors++;
	if ( tx_status & TS_LATCOL  ) {
		printk(KERN_DEBUG CARDNAME 
			": Late collision occured on last xmit.\n");
		lp->stats.tx_window_errors++;
	}
#if 0
		if ( tx_status & TS_16COL ) { ... }
#endif 

	if ( tx_status & TS_SUCCESS ) {  
		printk(CARDNAME": Successful packet caused interrupt \n");
	} 
	/* re-enable transmit */
	SMC_SELECT_BANK( 0 );
	outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );

	/* kill the packet */			
	SMC_SELECT_BANK( 2 );
	outw( MC_FREEPKT, ioaddr + MMU_CMD );

	/* one less packet waiting for me */
	lp->packets_waiting--;
		
	outb( saved_packet, ioaddr + PNR_ARR );
	return;
}

/*----------------------------------------------------
 . smc_close
 . 
 . this makes the board clean up everything that it can
 . and not talk to the outside world.   Caused by
 . an 'ifconfig ethX down'
 .
 -----------------------------------------------------*/
static int smc_close(struct device *dev)
{
	dev->tbusy = 1;
	dev->start = 0;

	/* clear everything */
	smc_shutdown( dev->base_addr );

	/* Update the statistics here. */
#ifdef MODULE
	MOD_DEC_USE_COUNT;
#endif

	return 0;
}

/*------------------------------------------------------------
 . Get the current statistics.	
 . This may be called with the card open or closed. 
 .-------------------------------------------------------------*/
static struct enet_statistics * smc_query_statistics(struct device *dev) {
	struct smc_local *lp = (struct smc_local *)dev->priv;

	return &lp->stats;
}

/*-----------------------------------------------------------
 . smc_set_multicast_list
 .  
 . This routine will, depending on the values passed to it,
 . either make it accept multicast packets, go into 
 . promiscuous mode ( for TCPDUMP and cousins ) or accept
 . a select set of multicast packets  
*/
#ifdef SUPPORT_OLD_KERNEL
static void smc_set_multicast_list( struct device * dev, 
			int num_addrs, void * addrs ) 	
#else
static void smc_set_multicast_list(struct device *dev) 
#endif 
{
	short ioaddr = dev->base_addr;

	SMC_SELECT_BANK(0);
#ifdef  SUPPORT_OLD_KERNEL
	if ( num_addrs < 0 )  
#else
	if ( dev->flags & IFF_PROMISC ) 
#endif 
		outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );

/* BUG?  I never disable promiscuous mode if multicasting was turned on. 
   Now, I turn off promiscouos mode, but I don't do anything to multicasting
   when promiscuous mode is turned on. 
*/

	/* Here, I am setting this to accept all multicast packets.  
	   I don't need to zero the multicast table, because the flag is
	   checked before the table is 
	*/
#ifdef  SUPPORT_OLD_KERNEL 
	else if ( num_addrs > 20 )	/* arbitrary constant */
#else
	else if (dev->flags & IFF_ALLMULTI)  
#endif 
		outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR ); 

	/* We just get all multicast packets even if we only want them
	 . from one source.  This will be changed at some future
	 . point. */
#ifdef  SUPPORT_OLD_KERNEL
	else if (num_addrs > 0 ) { 
/* the old kernel support will not have hardware multicast support. It would
   involve more kludges, and make the multicast setting code even worse.  
   Instead, just use the ALMUL method.   This is reasonable, considering that
   it is seldom used
*/
		outw( inw( ioaddr + RCR ) & ~RCR_PROMISC, ioaddr + RCR );
		outw( inw( ioadddr + RCR ) | RCR_ALMUL, ioadddr + RCR );
	}
#else
	else if (dev->mc_count )  { 
		/* support hardware multicasting */
		
		/* be sure I get rid of flags I might have set */	
		outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL), 
			ioaddr + RCR );
		/* NOTE: this has to set the bank, so make sure it is the
		   last thing called.  The bank is set to zero at the top */
		smc_setmulticast( ioaddr, dev->mc_count, dev->mc_list );
	}
#endif
	else  {
		outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL), 
			ioaddr + RCR );

		/* 
		  since I'm disabling all multicast entirely, I need to 
		  clear the multicast list 
		*/
		SMC_SELECT_BANK( 3 );
		outw( 0, ioaddr + MULTICAST1 ); 
		outw( 0, ioaddr + MULTICAST2 ); 
		outw( 0, ioaddr + MULTICAST3 ); 
		outw( 0, ioaddr + MULTICAST4 ); 
	}
}

#ifdef MODULE

static char devicename[9] = { 0, };
static struct device devSMC9194 = {
	devicename, /* device name is inserted by linux/drivers/net/net_init.c */
	0, 0, 0, 0,
	0, 0,  /* I/O address, IRQ */
	0, 0, 0, NULL, smc_init };

int io = 0;
int irq = 0;
int ifport = 0;

int init_module(void)
{
	int result;

	if (io == 0)
		printk(KERN_WARNING 
		CARDNAME": You shouldn't use auto-probing with insmod!\n" );

	/* copy the parameters from insmod into the device structure */
	devSMC9194.base_addr = io;
	devSMC9194.irq       = irq;
	devSMC9194.if_port	= ifport;
	if ((result = register_netdev(&devSMC9194)) != 0)
		return result;

	return 0;
}

void cleanup_module(void)
{
	/* No need to check MOD_IN_USE, as sys_delete_module() checks. */
	unregister_netdev(&devSMC9194);

	free_irq(devSMC9194.irq, NULL );
	irq2dev_map[devSMC9194.irq] = NULL;
	release_region(devSMC9194.base_addr, SMC_IO_EXTENT);

	if (devSMC9194.priv)
		kfree_s(devSMC9194.priv, sizeof(struct smc_local));
}

#endif /* MODULE */

