git.oblomov.eu Git - linux-2.6/blob - 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            these are things that the kernel wants me to keep, so users
 195            can find out semi-useless statistics of how well the card is
 196            performing
 197         */
 198         struct net_device_stats stats;
 199
 200         /*
 201            If I have to wait until memory is available to send
 202            a packet, I will store the skbuff here, until I get the
 203            desired memory.  Then, I'll send it out and free it.
 204         */
 205         struct sk_buff * saved_skb;
 206
 207         /*
 208          . This keeps track of how many packets that I have
 209          . sent out.  When an TX_EMPTY interrupt comes, I know
 210          . that all of these have been sent.
 211         */
 212         int     packets_waiting;
 213 };
 214
 215
 216 /*-----------------------------------------------------------------
 217  .
 218  .  The driver can be entered at any of the following entry points.
 219  .
 220  .------------------------------------------------------------------  */
 221
 222 /*
 223  . This is called by  register_netdev().  It is responsible for
 224  . checking the portlist for the SMC9000 series chipset.  If it finds
 225  . one, then it will initialize the device, find the hardware information,
 226  . and sets up the appropriate device parameters.
 227  . NOTE: Interrupts are *OFF* when this procedure is called.
 228  .
 229  . NB:This shouldn't be static since it is referred to externally.
 230 */
 231 struct net_device *smc_init(int unit);
 232
 233 /*
 234  . The kernel calls this function when someone wants to use the device,
 235  . typically 'ifconfig ethX up'.
 236 */
 237 static int smc_open(struct net_device *dev);
 238
 239 /*
 240  . Our watchdog timed out. Called by the networking layer
 241 */
 242 static void smc_timeout(struct net_device *dev);
 243
 244 /*
 245  . This is called by the kernel in response to 'ifconfig ethX down'.  It
 246  . is responsible for cleaning up everything that the open routine
 247  . does, and maybe putting the card into a powerdown state.
 248 */
 249 static int smc_close(struct net_device *dev);
 250
 251 /*
 252  . This routine allows the proc file system to query the driver's
 253  . statistics.
 254 */
 255 static struct net_device_stats * smc_query_statistics( struct net_device *dev);
 256
 257 /*
 258  . Finally, a call to set promiscuous mode ( for TCPDUMP and related
 259  . programs ) and multicast modes.
 260 */
 261 static void smc_set_multicast_list(struct net_device *dev);
 262
 263
 264 /*---------------------------------------------------------------
 265  .
 266  . Interrupt level calls..
 267  .
 268  ----------------------------------------------------------------*/
 269
 270 /*
 271  . Handles the actual interrupt
 272 */
 273 static irqreturn_t smc_interrupt(int irq, void *);
 274 /*
 275  . This is a separate procedure to handle the receipt of a packet, to
 276  . leave the interrupt code looking slightly cleaner
 277 */
 278 static inline void smc_rcv( struct net_device *dev );
 279 /*
 280  . This handles a TX interrupt, which is only called when an error
 281  . relating to a packet is sent.
 282 */
 283 static inline void smc_tx( struct net_device * dev );
 284
 285 /*
 286  ------------------------------------------------------------
 287  .
 288  . Internal routines
 289  .
 290  ------------------------------------------------------------
 291 */
 292
 293 /*
 294  . Test if a given location contains a chip, trying to cause as
 295  . little damage as possible if it's not a SMC chip.
 296 */
 297 static int smc_probe(struct net_device *dev, int ioaddr);
 298
 299 /*
 300  . A rather simple routine to print out a packet for debugging purposes.
 301 */
 302 #if SMC_DEBUG > 2
 303 static void print_packet( byte *, int );
 304 #endif
 305
 306 #define tx_done(dev) 1
 307
 308 /* this is called to actually send the packet to the chip */
 309 static void smc_hardware_send_packet( struct net_device * dev );
 310
 311 /* Since I am not sure if I will have enough room in the chip's ram
 312  . to store the packet, I call this routine, which either sends it
 313  . now, or generates an interrupt when the card is ready for the
 314  . packet */
 315 static int  smc_wait_to_send_packet( struct sk_buff * skb, struct net_device *dev );
 316
 317 /* this does a soft reset on the device */
 318 static void smc_reset( int ioaddr );
 319
 320 /* Enable Interrupts, Receive, and Transmit */
 321 static void smc_enable( int ioaddr );
 322
 323 /* this puts the device in an inactive state */
 324 static void smc_shutdown( int ioaddr );
 325
 326 /* This routine will find the IRQ of the driver if one is not
 327  . specified in the input to the device.  */
 328 static int smc_findirq( int ioaddr );
 329
 330 /*
 331  . Function: smc_reset( int ioaddr )
 332  . Purpose:
 333  .      This sets the SMC91xx chip to its normal state, hopefully from whatever
 334  .      mess that any other DOS driver has put it in.
 335  .
 336  . Maybe I should reset more registers to defaults in here?  SOFTRESET  should
 337  . do that for me.
 338  .
 339  . Method:
 340  .      1.  send a SOFT RESET
 341  .      2.  wait for it to finish
 342  .      3.  enable autorelease mode
 343  .      4.  reset the memory management unit
 344  .      5.  clear all interrupts
 345  .
 346 */
 347 static void smc_reset( int ioaddr )
 348 {
 349         /* This resets the registers mostly to defaults, but doesn't
 350            affect EEPROM.  That seems unnecessary */
 351         SMC_SELECT_BANK( 0 );
 352         outw( RCR_SOFTRESET, ioaddr + RCR );
 353
 354         /* this should pause enough for the chip to be happy */
 355         SMC_DELAY( );
 356
 357         /* Set the transmit and receive configuration registers to
 358            default values */
 359         outw( RCR_CLEAR, ioaddr + RCR );
 360         outw( TCR_CLEAR, ioaddr + TCR );
 361
 362         /* set the control register to automatically
 363            release successfully transmitted packets, to make the best
 364            use out of our limited memory */
 365         SMC_SELECT_BANK( 1 );
 366         outw( inw( ioaddr + CONTROL ) | CTL_AUTO_RELEASE , ioaddr + CONTROL );
 367
 368         /* Reset the MMU */
 369         SMC_SELECT_BANK( 2 );
 370         outw( MC_RESET, ioaddr + MMU_CMD );
 371
 372         /* Note:  It doesn't seem that waiting for the MMU busy is needed here,
 373            but this is a place where future chipsets _COULD_ break.  Be wary
 374            of issuing another MMU command right after this */
 375
 376         outb( 0, ioaddr + INT_MASK );
 377 }
 378
 379 /*
 380  . Function: smc_enable
 381  . Purpose: let the chip talk to the outside work
 382  . Method:
 383  .      1.  Enable the transmitter
 384  .      2.  Enable the receiver
 385  .      3.  Enable interrupts
 386 */
 387 static void smc_enable( int ioaddr )
 388 {
 389         SMC_SELECT_BANK( 0 );
 390         /* see the header file for options in TCR/RCR NORMAL*/
 391         outw( TCR_NORMAL, ioaddr + TCR );
 392         outw( RCR_NORMAL, ioaddr + RCR );
 393
 394         /* now, enable interrupts */
 395         SMC_SELECT_BANK( 2 );
 396         outb( SMC_INTERRUPT_MASK, ioaddr + INT_MASK );
 397 }
 398
 399 /*
 400  . Function: smc_shutdown
 401  . Purpose:  closes down the SMC91xxx chip.
 402  . Method:
 403  .      1. zero the interrupt mask
 404  .      2. clear the enable receive flag
 405  .      3. clear the enable xmit flags
 406  .
 407  . TODO:
 408  .   (1) maybe utilize power down mode.
 409  .      Why not yet?  Because while the chip will go into power down mode,
 410  .      the manual says that it will wake up in response to any I/O requests
 411  .      in the register space.   Empirical results do not show this working.
 412 */
 413 static void smc_shutdown( int ioaddr )
 414 {
 415         /* no more interrupts for me */
 416         SMC_SELECT_BANK( 2 );
 417         outb( 0, ioaddr + INT_MASK );
 418
 419         /* and tell the card to stay away from that nasty outside world */
 420         SMC_SELECT_BANK( 0 );
 421         outb( RCR_CLEAR, ioaddr + RCR );
 422         outb( TCR_CLEAR, ioaddr + TCR );
 423 #if 0
 424         /* finally, shut the chip down */
 425         SMC_SELECT_BANK( 1 );
 426         outw( inw( ioaddr + CONTROL ), CTL_POWERDOWN, ioaddr + CONTROL  );
 427 #endif
 428 }
 429
 430
 431 /*
 432  . Function: smc_setmulticast( int ioaddr, int count, dev_mc_list * adds )
 433  . Purpose:
 434  .    This sets the internal hardware table to filter out unwanted multicast
 435  .    packets before they take up memory.
 436  .
 437  .    The SMC chip uses a hash table where the high 6 bits of the CRC of
 438  .    address are the offset into the table.  If that bit is 1, then the
 439  .    multicast packet is accepted.  Otherwise, it's dropped silently.
 440  .
 441  .    To use the 6 bits as an offset into the table, the high 3 bits are the
 442  .    number of the 8 bit register, while the low 3 bits are the bit within
 443  .    that register.
 444  .
 445  . This routine is based very heavily on the one provided by Peter Cammaert.
 446 */
 447
 448
 449 static void smc_setmulticast( int ioaddr, int count, struct dev_mc_list * addrs ) {
 450         int                     i;
 451         unsigned char           multicast_table[ 8 ];
 452         struct dev_mc_list      * cur_addr;
 453         /* table for flipping the order of 3 bits */
 454         unsigned char invert3[] = { 0, 4, 2, 6, 1, 5, 3, 7 };
 455
 456         /* start with a table of all zeros: reject all */
 457         memset( multicast_table, 0, sizeof( multicast_table ) );
 458
 459         cur_addr = addrs;
 460         for ( i = 0; i < count ; i ++, cur_addr = cur_addr->next  ) {
 461                 int position;
 462
 463                 /* do we have a pointer here? */
 464                 if ( !cur_addr )
 465                         break;
 466                 /* make sure this is a multicast address - shouldn't this
 467                    be a given if we have it here ? */
 468                 if ( !( *cur_addr->dmi_addr & 1 ) )
 469                         continue;
 470
 471                 /* only use the low order bits */
 472                 position = ether_crc_le(6, cur_addr->dmi_addr) & 0x3f;
 473
 474                 /* do some messy swapping to put the bit in the right spot */
 475                 multicast_table[invert3[position&7]] |=
 476                                         (1<<invert3[(position>>3)&7]);
 477
 478         }
 479         /* now, the table can be loaded into the chipset */
 480         SMC_SELECT_BANK( 3 );
 481
 482         for ( i = 0; i < 8 ; i++ ) {
 483                 outb( multicast_table[i], ioaddr + MULTICAST1 + i );
 484         }
 485 }
 486
 487 /*
 488  . Function: smc_wait_to_send_packet( struct sk_buff * skb, struct net_device * )
 489  . Purpose:
 490  .    Attempt to allocate memory for a packet, if chip-memory is not
 491  .    available, then tell the card to generate an interrupt when it
 492  .    is available.
 493  .
 494  . Algorithm:
 495  .
 496  . o    if the saved_skb is not currently null, then drop this packet
 497  .      on the floor.  This should never happen, because of TBUSY.
 498  . o    if the saved_skb is null, then replace it with the current packet,
 499  . o    See if I can sending it now.
 500  . o    (NO): Enable interrupts and let the interrupt handler deal with it.
 501  . o    (YES):Send it now.
 502 */
 503 static int smc_wait_to_send_packet( struct sk_buff * skb, struct net_device * dev )
 504 {
 505         struct smc_local *lp = netdev_priv(dev);
 506         unsigned int ioaddr     = dev->base_addr;
 507         word                    length;
 508         unsigned short          numPages;
 509         word                    time_out;
 510
 511         netif_stop_queue(dev);
 512         /* Well, I want to send the packet.. but I don't know
 513            if I can send it right now...  */
 514
 515         if ( lp->saved_skb) {
 516                 /* THIS SHOULD NEVER HAPPEN. */
 517                 lp->stats.tx_aborted_errors++;
 518                 printk(CARDNAME": Bad Craziness - sent packet while busy.\n" );
 519                 return 1;
 520         }
 521         lp->saved_skb = skb;
 522
 523         length = skb->len;
 524
 525         if (length < ETH_ZLEN) {
 526                 if (skb_padto(skb, ETH_ZLEN)) {
 527                         netif_wake_queue(dev);
 528                         return 0;
 529                 }
 530                 length = ETH_ZLEN;
 531         }
 532
 533         /*
 534         ** The MMU wants the number of pages to be the number of 256 bytes
 535         ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) )
 536         **
 537         ** Pkt size for allocating is data length +6 (for additional status words,
 538         ** length and ctl!) If odd size last byte is included in this header.
 539         */
 540         numPages =  ((length & 0xfffe) + 6) / 256;
 541
 542         if (numPages > 7 ) {
 543                 printk(CARDNAME": Far too big packet error. \n");
 544                 /* freeing the packet is a good thing here... but should
 545                  . any packets of this size get down here?   */
 546                 dev_kfree_skb (skb);
 547                 lp->saved_skb = NULL;
 548                 /* this IS an error, but, i don't want the skb saved */
 549                 netif_wake_queue(dev);
 550                 return 0;
 551         }
 552         /* either way, a packet is waiting now */
 553         lp->packets_waiting++;
 554
 555         /* now, try to allocate the memory */
 556         SMC_SELECT_BANK( 2 );
 557         outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );
 558         /*
 559         . Performance Hack
 560         .
 561         . wait a short amount of time.. if I can send a packet now, I send
 562         . it now.  Otherwise, I enable an interrupt and wait for one to be
 563         . available.
 564         .
 565         . I could have handled this a slightly different way, by checking to
 566         . see if any memory was available in the FREE MEMORY register.  However,
 567         . either way, I need to generate an allocation, and the allocation works
 568         . no matter what, so I saw no point in checking free memory.
 569         */
 570         time_out = MEMORY_WAIT_TIME;
 571         do {
 572                 word    status;
 573
 574                 status = inb( ioaddr + INTERRUPT );
 575                 if ( status & IM_ALLOC_INT ) {
 576                         /* acknowledge the interrupt */
 577                         outb( IM_ALLOC_INT, ioaddr + INTERRUPT );
 578                         break;
 579                 }
 580         } while ( -- time_out );
 581
 582         if ( !time_out ) {
 583                 /* oh well, wait until the chip finds memory later */
 584                 SMC_ENABLE_INT( IM_ALLOC_INT );
 585                 PRINTK2((CARDNAME": memory allocation deferred. \n"));
 586                 /* it's deferred, but I'll handle it later */
 587                 return 0;
 588         }
 589         /* or YES! I can send the packet now.. */
 590         smc_hardware_send_packet(dev);
 591         netif_wake_queue(dev);
 592         return 0;
 593 }
 594
 595 /*
 596  . Function:  smc_hardware_send_packet(struct net_device * )
 597  . Purpose:
 598  .      This sends the actual packet to the SMC9xxx chip.
 599  .
 600  . Algorithm:
 601  .      First, see if a saved_skb is available.
 602  .              ( this should NOT be called if there is no 'saved_skb'
 603  .      Now, find the packet number that the chip allocated
 604  .      Point the data pointers at it in memory
 605  .      Set the length word in the chip's memory
 606  .      Dump the packet to chip memory
 607  .      Check if a last byte is needed ( odd length packet )
 608  .              if so, set the control flag right
 609  .      Tell the card to send it
 610  .      Enable the transmit interrupt, so I know if it failed
 611  .      Free the kernel data if I actually sent it.
 612 */
 613 static void smc_hardware_send_packet( struct net_device * dev )
 614 {
 615         struct smc_local *lp = netdev_priv(dev);
 616         byte                    packet_no;
 617         struct sk_buff *        skb = lp->saved_skb;
 618         word                    length;
 619         unsigned int            ioaddr;
 620         byte                    * buf;
 621
 622         ioaddr = dev->base_addr;
 623
 624         if ( !skb ) {
 625                 PRINTK((CARDNAME": In XMIT with no packet to send \n"));
 626                 return;
 627         }
 628         length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 629         buf = skb->data;
 630
 631         /* If I get here, I _know_ there is a packet slot waiting for me */
 632         packet_no = inb( ioaddr + PNR_ARR + 1 );
 633         if ( packet_no & 0x80 ) {
 634                 /* or isn't there?  BAD CHIP! */
 635                 printk(KERN_DEBUG CARDNAME": Memory allocation failed. \n");
 636                 dev_kfree_skb_any(skb);
 637                 lp->saved_skb = NULL;
 638                 netif_wake_queue(dev);
 639                 return;
 640         }
 641
 642         /* we have a packet address, so tell the card to use it */
 643         outb( packet_no, ioaddr + PNR_ARR );
 644
 645         /* point to the beginning of the packet */
 646         outw( PTR_AUTOINC , ioaddr + POINTER );
 647
 648         PRINTK3((CARDNAME": Trying to xmit packet of length %x\n", length ));
 649 #if SMC_DEBUG > 2
 650         print_packet( buf, length );
 651 #endif
 652
 653         /* send the packet length ( +6 for status, length and ctl byte )
 654            and the status word ( set to zeros ) */
 655 #ifdef USE_32_BIT
 656         outl(  (length +6 ) << 16 , ioaddr + DATA_1 );
 657 #else
 658         outw( 0, ioaddr + DATA_1 );
 659         /* send the packet length ( +6 for status words, length, and ctl*/
 660         outb( (length+6) & 0xFF,ioaddr + DATA_1 );
 661         outb( (length+6) >> 8 , ioaddr + DATA_1 );
 662 #endif
 663
 664         /* send the actual data
 665          . I _think_ it's faster to send the longs first, and then
 666          . mop up by sending the last word.  It depends heavily
 667          . on alignment, at least on the 486.  Maybe it would be
 668          . a good idea to check which is optimal?  But that could take
 669          . almost as much time as is saved?
 670         */
 671 #ifdef USE_32_BIT
 672         if ( length & 0x2  ) {
 673                 outsl(ioaddr + DATA_1, buf,  length >> 2 );
 674 #if !defined(__H8300H__) && !defined(__H8300S__)
 675                 outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
 676 #else
 677                 ctrl_outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
 678 #endif
 679         }
 680         else
 681                 outsl(ioaddr + DATA_1, buf,  length >> 2 );
 682 #else
 683         outsw(ioaddr + DATA_1 , buf, (length ) >> 1);
 684 #endif
 685         /* Send the last byte, if there is one.   */
 686
 687         if ( (length & 1) == 0 ) {
 688                 outw( 0, ioaddr + DATA_1 );
 689         } else {
 690                 outb( buf[length -1 ], ioaddr + DATA_1 );
 691                 outb( 0x20, ioaddr + DATA_1);
 692         }
 693
 694         /* enable the interrupts */
 695         SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );
 696
 697         /* and let the chipset deal with it */
 698         outw( MC_ENQUEUE , ioaddr + MMU_CMD );
 699
 700         PRINTK2((CARDNAME": Sent packet of length %d \n",length));
 701
 702         lp->saved_skb = NULL;
 703         dev_kfree_skb_any (skb);
 704
 705         dev->trans_start = jiffies;
 706
 707         /* we can send another packet */
 708         netif_wake_queue(dev);
 709
 710         return;
 711 }
 712
 713 /*-------------------------------------------------------------------------
 714  |
 715  | smc_init(int unit)
 716  |   Input parameters:
 717  |      dev->base_addr == 0, try to find all possible locations
 718  |      dev->base_addr == 1, return failure code
 719  |      dev->base_addr == 2, always allocate space,  and return success
 720  |      dev->base_addr == <anything else>   this is the address to check
 721  |
 722  |   Output:
 723  |      pointer to net_device or ERR_PTR(error)
 724  |
 725  ---------------------------------------------------------------------------
 726 */
 727 static int io;
 728 static int irq;
 729 static int ifport;
 730
 731 struct net_device * __init smc_init(int unit)
 732 {
 733         struct net_device *dev = alloc_etherdev(sizeof(struct smc_local));
 734         struct devlist *smcdev = smc_devlist;
 735         int err = 0;
 736
 737         if (!dev)
 738                 return ERR_PTR(-ENODEV);
 739
 740         if (unit >= 0) {
 741                 sprintf(dev->name, "eth%d", unit);
 742                 netdev_boot_setup_check(dev);
 743                 io = dev->base_addr;
 744                 irq = dev->irq;
 745         }
 746
 747         if (io > 0x1ff) {       /* Check a single specified location. */
 748                 err = smc_probe(dev, io);
 749         } else if (io != 0) {   /* Don't probe at all. */
 750                 err = -ENXIO;
 751         } else {
 752                 for (;smcdev->port; smcdev++) {
 753                         if (smc_probe(dev, smcdev->port) == 0)
 754                                 break;
 755                 }
 756                 if (!smcdev->port)
 757                         err = -ENODEV;
 758         }
 759         if (err)
 760                 goto out;
 761         err = register_netdev(dev);
 762         if (err)
 763                 goto out1;
 764         return dev;
 765 out1:
 766         free_irq(dev->irq, dev);
 767         release_region(dev->base_addr, SMC_IO_EXTENT);
 768 out:
 769         free_netdev(dev);
 770         return ERR_PTR(err);
 771 }
 772
 773 /*----------------------------------------------------------------------
 774  . smc_findirq
 775  .
 776  . This routine has a simple purpose -- make the SMC chip generate an
 777  . interrupt, so an auto-detect routine can detect it, and find the IRQ,
 778  ------------------------------------------------------------------------
 779 */
 780 int __init smc_findirq( int ioaddr )
 781 {
 782 #ifndef NO_AUTOPROBE
 783         int     timeout = 20;
 784         unsigned long cookie;
 785
 786
 787         cookie = probe_irq_on();
 788
 789         /*
 790          * What I try to do here is trigger an ALLOC_INT. This is done
 791          * by allocating a small chunk of memory, which will give an interrupt
 792          * when done.
 793          */
 794
 795
 796         SMC_SELECT_BANK(2);
 797         /* enable ALLOCation interrupts ONLY */
 798         outb( IM_ALLOC_INT, ioaddr + INT_MASK );
 799
 800         /*
 801          . Allocate 512 bytes of memory.  Note that the chip was just
 802          . reset so all the memory is available
 803         */
 804         outw( MC_ALLOC | 1, ioaddr + MMU_CMD );
 805
 806         /*
 807          . Wait until positive that the interrupt has been generated
 808         */
 809         while ( timeout ) {
 810                 byte    int_status;
 811
 812                 int_status = inb( ioaddr + INTERRUPT );
 813
 814                 if ( int_status & IM_ALLOC_INT )
 815                         break;          /* got the interrupt */
 816                 timeout--;
 817         }
 818         /* there is really nothing that I can do here if timeout fails,
 819            as probe_irq_off will return a 0 anyway, which is what I
 820            want in this case.   Plus, the clean up is needed in both
 821            cases.  */
 822
 823         /* DELAY HERE!
 824            On a fast machine, the status might change before the interrupt
 825            is given to the processor.  This means that the interrupt was
 826            never detected, and probe_irq_off fails to report anything.
 827            This should fix probe_irq_* problems.
 828         */
 829         SMC_DELAY();
 830         SMC_DELAY();
 831
 832         /* and disable all interrupts again */
 833         outb( 0, ioaddr + INT_MASK );
 834
 835         /* and return what I found */
 836         return probe_irq_off(cookie);
 837 #else /* NO_AUTOPROBE */
 838         struct devlist *smcdev;
 839         for (smcdev = smc_devlist; smcdev->port; smcdev++) {
 840                 if (smcdev->port == ioaddr)
 841                         return smcdev->irq;
 842         }
 843         return 0;
 844 #endif
 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: ");
1048         for (i = 0; i < 5; i++)
1049                 printk("%2.2x:", dev->dev_addr[i] );
1050         printk("%2.2x \n", dev->dev_addr[5] );
1051
1052         /* set the private data to zero by default */
1053         memset(dev->priv, 0, sizeof(struct smc_local));
1054
1055         /* Grab the IRQ */
1056         retval = request_irq(dev->irq, &smc_interrupt, 0, DRV_NAME, dev);
1057         if (retval) {
1058                 printk("%s: unable to get IRQ %d (irqval=%d).\n", DRV_NAME,
1059                         dev->irq, retval);
1060                 goto err_out;
1061         }
1062
1063         dev->open                       = smc_open;
1064         dev->stop                       = smc_close;
1065         dev->hard_start_xmit            = smc_wait_to_send_packet;
1066         dev->tx_timeout                 = smc_timeout;
1067         dev->watchdog_timeo             = HZ/20;
1068         dev->get_stats                  = smc_query_statistics;
1069         dev->set_multicast_list         = smc_set_multicast_list;
1070
1071         return 0;
1072
1073 err_out:
1074         release_region(ioaddr, SMC_IO_EXTENT);
1075         return retval;
1076 }
1077
1078 #if SMC_DEBUG > 2
1079 static void print_packet( byte * buf, int length )
1080 {
1081 #if 0
1082         int i;
1083         int remainder;
1084         int lines;
1085
1086         printk("Packet of length %d \n", length );
1087         lines = length / 16;
1088         remainder = length % 16;
1089
1090         for ( i = 0; i < lines ; i ++ ) {
1091                 int cur;
1092
1093                 for ( cur = 0; cur < 8; cur ++ ) {
1094                         byte a, b;
1095
1096                         a = *(buf ++ );
1097                         b = *(buf ++ );
1098                         printk("%02x%02x ", a, b );
1099                 }
1100                 printk("\n");
1101         }
1102         for ( i = 0; i < remainder/2 ; i++ ) {
1103                 byte a, b;
1104
1105                 a = *(buf ++ );
1106                 b = *(buf ++ );
1107                 printk("%02x%02x ", a, b );
1108         }
1109         printk("\n");
1110 #endif
1111 }
1112 #endif
1113
1114
1115 /*
1116  * Open and Initialize the board
1117  *
1118  * Set up everything, reset the card, etc ..
1119  *
1120  */
1121 static int smc_open(struct net_device *dev)
1122 {
1123         int     ioaddr = dev->base_addr;
1124
1125         int     i;      /* used to set hw ethernet address */
1126
1127         /* clear out all the junk that was put here before... */
1128         memset(dev->priv, 0, sizeof(struct smc_local));
1129
1130         /* reset the hardware */
1131
1132         smc_reset( ioaddr );
1133         smc_enable( ioaddr );
1134
1135         /* Select which interface to use */
1136
1137         SMC_SELECT_BANK( 1 );
1138         if ( dev->if_port == 1 ) {
1139                 outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT,
1140                         ioaddr + CONFIG );
1141         }
1142         else if ( dev->if_port == 2 ) {
1143                 outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT,
1144                         ioaddr + CONFIG );
1145         }
1146
1147         /*
1148                 According to Becker, I have to set the hardware address
1149                 at this point, because the (l)user can set it with an
1150                 ioctl.  Easily done...
1151         */
1152         SMC_SELECT_BANK( 1 );
1153         for ( i = 0; i < 6; i += 2 ) {
1154                 word    address;
1155
1156                 address = dev->dev_addr[ i + 1 ] << 8 ;
1157                 address  |= dev->dev_addr[ i ];
1158                 outw( address, ioaddr + ADDR0 + i );
1159         }
1160
1161         netif_start_queue(dev);
1162         return 0;
1163 }
1164
1165 /*--------------------------------------------------------
1166  . Called by the kernel to send a packet out into the void
1167  . of the net.  This routine is largely based on
1168  . skeleton.c, from Becker.
1169  .--------------------------------------------------------
1170 */
1171
1172 static void smc_timeout(struct net_device *dev)
1173 {
1174         /* If we get here, some higher level has decided we are broken.
1175            There should really be a "kick me" function call instead. */
1176         printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n",
1177                 tx_done(dev) ? "IRQ conflict" :
1178                 "network cable problem");
1179         /* "kick" the adaptor */
1180         smc_reset( dev->base_addr );
1181         smc_enable( dev->base_addr );
1182         dev->trans_start = jiffies;
1183         /* clear anything saved */
1184         ((struct smc_local *)dev->priv)->saved_skb = NULL;
1185         netif_wake_queue(dev);
1186 }
1187
1188 /*-------------------------------------------------------------
1189  .
1190  . smc_rcv -  receive a packet from the card
1191  .
1192  . There is ( at least ) a packet waiting to be read from
1193  . chip-memory.
1194  .
1195  . o Read the status
1196  . o If an error, record it
1197  . o otherwise, read in the packet
1198  --------------------------------------------------------------
1199 */
1200 static void smc_rcv(struct net_device *dev)
1201 {
1202         struct smc_local *lp = netdev_priv(dev);
1203         int     ioaddr = dev->base_addr;
1204         int     packet_number;
1205         word    status;
1206         word    packet_length;
1207
1208         /* assume bank 2 */
1209
1210         packet_number = inw( ioaddr + FIFO_PORTS );
1211
1212         if ( packet_number & FP_RXEMPTY ) {
1213                 /* we got called , but nothing was on the FIFO */
1214                 PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO. \n"));
1215                 /* don't need to restore anything */
1216                 return;
1217         }
1218
1219         /*  start reading from the start of the packet */
1220         outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );
1221
1222         /* First two words are status and packet_length */
1223         status          = inw( ioaddr + DATA_1 );
1224         packet_length   = inw( ioaddr + DATA_1 );
1225
1226         packet_length &= 0x07ff;  /* mask off top bits */
1227
1228         PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));
1229         /*
1230          . the packet length contains 3 extra words :
1231          . status, length, and an extra word with an odd byte .
1232         */
1233         packet_length -= 6;
1234
1235         if ( !(status & RS_ERRORS ) ){
1236                 /* do stuff to make a new packet */
1237                 struct sk_buff  * skb;
1238                 byte            * data;
1239
1240                 /* read one extra byte */
1241                 if ( status & RS_ODDFRAME )
1242                         packet_length++;
1243
1244                 /* set multicast stats */
1245                 if ( status & RS_MULTICAST )
1246                         lp->stats.multicast++;
1247
1248                 skb = dev_alloc_skb( packet_length + 5);
1249
1250                 if ( skb == NULL ) {
1251                         printk(KERN_NOTICE CARDNAME ": Low memory, packet dropped.\n");
1252                         lp->stats.rx_dropped++;
1253                         goto done;
1254                 }
1255
1256                 /*
1257                  ! This should work without alignment, but it could be
1258                  ! in the worse case
1259                 */
1260
1261                 skb_reserve( skb, 2 );   /* 16 bit alignment */
1262
1263                 data = skb_put( skb, packet_length);
1264
1265 #ifdef USE_32_BIT
1266                 /* QUESTION:  Like in the TX routine, do I want
1267                    to send the DWORDs or the bytes first, or some
1268                    mixture.  A mixture might improve already slow PIO
1269                    performance  */
1270                 PRINTK3((" Reading %d dwords (and %d bytes) \n",
1271                         packet_length >> 2, packet_length & 3 ));
1272                 insl(ioaddr + DATA_1 , data, packet_length >> 2 );
1273                 /* read the left over bytes */
1274                 insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),
1275                         packet_length & 0x3  );
1276 #else
1277                 PRINTK3((" Reading %d words and %d byte(s) \n",
1278                         (packet_length >> 1 ), packet_length & 1 ));
1279                 insw(ioaddr + DATA_1 , data, packet_length >> 1);
1280                 if ( packet_length & 1 ) {
1281                         data += packet_length & ~1;
1282                         *(data++) = inb( ioaddr + DATA_1 );
1283                 }
1284 #endif
1285 #if     SMC_DEBUG > 2
1286                         print_packet( data, packet_length );
1287 #endif
1288
1289                 skb->protocol = eth_type_trans(skb, dev );
1290                 netif_rx(skb);
1291                 dev->last_rx = jiffies;
1292                 lp->stats.rx_packets++;
1293                 lp->stats.rx_bytes += packet_length;
1294         } else {
1295                 /* error ... */
1296                 lp->stats.rx_errors++;
1297
1298                 if ( status & RS_ALGNERR )  lp->stats.rx_frame_errors++;
1299                 if ( status & (RS_TOOSHORT | RS_TOOLONG ) )
1300                         lp->stats.rx_length_errors++;
1301                 if ( status & RS_BADCRC)        lp->stats.rx_crc_errors++;
1302         }
1303
1304 done:
1305         /*  error or good, tell the card to get rid of this packet */
1306         outw( MC_RELEASE, ioaddr + MMU_CMD );
1307 }
1308
1309
1310 /*************************************************************************
1311  . smc_tx
1312  .
1313  . Purpose:  Handle a transmit error message.   This will only be called
1314  .   when an error, because of the AUTO_RELEASE mode.
1315  .
1316  . Algorithm:
1317  .      Save pointer and packet no
1318  .      Get the packet no from the top of the queue
1319  .      check if it's valid ( if not, is this an error??? )
1320  .      read the status word
1321  .      record the error
1322  .      ( resend?  Not really, since we don't want old packets around )
1323  .      Restore saved values
1324  ************************************************************************/
1325 static void smc_tx( struct net_device * dev )
1326 {
1327         int     ioaddr = dev->base_addr;
1328         struct smc_local *lp = netdev_priv(dev);
1329         byte saved_packet;
1330         byte packet_no;
1331         word tx_status;
1332
1333
1334         /* assume bank 2  */
1335
1336         saved_packet = inb( ioaddr + PNR_ARR );
1337         packet_no = inw( ioaddr + FIFO_PORTS );
1338         packet_no &= 0x7F;
1339
1340         /* select this as the packet to read from */
1341         outb( packet_no, ioaddr + PNR_ARR );
1342
1343         /* read the first word from this packet */
1344         outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
1345
1346         tx_status = inw( ioaddr + DATA_1 );
1347         PRINTK3((CARDNAME": TX DONE STATUS: %4x \n", tx_status ));
1348
1349         lp->stats.tx_errors++;
1350         if ( tx_status & TS_LOSTCAR ) lp->stats.tx_carrier_errors++;
1351         if ( tx_status & TS_LATCOL  ) {
1352                 printk(KERN_DEBUG CARDNAME
1353                         ": Late collision occurred on last xmit.\n");
1354                 lp->stats.tx_window_errors++;
1355         }
1356 #if 0
1357                 if ( tx_status & TS_16COL ) { ... }
1358 #endif
1359
1360         if ( tx_status & TS_SUCCESS ) {
1361                 printk(CARDNAME": Successful packet caused interrupt \n");
1362         }
1363         /* re-enable transmit */
1364         SMC_SELECT_BANK( 0 );
1365         outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
1366
1367         /* kill the packet */
1368         SMC_SELECT_BANK( 2 );
1369         outw( MC_FREEPKT, ioaddr + MMU_CMD );
1370
1371         /* one less packet waiting for me */
1372         lp->packets_waiting--;
1373
1374         outb( saved_packet, ioaddr + PNR_ARR );
1375         return;
1376 }
1377
1378 /*--------------------------------------------------------------------
1379  .
1380  . This is the main routine of the driver, to handle the device when
1381  . it needs some attention.
1382  .
1383  . So:
1384  .   first, save state of the chipset
1385  .   branch off into routines to handle each case, and acknowledge
1386  .          each to the interrupt register
1387  .   and finally restore state.
1388  .
1389  ---------------------------------------------------------------------*/
1390
1391 static irqreturn_t smc_interrupt(int irq, void * dev_id)
1392 {
1393         struct net_device *dev  = dev_id;
1394         int ioaddr              = dev->base_addr;
1395         struct smc_local *lp = netdev_priv(dev);
1396
1397         byte    status;
1398         word    card_stats;
1399         byte    mask;
1400         int     timeout;
1401         /* state registers */
1402         word    saved_bank;
1403         word    saved_pointer;
1404         int handled = 0;
1405
1406
1407         PRINTK3((CARDNAME": SMC interrupt started \n"));
1408
1409         saved_bank = inw( ioaddr + BANK_SELECT );
1410
1411         SMC_SELECT_BANK(2);
1412         saved_pointer = inw( ioaddr + POINTER );
1413
1414         mask = inb( ioaddr + INT_MASK );
1415         /* clear all interrupts */
1416         outb( 0, ioaddr + INT_MASK );
1417
1418
1419         /* set a timeout value, so I don't stay here forever */
1420         timeout = 4;
1421
1422         PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x \n", mask ));
1423         do {
1424                 /* read the status flag, and mask it */
1425                 status = inb( ioaddr + INTERRUPT ) & mask;
1426                 if (!status )
1427                         break;
1428
1429                 handled = 1;
1430
1431                 PRINTK3((KERN_WARNING CARDNAME
1432                         ": Handling interrupt status %x \n", status ));
1433
1434                 if (status & IM_RCV_INT) {
1435                         /* Got a packet(s). */
1436                         PRINTK2((KERN_WARNING CARDNAME
1437                                 ": Receive Interrupt\n"));
1438                         smc_rcv(dev);
1439                 } else if (status & IM_TX_INT ) {
1440                         PRINTK2((KERN_WARNING CARDNAME
1441                                 ": TX ERROR handled\n"));
1442                         smc_tx(dev);
1443                         outb(IM_TX_INT, ioaddr + INTERRUPT );
1444                 } else if (status & IM_TX_EMPTY_INT ) {
1445                         /* update stats */
1446                         SMC_SELECT_BANK( 0 );
1447                         card_stats = inw( ioaddr + COUNTER );
1448                         /* single collisions */
1449                         lp->stats.collisions += card_stats & 0xF;
1450                         card_stats >>= 4;
1451                         /* multiple collisions */
1452                         lp->stats.collisions += card_stats & 0xF;
1453
1454                         /* these are for when linux supports these statistics */
1455
1456                         SMC_SELECT_BANK( 2 );
1457                         PRINTK2((KERN_WARNING CARDNAME
1458                                 ": TX_BUFFER_EMPTY handled\n"));
1459                         outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
1460                         mask &= ~IM_TX_EMPTY_INT;
1461                         lp->stats.tx_packets += lp->packets_waiting;
1462                         lp->packets_waiting = 0;
1463
1464                 } else if (status & IM_ALLOC_INT ) {
1465                         PRINTK2((KERN_DEBUG CARDNAME
1466                                 ": Allocation interrupt \n"));
1467                         /* clear this interrupt so it doesn't happen again */
1468                         mask &= ~IM_ALLOC_INT;
1469
1470                         smc_hardware_send_packet( dev );
1471
1472                         /* enable xmit interrupts based on this */
1473                         mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
1474
1475                         /* and let the card send more packets to me */
1476                         netif_wake_queue(dev);
1477
1478                         PRINTK2((CARDNAME": Handoff done successfully.\n"));
1479                 } else if (status & IM_RX_OVRN_INT ) {
1480                         lp->stats.rx_errors++;
1481                         lp->stats.rx_fifo_errors++;
1482                         outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
1483                 } else if (status & IM_EPH_INT ) {
1484                         PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT \n"));
1485                 } else if (status & IM_ERCV_INT ) {
1486                         PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT \n"));
1487                         outb( IM_ERCV_INT, ioaddr + INTERRUPT );
1488                 }
1489         } while ( timeout -- );
1490
1491
1492         /* restore state register */
1493         SMC_SELECT_BANK( 2 );
1494         outb( mask, ioaddr + INT_MASK );
1495
1496         PRINTK3(( KERN_WARNING CARDNAME ": MASK is now %x \n", mask ));
1497         outw( saved_pointer, ioaddr + POINTER );
1498
1499         SMC_SELECT_BANK( saved_bank );
1500
1501         PRINTK3((CARDNAME ": Interrupt done\n"));
1502         return IRQ_RETVAL(handled);
1503 }
1504
1505
1506 /*----------------------------------------------------
1507  . smc_close
1508  .
1509  . this makes the board clean up everything that it can
1510  . and not talk to the outside world.   Caused by
1511  . an 'ifconfig ethX down'
1512  .
1513  -----------------------------------------------------*/
1514 static int smc_close(struct net_device *dev)
1515 {
1516         netif_stop_queue(dev);
1517         /* clear everything */
1518         smc_shutdown( dev->base_addr );
1519
1520         /* Update the statistics here. */
1521         return 0;
1522 }
1523
1524 /*------------------------------------------------------------
1525  . Get the current statistics.
1526  . This may be called with the card open or closed.
1527  .-------------------------------------------------------------*/
1528 static struct net_device_stats* smc_query_statistics(struct net_device *dev) {
1529         struct smc_local *lp = netdev_priv(dev);
1530
1531         return &lp->stats;
1532 }
1533
1534 /*-----------------------------------------------------------
1535  . smc_set_multicast_list
1536  .
1537  . This routine will, depending on the values passed to it,
1538  . either make it accept multicast packets, go into
1539  . promiscuous mode ( for TCPDUMP and cousins ) or accept
1540  . a select set of multicast packets
1541 */
1542 static void smc_set_multicast_list(struct net_device *dev)
1543 {
1544         short ioaddr = dev->base_addr;
1545
1546         SMC_SELECT_BANK(0);
1547         if ( dev->flags & IFF_PROMISC )
1548                 outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
1549
1550 /* BUG?  I never disable promiscuous mode if multicasting was turned on.
1551    Now, I turn off promiscuous mode, but I don't do anything to multicasting
1552    when promiscuous mode is turned on.
1553 */
1554
1555         /* Here, I am setting this to accept all multicast packets.
1556            I don't need to zero the multicast table, because the flag is
1557            checked before the table is
1558         */
1559         else if (dev->flags & IFF_ALLMULTI)
1560                 outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );
1561
1562         /* We just get all multicast packets even if we only want them
1563          . from one source.  This will be changed at some future
1564          . point. */
1565         else if (dev->mc_count )  {
1566                 /* support hardware multicasting */
1567
1568                 /* be sure I get rid of flags I might have set */
1569                 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1570                         ioaddr + RCR );
1571                 /* NOTE: this has to set the bank, so make sure it is the
1572                    last thing called.  The bank is set to zero at the top */
1573                 smc_setmulticast( ioaddr, dev->mc_count, dev->mc_list );
1574         }
1575         else  {
1576                 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1577                         ioaddr + RCR );
1578
1579                 /*
1580                   since I'm disabling all multicast entirely, I need to
1581                   clear the multicast list
1582                 */
1583                 SMC_SELECT_BANK( 3 );
1584                 outw( 0, ioaddr + MULTICAST1 );
1585                 outw( 0, ioaddr + MULTICAST2 );
1586                 outw( 0, ioaddr + MULTICAST3 );
1587                 outw( 0, ioaddr + MULTICAST4 );
1588         }
1589 }
1590
1591 #ifdef MODULE
1592
1593 static struct net_device *devSMC9194;
1594 MODULE_LICENSE("GPL");
1595
1596 module_param(io, int, 0);
1597 module_param(irq, int, 0);
1598 module_param(ifport, int, 0);
1599 MODULE_PARM_DESC(io, "SMC 99194 I/O base address");
1600 MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");
1601 MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");
1602
1603 int __init init_module(void)
1604 {
1605         if (io == 0)
1606                 printk(KERN_WARNING
1607                 CARDNAME": You shouldn't use auto-probing with insmod!\n" );
1608
1609         /* copy the parameters from insmod into the device structure */
1610         devSMC9194 = smc_init(-1);
1611         if (IS_ERR(devSMC9194))
1612                 return PTR_ERR(devSMC9194);
1613         return 0;
1614 }
1615
1616 void __exit cleanup_module(void)
1617 {
1618         unregister_netdev(devSMC9194);
1619         free_irq(devSMC9194->irq, devSMC9194);
1620         release_region(devSMC9194->base_addr, SMC_IO_EXTENT);
1621         free_netdev(devSMC9194);
1622 }
1623
1624 #endif /* MODULE */