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