drivers/net/ethernet/smsc/smc9194.c

   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
  57 static const char version[] =
  58         "smc9194.c:v0.14 12/15/00 by Erik Stahlman (erik@vt.edu)\n";
  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
 104 struct devlist {
 105         unsigned int port;
 106         unsigned int irq;
 107 };
 108
 109 static 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.. */
 176 struct 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 */
 208 struct 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 */
 214 static int smc_open(struct net_device *dev);
 215
 216 /*
 217  . Our watchdog timed out. Called by the networking layer
 218 */
 219 static void smc_timeout(struct net_device *dev);
 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 */
 226 static 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 */
 232 static 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 */
 244 static 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 */
 249 static 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 */
 254 static 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 */
 268 static 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
 274 static 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 */
 280 static 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 */
 286 static 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 */
 290 static void smc_reset( int ioaddr );
 291
 292 /* Enable Interrupts, Receive, and Transmit */
 293 static void smc_enable( int ioaddr );
 294
 295 /* this puts the device in an inactive state */
 296 static 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.  */
 300 static 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 */
 319 static 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 */
 359 static 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 */
 385 static 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
 421 static 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 */
 467 static 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 */
 578 static 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                 printk(KERN_DEBUG 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         dev->trans_start = jiffies;
 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 */
 686 static int io;
 687 static int irq;
 688 static int ifport;
 689
 690 struct 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;
 724 out1:
 725         free_irq(dev->irq, dev);
 726         release_region(dev->base_addr, SMC_IO_EXTENT);
 727 out:
 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 */
 739 static 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
 806 static 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_change_mtu         = eth_change_mtu,
 813         .ndo_set_mac_address    = eth_mac_addr,
 814         .ndo_validate_addr      = eth_validate_addr,
 815 };
 816
 817 /*----------------------------------------------------------------------
 818  . Function: smc_probe( int ioaddr )
 819  .
 820  . Purpose:
 821  .      Tests to see if a given ioaddr points to an SMC9xxx chip.
 822  .      Returns a 0 on success
 823  .
 824  . Algorithm:
 825  .      (1) see if the high byte of BANK_SELECT is 0x33
 826  .      (2) compare the ioaddr with the base register's address
 827  .      (3) see if I recognize the chip ID in the appropriate register
 828  .
 829  .---------------------------------------------------------------------
 830  */
 831
 832 /*---------------------------------------------------------------
 833  . Here I do typical initialization tasks.
 834  .
 835  . o  Initialize the structure if needed
 836  . o  print out my vanity message if not done so already
 837  . o  print out what type of hardware is detected
 838  . o  print out the ethernet address
 839  . o  find the IRQ
 840  . o  set up my private data
 841  . o  configure the dev structure with my subroutines
 842  . o  actually GRAB the irq.
 843  . o  GRAB the region
 844  .-----------------------------------------------------------------
 845 */
 846 static int __init smc_probe(struct net_device *dev, int ioaddr)
 847 {
 848         int i, memory, retval;
 849         static unsigned version_printed;
 850         unsigned int bank;
 851
 852         const char *version_string;
 853         const char *if_string;
 854
 855         /* registers */
 856         word revision_register;
 857         word base_address_register;
 858         word configuration_register;
 859         word memory_info_register;
 860         word memory_cfg_register;
 861
 862         /* Grab the region so that no one else tries to probe our ioports. */
 863         if (!request_region(ioaddr, SMC_IO_EXTENT, DRV_NAME))
 864                 return -EBUSY;
 865
 866         dev->irq = irq;
 867         dev->if_port = ifport;
 868
 869         /* First, see if the high byte is 0x33 */
 870         bank = inw( ioaddr + BANK_SELECT );
 871         if ( (bank & 0xFF00) != 0x3300 ) {
 872                 retval = -ENODEV;
 873                 goto err_out;
 874         }
 875         /* The above MIGHT indicate a device, but I need to write to further
 876                 test this.  */
 877         outw( 0x0, ioaddr + BANK_SELECT );
 878         bank = inw( ioaddr + BANK_SELECT );
 879         if ( (bank & 0xFF00 ) != 0x3300 ) {
 880                 retval = -ENODEV;
 881                 goto err_out;
 882         }
 883         /* well, we've already written once, so hopefully another time won't
 884            hurt.  This time, I need to switch the bank register to bank 1,
 885            so I can access the base address register */
 886         SMC_SELECT_BANK(1);
 887         base_address_register = inw( ioaddr + BASE );
 888         if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) )  {
 889                 printk(CARDNAME ": IOADDR %x doesn't match configuration (%x). "
 890                         "Probably not a SMC chip\n",
 891                         ioaddr, base_address_register >> 3 & 0x3E0 );
 892                 /* well, the base address register didn't match.  Must not have
 893                    been a SMC chip after all. */
 894                 retval = -ENODEV;
 895                 goto err_out;
 896         }
 897
 898         /*  check if the revision register is something that I recognize.
 899             These might need to be added to later, as future revisions
 900             could be added.  */
 901         SMC_SELECT_BANK(3);
 902         revision_register  = inw( ioaddr + REVISION );
 903         if ( !chip_ids[ ( revision_register  >> 4 ) & 0xF  ] ) {
 904                 /* I don't recognize this chip, so... */
 905                 printk(CARDNAME ": IO %x: Unrecognized revision register:"
 906                         " %x, Contact author.\n", ioaddr, revision_register);
 907
 908                 retval = -ENODEV;
 909                 goto err_out;
 910         }
 911
 912         /* at this point I'll assume that the chip is an SMC9xxx.
 913            It might be prudent to check a listing of MAC addresses
 914            against the hardware address, or do some other tests. */
 915
 916         if (version_printed++ == 0)
 917                 printk("%s", version);
 918
 919         /* fill in some of the fields */
 920         dev->base_addr = ioaddr;
 921
 922         /*
 923          . Get the MAC address ( bank 1, regs 4 - 9 )
 924         */
 925         SMC_SELECT_BANK( 1 );
 926         for ( i = 0; i < 6; i += 2 ) {
 927                 word    address;
 928
 929                 address = inw( ioaddr + ADDR0 + i  );
 930                 dev->dev_addr[ i + 1] = address >> 8;
 931                 dev->dev_addr[ i ] = address & 0xFF;
 932         }
 933
 934         /* get the memory information */
 935
 936         SMC_SELECT_BANK( 0 );
 937         memory_info_register = inw( ioaddr + MIR );
 938         memory_cfg_register  = inw( ioaddr + MCR );
 939         memory = ( memory_cfg_register >> 9 )  & 0x7;  /* multiplier */
 940         memory *= 256 * ( memory_info_register & 0xFF );
 941
 942         /*
 943          Now, I want to find out more about the chip.  This is sort of
 944          redundant, but it's cleaner to have it in both, rather than having
 945          one VERY long probe procedure.
 946         */
 947         SMC_SELECT_BANK(3);
 948         revision_register  = inw( ioaddr + REVISION );
 949         version_string = chip_ids[ ( revision_register  >> 4 ) & 0xF  ];
 950         if ( !version_string ) {
 951                 /* I shouldn't get here because this call was done before.... */
 952                 retval = -ENODEV;
 953                 goto err_out;
 954         }
 955
 956         /* is it using AUI or 10BaseT ? */
 957         if ( dev->if_port == 0 ) {
 958                 SMC_SELECT_BANK(1);
 959                 configuration_register = inw( ioaddr + CONFIG );
 960                 if ( configuration_register & CFG_AUI_SELECT )
 961                         dev->if_port = 2;
 962                 else
 963                         dev->if_port = 1;
 964         }
 965         if_string = interfaces[ dev->if_port - 1 ];
 966
 967         /* now, reset the chip, and put it into a known state */
 968         smc_reset( ioaddr );
 969
 970         /*
 971          . If dev->irq is 0, then the device has to be banged on to see
 972          . what the IRQ is.
 973          .
 974          . This banging doesn't always detect the IRQ, for unknown reasons.
 975          . a workaround is to reset the chip and try again.
 976          .
 977          . Interestingly, the DOS packet driver *SETS* the IRQ on the card to
 978          . be what is requested on the command line.   I don't do that, mostly
 979          . because the card that I have uses a non-standard method of accessing
 980          . the IRQs, and because this _should_ work in most configurations.
 981          .
 982          . Specifying an IRQ is done with the assumption that the user knows
 983          . what (s)he is doing.  No checking is done!!!!
 984          .
 985         */
 986         if ( dev->irq < 2 ) {
 987                 int     trials;
 988
 989                 trials = 3;
 990                 while ( trials-- ) {
 991                         dev->irq = smc_findirq( ioaddr );
 992                         if ( dev->irq )
 993                                 break;
 994                         /* kick the card and try again */
 995                         smc_reset( ioaddr );
 996                 }
 997         }
 998         if (dev->irq == 0 ) {
 999                 printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n");
1000                 retval = -ENODEV;
1001                 goto err_out;
1002         }
1003
1004         /* now, print out the card info, in a short format.. */
1005
1006         printk("%s: %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ", dev->name,
1007                 version_string, revision_register & 0xF, ioaddr, dev->irq,
1008                 if_string, memory );
1009         /*
1010          . Print the Ethernet address
1011         */
1012         printk("ADDR: %pM\n", dev->dev_addr);
1013
1014         /* Grab the IRQ */
1015         retval = request_irq(dev->irq, smc_interrupt, 0, DRV_NAME, dev);
1016         if (retval) {
1017                 printk("%s: unable to get IRQ %d (irqval=%d).\n", DRV_NAME,
1018                         dev->irq, retval);
1019                 goto err_out;
1020         }
1021
1022         dev->netdev_ops                 = &smc_netdev_ops;
1023         dev->watchdog_timeo             = HZ/20;
1024
1025         return 0;
1026
1027 err_out:
1028         release_region(ioaddr, SMC_IO_EXTENT);
1029         return retval;
1030 }
1031
1032 #if SMC_DEBUG > 2
1033 static void print_packet( byte * buf, int length )
1034 {
1035 #if 0
1036         int i;
1037         int remainder;
1038         int lines;
1039
1040         printk("Packet of length %d\n", length);
1041         lines = length / 16;
1042         remainder = length % 16;
1043
1044         for ( i = 0; i < lines ; i ++ ) {
1045                 int cur;
1046
1047                 for ( cur = 0; cur < 8; cur ++ ) {
1048                         byte a, b;
1049
1050                         a = *(buf ++ );
1051                         b = *(buf ++ );
1052                         printk("%02x%02x ", a, b );
1053                 }
1054                 printk("\n");
1055         }
1056         for ( i = 0; i < remainder/2 ; i++ ) {
1057                 byte a, b;
1058
1059                 a = *(buf ++ );
1060                 b = *(buf ++ );
1061                 printk("%02x%02x ", a, b );
1062         }
1063         printk("\n");
1064 #endif
1065 }
1066 #endif
1067
1068
1069 /*
1070  * Open and Initialize the board
1071  *
1072  * Set up everything, reset the card, etc ..
1073  *
1074  */
1075 static int smc_open(struct net_device *dev)
1076 {
1077         int     ioaddr = dev->base_addr;
1078
1079         int     i;      /* used to set hw ethernet address */
1080
1081         /* clear out all the junk that was put here before... */
1082         memset(netdev_priv(dev), 0, sizeof(struct smc_local));
1083
1084         /* reset the hardware */
1085
1086         smc_reset( ioaddr );
1087         smc_enable( ioaddr );
1088
1089         /* Select which interface to use */
1090
1091         SMC_SELECT_BANK( 1 );
1092         if ( dev->if_port == 1 ) {
1093                 outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT,
1094                         ioaddr + CONFIG );
1095         }
1096         else if ( dev->if_port == 2 ) {
1097                 outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT,
1098                         ioaddr + CONFIG );
1099         }
1100
1101         /*
1102                 According to Becker, I have to set the hardware address
1103                 at this point, because the (l)user can set it with an
1104                 ioctl.  Easily done...
1105         */
1106         SMC_SELECT_BANK( 1 );
1107         for ( i = 0; i < 6; i += 2 ) {
1108                 word    address;
1109
1110                 address = dev->dev_addr[ i + 1 ] << 8 ;
1111                 address  |= dev->dev_addr[ i ];
1112                 outw( address, ioaddr + ADDR0 + i );
1113         }
1114
1115         netif_start_queue(dev);
1116         return 0;
1117 }
1118
1119 /*--------------------------------------------------------
1120  . Called by the kernel to send a packet out into the void
1121  . of the net.  This routine is largely based on
1122  . skeleton.c, from Becker.
1123  .--------------------------------------------------------
1124 */
1125
1126 static void smc_timeout(struct net_device *dev)
1127 {
1128         /* If we get here, some higher level has decided we are broken.
1129            There should really be a "kick me" function call instead. */
1130         printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n",
1131                 tx_done(dev) ? "IRQ conflict" :
1132                 "network cable problem");
1133         /* "kick" the adaptor */
1134         smc_reset( dev->base_addr );
1135         smc_enable( dev->base_addr );
1136         dev->trans_start = jiffies; /* prevent tx timeout */
1137         /* clear anything saved */
1138         ((struct smc_local *)netdev_priv(dev))->saved_skb = NULL;
1139         netif_wake_queue(dev);
1140 }
1141
1142 /*-------------------------------------------------------------
1143  .
1144  . smc_rcv -  receive a packet from the card
1145  .
1146  . There is ( at least ) a packet waiting to be read from
1147  . chip-memory.
1148  .
1149  . o Read the status
1150  . o If an error, record it
1151  . o otherwise, read in the packet
1152  --------------------------------------------------------------
1153 */
1154 static void smc_rcv(struct net_device *dev)
1155 {
1156         int     ioaddr = dev->base_addr;
1157         int     packet_number;
1158         word    status;
1159         word    packet_length;
1160
1161         /* assume bank 2 */
1162
1163         packet_number = inw( ioaddr + FIFO_PORTS );
1164
1165         if ( packet_number & FP_RXEMPTY ) {
1166                 /* we got called , but nothing was on the FIFO */
1167                 PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO.\n"));
1168                 /* don't need to restore anything */
1169                 return;
1170         }
1171
1172         /*  start reading from the start of the packet */
1173         outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );
1174
1175         /* First two words are status and packet_length */
1176         status          = inw( ioaddr + DATA_1 );
1177         packet_length   = inw( ioaddr + DATA_1 );
1178
1179         packet_length &= 0x07ff;  /* mask off top bits */
1180
1181         PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));
1182         /*
1183          . the packet length contains 3 extra words :
1184          . status, length, and an extra word with an odd byte .
1185         */
1186         packet_length -= 6;
1187
1188         if ( !(status & RS_ERRORS ) ){
1189                 /* do stuff to make a new packet */
1190                 struct sk_buff  * skb;
1191                 byte            * data;
1192
1193                 /* read one extra byte */
1194                 if ( status & RS_ODDFRAME )
1195                         packet_length++;
1196
1197                 /* set multicast stats */
1198                 if ( status & RS_MULTICAST )
1199                         dev->stats.multicast++;
1200
1201                 skb = netdev_alloc_skb(dev, packet_length + 5);
1202                 if ( skb == NULL ) {
1203                         dev->stats.rx_dropped++;
1204                         goto done;
1205                 }
1206
1207                 /*
1208                  ! This should work without alignment, but it could be
1209                  ! in the worse case
1210                 */
1211
1212                 skb_reserve( skb, 2 );   /* 16 bit alignment */
1213
1214                 data = skb_put( skb, packet_length);
1215
1216 #ifdef USE_32_BIT
1217                 /* QUESTION:  Like in the TX routine, do I want
1218                    to send the DWORDs or the bytes first, or some
1219                    mixture.  A mixture might improve already slow PIO
1220                    performance  */
1221                 PRINTK3((" Reading %d dwords (and %d bytes)\n",
1222                         packet_length >> 2, packet_length & 3 ));
1223                 insl(ioaddr + DATA_1 , data, packet_length >> 2 );
1224                 /* read the left over bytes */
1225                 insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),
1226                         packet_length & 0x3  );
1227 #else
1228                 PRINTK3((" Reading %d words and %d byte(s)\n",
1229                         (packet_length >> 1 ), packet_length & 1 ));
1230                 insw(ioaddr + DATA_1 , data, packet_length >> 1);
1231                 if ( packet_length & 1 ) {
1232                         data += packet_length & ~1;
1233                         *(data++) = inb( ioaddr + DATA_1 );
1234                 }
1235 #endif
1236 #if     SMC_DEBUG > 2
1237                         print_packet( data, packet_length );
1238 #endif
1239
1240                 skb->protocol = eth_type_trans(skb, dev );
1241                 netif_rx(skb);
1242                 dev->stats.rx_packets++;
1243                 dev->stats.rx_bytes += packet_length;
1244         } else {
1245                 /* error ... */
1246                 dev->stats.rx_errors++;
1247
1248                 if ( status & RS_ALGNERR )  dev->stats.rx_frame_errors++;
1249                 if ( status & (RS_TOOSHORT | RS_TOOLONG ) )
1250                         dev->stats.rx_length_errors++;
1251                 if ( status & RS_BADCRC)        dev->stats.rx_crc_errors++;
1252         }
1253
1254 done:
1255         /*  error or good, tell the card to get rid of this packet */
1256         outw( MC_RELEASE, ioaddr + MMU_CMD );
1257 }
1258
1259
1260 /*************************************************************************
1261  . smc_tx
1262  .
1263  . Purpose:  Handle a transmit error message.   This will only be called
1264  .   when an error, because of the AUTO_RELEASE mode.
1265  .
1266  . Algorithm:
1267  .      Save pointer and packet no
1268  .      Get the packet no from the top of the queue
1269  .      check if it's valid ( if not, is this an error??? )
1270  .      read the status word
1271  .      record the error
1272  .      ( resend?  Not really, since we don't want old packets around )
1273  .      Restore saved values
1274  ************************************************************************/
1275 static void smc_tx( struct net_device * dev )
1276 {
1277         int     ioaddr = dev->base_addr;
1278         struct smc_local *lp = netdev_priv(dev);
1279         byte saved_packet;
1280         byte packet_no;
1281         word tx_status;
1282
1283
1284         /* assume bank 2  */
1285
1286         saved_packet = inb( ioaddr + PNR_ARR );
1287         packet_no = inw( ioaddr + FIFO_PORTS );
1288         packet_no &= 0x7F;
1289
1290         /* select this as the packet to read from */
1291         outb( packet_no, ioaddr + PNR_ARR );
1292
1293         /* read the first word from this packet */
1294         outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
1295
1296         tx_status = inw( ioaddr + DATA_1 );
1297         PRINTK3((CARDNAME": TX DONE STATUS: %4x\n", tx_status));
1298
1299         dev->stats.tx_errors++;
1300         if ( tx_status & TS_LOSTCAR ) dev->stats.tx_carrier_errors++;
1301         if ( tx_status & TS_LATCOL  ) {
1302                 printk(KERN_DEBUG CARDNAME
1303                         ": Late collision occurred on last xmit.\n");
1304                 dev->stats.tx_window_errors++;
1305         }
1306 #if 0
1307                 if ( tx_status & TS_16COL ) { ... }
1308 #endif
1309
1310         if ( tx_status & TS_SUCCESS ) {
1311                 printk(CARDNAME": Successful packet caused interrupt\n");
1312         }
1313         /* re-enable transmit */
1314         SMC_SELECT_BANK( 0 );
1315         outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
1316
1317         /* kill the packet */
1318         SMC_SELECT_BANK( 2 );
1319         outw( MC_FREEPKT, ioaddr + MMU_CMD );
1320
1321         /* one less packet waiting for me */
1322         lp->packets_waiting--;
1323
1324         outb( saved_packet, ioaddr + PNR_ARR );
1325 }
1326
1327 /*--------------------------------------------------------------------
1328  .
1329  . This is the main routine of the driver, to handle the device when
1330  . it needs some attention.
1331  .
1332  . So:
1333  .   first, save state of the chipset
1334  .   branch off into routines to handle each case, and acknowledge
1335  .          each to the interrupt register
1336  .   and finally restore state.
1337  .
1338  ---------------------------------------------------------------------*/
1339
1340 static irqreturn_t smc_interrupt(int irq, void * dev_id)
1341 {
1342         struct net_device *dev  = dev_id;
1343         int ioaddr              = dev->base_addr;
1344         struct smc_local *lp = netdev_priv(dev);
1345
1346         byte    status;
1347         word    card_stats;
1348         byte    mask;
1349         int     timeout;
1350         /* state registers */
1351         word    saved_bank;
1352         word    saved_pointer;
1353         int handled = 0;
1354
1355
1356         PRINTK3((CARDNAME": SMC interrupt started\n"));
1357
1358         saved_bank = inw( ioaddr + BANK_SELECT );
1359
1360         SMC_SELECT_BANK(2);
1361         saved_pointer = inw( ioaddr + POINTER );
1362
1363         mask = inb( ioaddr + INT_MASK );
1364         /* clear all interrupts */
1365         outb( 0, ioaddr + INT_MASK );
1366
1367
1368         /* set a timeout value, so I don't stay here forever */
1369         timeout = 4;
1370
1371         PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x\n", mask));
1372         do {
1373                 /* read the status flag, and mask it */
1374                 status = inb( ioaddr + INTERRUPT ) & mask;
1375                 if (!status )
1376                         break;
1377
1378                 handled = 1;
1379
1380                 PRINTK3((KERN_WARNING CARDNAME
1381                         ": Handling interrupt status %x\n", status));
1382
1383                 if (status & IM_RCV_INT) {
1384                         /* Got a packet(s). */
1385                         PRINTK2((KERN_WARNING CARDNAME
1386                                 ": Receive Interrupt\n"));
1387                         smc_rcv(dev);
1388                 } else if (status & IM_TX_INT ) {
1389                         PRINTK2((KERN_WARNING CARDNAME
1390                                 ": TX ERROR handled\n"));
1391                         smc_tx(dev);
1392                         outb(IM_TX_INT, ioaddr + INTERRUPT );
1393                 } else if (status & IM_TX_EMPTY_INT ) {
1394                         /* update stats */
1395                         SMC_SELECT_BANK( 0 );
1396                         card_stats = inw( ioaddr + COUNTER );
1397                         /* single collisions */
1398                         dev->stats.collisions += card_stats & 0xF;
1399                         card_stats >>= 4;
1400                         /* multiple collisions */
1401                         dev->stats.collisions += card_stats & 0xF;
1402
1403                         /* these are for when linux supports these statistics */
1404
1405                         SMC_SELECT_BANK( 2 );
1406                         PRINTK2((KERN_WARNING CARDNAME
1407                                 ": TX_BUFFER_EMPTY handled\n"));
1408                         outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
1409                         mask &= ~IM_TX_EMPTY_INT;
1410                         dev->stats.tx_packets += lp->packets_waiting;
1411                         lp->packets_waiting = 0;
1412
1413                 } else if (status & IM_ALLOC_INT ) {
1414                         PRINTK2((KERN_DEBUG CARDNAME
1415                                 ": Allocation interrupt\n"));
1416                         /* clear this interrupt so it doesn't happen again */
1417                         mask &= ~IM_ALLOC_INT;
1418
1419                         smc_hardware_send_packet( dev );
1420
1421                         /* enable xmit interrupts based on this */
1422                         mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
1423
1424                         /* and let the card send more packets to me */
1425                         netif_wake_queue(dev);
1426
1427                         PRINTK2((CARDNAME": Handoff done successfully.\n"));
1428                 } else if (status & IM_RX_OVRN_INT ) {
1429                         dev->stats.rx_errors++;
1430                         dev->stats.rx_fifo_errors++;
1431                         outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
1432                 } else if (status & IM_EPH_INT ) {
1433                         PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT\n"));
1434                 } else if (status & IM_ERCV_INT ) {
1435                         PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT\n"));
1436                         outb( IM_ERCV_INT, ioaddr + INTERRUPT );
1437                 }
1438         } while ( timeout -- );
1439
1440
1441         /* restore state register */
1442         SMC_SELECT_BANK( 2 );
1443         outb( mask, ioaddr + INT_MASK );
1444
1445         PRINTK3((KERN_WARNING CARDNAME ": MASK is now %x\n", mask));
1446         outw( saved_pointer, ioaddr + POINTER );
1447
1448         SMC_SELECT_BANK( saved_bank );
1449
1450         PRINTK3((CARDNAME ": Interrupt done\n"));
1451         return IRQ_RETVAL(handled);
1452 }
1453
1454
1455 /*----------------------------------------------------
1456  . smc_close
1457  .
1458  . this makes the board clean up everything that it can
1459  . and not talk to the outside world.   Caused by
1460  . an 'ifconfig ethX down'
1461  .
1462  -----------------------------------------------------*/
1463 static int smc_close(struct net_device *dev)
1464 {
1465         netif_stop_queue(dev);
1466         /* clear everything */
1467         smc_shutdown( dev->base_addr );
1468
1469         /* Update the statistics here. */
1470         return 0;
1471 }
1472
1473 /*-----------------------------------------------------------
1474  . smc_set_multicast_list
1475  .
1476  . This routine will, depending on the values passed to it,
1477  . either make it accept multicast packets, go into
1478  . promiscuous mode ( for TCPDUMP and cousins ) or accept
1479  . a select set of multicast packets
1480 */
1481 static void smc_set_multicast_list(struct net_device *dev)
1482 {
1483         short ioaddr = dev->base_addr;
1484
1485         SMC_SELECT_BANK(0);
1486         if ( dev->flags & IFF_PROMISC )
1487                 outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
1488
1489 /* BUG?  I never disable promiscuous mode if multicasting was turned on.
1490    Now, I turn off promiscuous mode, but I don't do anything to multicasting
1491    when promiscuous mode is turned on.
1492 */
1493
1494         /* Here, I am setting this to accept all multicast packets.
1495            I don't need to zero the multicast table, because the flag is
1496            checked before the table is
1497         */
1498         else if (dev->flags & IFF_ALLMULTI)
1499                 outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );
1500
1501         /* We just get all multicast packets even if we only want them
1502          . from one source.  This will be changed at some future
1503          . point. */
1504         else if (!netdev_mc_empty(dev)) {
1505                 /* support hardware multicasting */
1506
1507                 /* be sure I get rid of flags I might have set */
1508                 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1509                         ioaddr + RCR );
1510                 /* NOTE: this has to set the bank, so make sure it is the
1511                    last thing called.  The bank is set to zero at the top */
1512                 smc_setmulticast(ioaddr, dev);
1513         }
1514         else  {
1515                 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1516                         ioaddr + RCR );
1517
1518                 /*
1519                   since I'm disabling all multicast entirely, I need to
1520                   clear the multicast list
1521                 */
1522                 SMC_SELECT_BANK( 3 );
1523                 outw( 0, ioaddr + MULTICAST1 );
1524                 outw( 0, ioaddr + MULTICAST2 );
1525                 outw( 0, ioaddr + MULTICAST3 );
1526                 outw( 0, ioaddr + MULTICAST4 );
1527         }
1528 }
1529
1530 #ifdef MODULE
1531
1532 static struct net_device *devSMC9194;
1533 MODULE_LICENSE("GPL");
1534
1535 module_param(io, int, 0);
1536 module_param(irq, int, 0);
1537 module_param(ifport, int, 0);
1538 MODULE_PARM_DESC(io, "SMC 99194 I/O base address");
1539 MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");
1540 MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");
1541
1542 int __init init_module(void)
1543 {
1544         if (io == 0)
1545                 printk(KERN_WARNING
1546                 CARDNAME": You shouldn't use auto-probing with insmod!\n" );
1547
1548         /* copy the parameters from insmod into the device structure */
1549         devSMC9194 = smc_init(-1);
1550         if (IS_ERR(devSMC9194))
1551                 return PTR_ERR(devSMC9194);
1552         return 0;
1553 }
1554
1555 void __exit cleanup_module(void)
1556 {
1557         unregister_netdev(devSMC9194);
1558         free_irq(devSMC9194->irq, devSMC9194);
1559         release_region(devSMC9194->base_addr, SMC_IO_EXTENT);
1560         free_netdev(devSMC9194);
1561 }
1562
1563 #endif /* MODULE */