cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

smc9194.c (43225B)


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