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