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 *, struct pt_regs *regs);
 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                 skb = skb_padto(skb, ETH_ZLEN);
 527                 if (skb == NULL) {
 528                         netif_wake_queue(dev);
 529                         return 0;
 530                 }
 531                 length = ETH_ZLEN;
 532         }
 533
 534         /*
 535         ** The MMU wants the number of pages to be the number of 256 bytes
 536         ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) )
 537         **
 538         ** Pkt size for allocating is data length +6 (for additional status words,
 539         ** length and ctl!) If odd size last byte is included in this header.
 540         */
 541         numPages =  ((length & 0xfffe) + 6) / 256;
 542
 543         if (numPages > 7 ) {
 544                 printk(CARDNAME": Far too big packet error. \n");
 545                 /* freeing the packet is a good thing here... but should
 546                  . any packets of this size get down here?   */
 547                 dev_kfree_skb (skb);
 548                 lp->saved_skb = NULL;
 549                 /* this IS an error, but, i don't want the skb saved */
 550                 netif_wake_queue(dev);
 551                 return 0;
 552         }
 553         /* either way, a packet is waiting now */
 554         lp->packets_waiting++;
 555
 556         /* now, try to allocate the memory */
 557         SMC_SELECT_BANK( 2 );
 558         outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );
 559         /*
 560         . Performance Hack
 561         .
 562         . wait a short amount of time.. if I can send a packet now, I send
 563         . it now.  Otherwise, I enable an interrupt and wait for one to be
 564         . available.
 565         .
 566         . I could have handled this a slightly different way, by checking to
 567         . see if any memory was available in the FREE MEMORY register.  However,
 568         . either way, I need to generate an allocation, and the allocation works
 569         . no matter what, so I saw no point in checking free memory.
 570         */
 571         time_out = MEMORY_WAIT_TIME;
 572         do {
 573                 word    status;
 574
 575                 status = inb( ioaddr + INTERRUPT );
 576                 if ( status & IM_ALLOC_INT ) {
 577                         /* acknowledge the interrupt */
 578                         outb( IM_ALLOC_INT, ioaddr + INTERRUPT );
 579                         break;
 580                 }
 581         } while ( -- time_out );
 582
 583         if ( !time_out ) {
 584                 /* oh well, wait until the chip finds memory later */
 585                 SMC_ENABLE_INT( IM_ALLOC_INT );
 586                 PRINTK2((CARDNAME": memory allocation deferred. \n"));
 587                 /* it's deferred, but I'll handle it later */
 588                 return 0;
 589         }
 590         /* or YES! I can send the packet now.. */
 591         smc_hardware_send_packet(dev);
 592         netif_wake_queue(dev);
 593         return 0;
 594 }
 595
 596 /*
 597  . Function:  smc_hardware_send_packet(struct net_device * )
 598  . Purpose:
 599  .      This sends the actual packet to the SMC9xxx chip.
 600  .
 601  . Algorithm:
 602  .      First, see if a saved_skb is available.
 603  .              ( this should NOT be called if there is no 'saved_skb'
 604  .      Now, find the packet number that the chip allocated
 605  .      Point the data pointers at it in memory
 606  .      Set the length word in the chip's memory
 607  .      Dump the packet to chip memory
 608  .      Check if a last byte is needed ( odd length packet )
 609  .              if so, set the control flag right
 610  .      Tell the card to send it
 611  .      Enable the transmit interrupt, so I know if it failed
 612  .      Free the kernel data if I actually sent it.
 613 */
 614 static void smc_hardware_send_packet( struct net_device * dev )
 615 {
 616         struct smc_local *lp = netdev_priv(dev);
 617         byte                    packet_no;
 618         struct sk_buff *        skb = lp->saved_skb;
 619         word                    length;
 620         unsigned int            ioaddr;
 621         byte                    * buf;
 622
 623         ioaddr = dev->base_addr;
 624
 625         if ( !skb ) {
 626                 PRINTK((CARDNAME": In XMIT with no packet to send \n"));
 627                 return;
 628         }
 629         length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 630         buf = skb->data;
 631
 632         /* If I get here, I _know_ there is a packet slot waiting for me */
 633         packet_no = inb( ioaddr + PNR_ARR + 1 );
 634         if ( packet_no & 0x80 ) {
 635                 /* or isn't there?  BAD CHIP! */
 636                 printk(KERN_DEBUG CARDNAME": Memory allocation failed. \n");
 637                 dev_kfree_skb_any(skb);
 638                 lp->saved_skb = NULL;
 639                 netif_wake_queue(dev);
 640                 return;
 641         }
 642
 643         /* we have a packet address, so tell the card to use it */
 644         outb( packet_no, ioaddr + PNR_ARR );
 645
 646         /* point to the beginning of the packet */
 647         outw( PTR_AUTOINC , ioaddr + POINTER );
 648
 649         PRINTK3((CARDNAME": Trying to xmit packet of length %x\n", length ));
 650 #if SMC_DEBUG > 2
 651         print_packet( buf, length );
 652 #endif
 653
 654         /* send the packet length ( +6 for status, length and ctl byte )
 655            and the status word ( set to zeros ) */
 656 #ifdef USE_32_BIT
 657         outl(  (length +6 ) << 16 , ioaddr + DATA_1 );
 658 #else
 659         outw( 0, ioaddr + DATA_1 );
 660         /* send the packet length ( +6 for status words, length, and ctl*/
 661         outb( (length+6) & 0xFF,ioaddr + DATA_1 );
 662         outb( (length+6) >> 8 , ioaddr + DATA_1 );
 663 #endif
 664
 665         /* send the actual data
 666          . I _think_ it's faster to send the longs first, and then
 667          . mop up by sending the last word.  It depends heavily
 668          . on alignment, at least on the 486.  Maybe it would be
 669          . a good idea to check which is optimal?  But that could take
 670          . almost as much time as is saved?
 671         */
 672 #ifdef USE_32_BIT
 673         if ( length & 0x2  ) {
 674                 outsl(ioaddr + DATA_1, buf,  length >> 2 );
 675 #if !defined(__H8300H__) && !defined(__H8300S__)
 676                 outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
 677 #else
 678                 ctrl_outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);
 679 #endif
 680         }
 681         else
 682                 outsl(ioaddr + DATA_1, buf,  length >> 2 );
 683 #else
 684         outsw(ioaddr + DATA_1 , buf, (length ) >> 1);
 685 #endif
 686         /* Send the last byte, if there is one.   */
 687
 688         if ( (length & 1) == 0 ) {
 689                 outw( 0, ioaddr + DATA_1 );
 690         } else {
 691                 outb( buf[length -1 ], ioaddr + DATA_1 );
 692                 outb( 0x20, ioaddr + DATA_1);
 693         }
 694
 695         /* enable the interrupts */
 696         SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );
 697
 698         /* and let the chipset deal with it */
 699         outw( MC_ENQUEUE , ioaddr + MMU_CMD );
 700
 701         PRINTK2((CARDNAME": Sent packet of length %d \n",length));
 702
 703         lp->saved_skb = NULL;
 704         dev_kfree_skb_any (skb);
 705
 706         dev->trans_start = jiffies;
 707
 708         /* we can send another packet */
 709         netif_wake_queue(dev);
 710
 711         return;
 712 }
 713
 714 /*-------------------------------------------------------------------------
 715  |
 716  | smc_init(int unit)
 717  |   Input parameters:
 718  |      dev->base_addr == 0, try to find all possible locations
 719  |      dev->base_addr == 1, return failure code
 720  |      dev->base_addr == 2, always allocate space,  and return success
 721  |      dev->base_addr == <anything else>   this is the address to check
 722  |
 723  |   Output:
 724  |      pointer to net_device or ERR_PTR(error)
 725  |
 726  ---------------------------------------------------------------------------
 727 */
 728 static int io;
 729 static int irq;
 730 static int ifport;
 731
 732 struct net_device * __init smc_init(int unit)
 733 {
 734         struct net_device *dev = alloc_etherdev(sizeof(struct smc_local));
 735         static struct devlist *smcdev = smc_devlist;
 736         int err = 0;
 737
 738 #ifndef NO_AUTOPROBE
 739         smcdev = smc_devlist;
 740 #endif
 741         if (!dev)
 742                 return ERR_PTR(-ENODEV);
 743
 744         if (unit >= 0) {
 745                 sprintf(dev->name, "eth%d", unit);
 746                 netdev_boot_setup_check(dev);
 747                 io = dev->base_addr;
 748                 irq = dev->irq;
 749         }
 750
 751         SET_MODULE_OWNER(dev);
 752
 753         if (io > 0x1ff) {       /* Check a single specified location. */
 754                 err = smc_probe(dev, io);
 755         } else if (io != 0) {   /* Don't probe at all. */
 756                 err = -ENXIO;
 757         } else {
 758                 for (;smcdev->port; smcdev++) {
 759                         if (smc_probe(dev, smcdev->port) == 0)
 760                                 break;
 761                 }
 762                 if (!smcdev->port)
 763                         err = -ENODEV;
 764         }
 765         if (err)
 766                 goto out;
 767         err = register_netdev(dev);
 768         if (err)
 769                 goto out1;
 770         return dev;
 771 out1:
 772         free_irq(dev->irq, dev);
 773         release_region(dev->base_addr, SMC_IO_EXTENT);
 774 out:
 775         free_netdev(dev);
 776         return ERR_PTR(err);
 777 }
 778
 779 /*----------------------------------------------------------------------
 780  . smc_findirq
 781  .
 782  . This routine has a simple purpose -- make the SMC chip generate an
 783  . interrupt, so an auto-detect routine can detect it, and find the IRQ,
 784  ------------------------------------------------------------------------
 785 */
 786 int __init smc_findirq( int ioaddr )
 787 {
 788 #ifndef NO_AUTOPROBE
 789         int     timeout = 20;
 790         unsigned long cookie;
 791
 792
 793         cookie = probe_irq_on();
 794
 795         /*
 796          * What I try to do here is trigger an ALLOC_INT. This is done
 797          * by allocating a small chunk of memory, which will give an interrupt
 798          * when done.
 799          */
 800
 801
 802         SMC_SELECT_BANK(2);
 803         /* enable ALLOCation interrupts ONLY */
 804         outb( IM_ALLOC_INT, ioaddr + INT_MASK );
 805
 806         /*
 807          . Allocate 512 bytes of memory.  Note that the chip was just
 808          . reset so all the memory is available
 809         */
 810         outw( MC_ALLOC | 1, ioaddr + MMU_CMD );
 811
 812         /*
 813          . Wait until positive that the interrupt has been generated
 814         */
 815         while ( timeout ) {
 816                 byte    int_status;
 817
 818                 int_status = inb( ioaddr + INTERRUPT );
 819
 820                 if ( int_status & IM_ALLOC_INT )
 821                         break;          /* got the interrupt */
 822                 timeout--;
 823         }
 824         /* there is really nothing that I can do here if timeout fails,
 825            as probe_irq_off will return a 0 anyway, which is what I
 826            want in this case.   Plus, the clean up is needed in both
 827            cases.  */
 828
 829         /* DELAY HERE!
 830            On a fast machine, the status might change before the interrupt
 831            is given to the processor.  This means that the interrupt was
 832            never detected, and probe_irq_off fails to report anything.
 833            This should fix probe_irq_* problems.
 834         */
 835         SMC_DELAY();
 836         SMC_DELAY();
 837
 838         /* and disable all interrupts again */
 839         outb( 0, ioaddr + INT_MASK );
 840
 841         /* and return what I found */
 842         return probe_irq_off(cookie);
 843 #else /* NO_AUTOPROBE */
 844         struct devlist *smcdev;
 845         for (smcdev = smc_devlist; smcdev->port; smcdev++) {
 846                 if (smcdev->port == ioaddr)
 847                         return smcdev->irq;
 848         }
 849         return 0;
 850 #endif
 851 }
 852
 853 /*----------------------------------------------------------------------
 854  . Function: smc_probe( int ioaddr )
 855  .
 856  . Purpose:
 857  .      Tests to see if a given ioaddr points to an SMC9xxx chip.
 858  .      Returns a 0 on success
 859  .
 860  . Algorithm:
 861  .      (1) see if the high byte of BANK_SELECT is 0x33
 862  .      (2) compare the ioaddr with the base register's address
 863  .      (3) see if I recognize the chip ID in the appropriate register
 864  .
 865  .---------------------------------------------------------------------
 866  */
 867
 868 /*---------------------------------------------------------------
 869  . Here I do typical initialization tasks.
 870  .
 871  . o  Initialize the structure if needed
 872  . o  print out my vanity message if not done so already
 873  . o  print out what type of hardware is detected
 874  . o  print out the ethernet address
 875  . o  find the IRQ
 876  . o  set up my private data
 877  . o  configure the dev structure with my subroutines
 878  . o  actually GRAB the irq.
 879  . o  GRAB the region
 880  .-----------------------------------------------------------------
 881 */
 882 static int __init smc_probe(struct net_device *dev, int ioaddr)
 883 {
 884         int i, memory, retval;
 885         static unsigned version_printed;
 886         unsigned int bank;
 887
 888         const char *version_string;
 889         const char *if_string;
 890
 891         /* registers */
 892         word revision_register;
 893         word base_address_register;
 894         word configuration_register;
 895         word memory_info_register;
 896         word memory_cfg_register;
 897
 898         /* Grab the region so that no one else tries to probe our ioports. */
 899         if (!request_region(ioaddr, SMC_IO_EXTENT, DRV_NAME))
 900                 return -EBUSY;
 901
 902         dev->irq = irq;
 903         dev->if_port = ifport;
 904
 905         /* First, see if the high byte is 0x33 */
 906         bank = inw( ioaddr + BANK_SELECT );
 907         if ( (bank & 0xFF00) != 0x3300 ) {
 908                 retval = -ENODEV;
 909                 goto err_out;
 910         }
 911         /* The above MIGHT indicate a device, but I need to write to further
 912                 test this.  */
 913         outw( 0x0, ioaddr + BANK_SELECT );
 914         bank = inw( ioaddr + BANK_SELECT );
 915         if ( (bank & 0xFF00 ) != 0x3300 ) {
 916                 retval = -ENODEV;
 917                 goto err_out;
 918         }
 919 #if !defined(CONFIG_H8S_EDOSK2674)
 920         /* well, we've already written once, so hopefully another time won't
 921            hurt.  This time, I need to switch the bank register to bank 1,
 922            so I can access the base address register */
 923         SMC_SELECT_BANK(1);
 924         base_address_register = inw( ioaddr + BASE );
 925         if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) )  {
 926                 printk(CARDNAME ": IOADDR %x doesn't match configuration (%x)."
 927                         "Probably not a SMC chip\n",
 928                         ioaddr, base_address_register >> 3 & 0x3E0 );
 929                 /* well, the base address register didn't match.  Must not have
 930                    been a SMC chip after all. */
 931                 retval = -ENODEV;
 932                 goto err_out;
 933         }
 934 #else
 935         (void)base_address_register; /* Warning suppression */
 936 #endif
 937
 938
 939         /*  check if the revision register is something that I recognize.
 940             These might need to be added to later, as future revisions
 941             could be added.  */
 942         SMC_SELECT_BANK(3);
 943         revision_register  = inw( ioaddr + REVISION );
 944         if ( !chip_ids[ ( revision_register  >> 4 ) & 0xF  ] ) {
 945                 /* I don't recognize this chip, so... */
 946                 printk(CARDNAME ": IO %x: Unrecognized revision register:"
 947                         " %x, Contact author. \n", ioaddr, revision_register );
 948
 949                 retval = -ENODEV;
 950                 goto err_out;
 951         }
 952
 953         /* at this point I'll assume that the chip is an SMC9xxx.
 954            It might be prudent to check a listing of MAC addresses
 955            against the hardware address, or do some other tests. */
 956
 957         if (version_printed++ == 0)
 958                 printk("%s", version);
 959
 960         /* fill in some of the fields */
 961         dev->base_addr = ioaddr;
 962
 963         /*
 964          . Get the MAC address ( bank 1, regs 4 - 9 )
 965         */
 966         SMC_SELECT_BANK( 1 );
 967         for ( i = 0; i < 6; i += 2 ) {
 968                 word    address;
 969
 970                 address = inw( ioaddr + ADDR0 + i  );
 971                 dev->dev_addr[ i + 1] = address >> 8;
 972                 dev->dev_addr[ i ] = address & 0xFF;
 973         }
 974
 975         /* get the memory information */
 976
 977         SMC_SELECT_BANK( 0 );
 978         memory_info_register = inw( ioaddr + MIR );
 979         memory_cfg_register  = inw( ioaddr + MCR );
 980         memory = ( memory_cfg_register >> 9 )  & 0x7;  /* multiplier */
 981         memory *= 256 * ( memory_info_register & 0xFF );
 982
 983         /*
 984          Now, I want to find out more about the chip.  This is sort of
 985          redundant, but it's cleaner to have it in both, rather than having
 986          one VERY long probe procedure.
 987         */
 988         SMC_SELECT_BANK(3);
 989         revision_register  = inw( ioaddr + REVISION );
 990         version_string = chip_ids[ ( revision_register  >> 4 ) & 0xF  ];
 991         if ( !version_string ) {
 992                 /* I shouldn't get here because this call was done before.... */
 993                 retval = -ENODEV;
 994                 goto err_out;
 995         }
 996
 997         /* is it using AUI or 10BaseT ? */
 998         if ( dev->if_port == 0 ) {
 999                 SMC_SELECT_BANK(1);
1000                 configuration_register = inw( ioaddr + CONFIG );
1001                 if ( configuration_register & CFG_AUI_SELECT )
1002                         dev->if_port = 2;
1003                 else
1004                         dev->if_port = 1;
1005         }
1006         if_string = interfaces[ dev->if_port - 1 ];
1007
1008         /* now, reset the chip, and put it into a known state */
1009         smc_reset( ioaddr );
1010
1011         /*
1012          . If dev->irq is 0, then the device has to be banged on to see
1013          . what the IRQ is.
1014          .
1015          . This banging doesn't always detect the IRQ, for unknown reasons.
1016          . a workaround is to reset the chip and try again.
1017          .
1018          . Interestingly, the DOS packet driver *SETS* the IRQ on the card to
1019          . be what is requested on the command line.   I don't do that, mostly
1020          . because the card that I have uses a non-standard method of accessing
1021          . the IRQs, and because this _should_ work in most configurations.
1022          .
1023          . Specifying an IRQ is done with the assumption that the user knows
1024          . what (s)he is doing.  No checking is done!!!!
1025          .
1026         */
1027         if ( dev->irq < 2 ) {
1028                 int     trials;
1029
1030                 trials = 3;
1031                 while ( trials-- ) {
1032                         dev->irq = smc_findirq( ioaddr );
1033                         if ( dev->irq )
1034                                 break;
1035                         /* kick the card and try again */
1036                         smc_reset( ioaddr );
1037                 }
1038         }
1039         if (dev->irq == 0 ) {
1040                 printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n");
1041                 retval = -ENODEV;
1042                 goto err_out;
1043         }
1044
1045         /* now, print out the card info, in a short format.. */
1046
1047         printk("%s: %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ", dev->name,
1048                 version_string, revision_register & 0xF, ioaddr, dev->irq,
1049                 if_string, memory );
1050         /*
1051          . Print the Ethernet address
1052         */
1053         printk("ADDR: ");
1054         for (i = 0; i < 5; i++)
1055                 printk("%2.2x:", dev->dev_addr[i] );
1056         printk("%2.2x \n", dev->dev_addr[5] );
1057
1058         /* set the private data to zero by default */
1059         memset(dev->priv, 0, sizeof(struct smc_local));
1060
1061         /* Grab the IRQ */
1062         retval = request_irq(dev->irq, &smc_interrupt, 0, DRV_NAME, dev);
1063         if (retval) {
1064                 printk("%s: unable to get IRQ %d (irqval=%d).\n", DRV_NAME,
1065                         dev->irq, retval);
1066                 goto err_out;
1067         }
1068
1069         dev->open                       = smc_open;
1070         dev->stop                       = smc_close;
1071         dev->hard_start_xmit            = smc_wait_to_send_packet;
1072         dev->tx_timeout                 = smc_timeout;
1073         dev->watchdog_timeo             = HZ/20;
1074         dev->get_stats                  = smc_query_statistics;
1075         dev->set_multicast_list         = smc_set_multicast_list;
1076
1077         return 0;
1078
1079 err_out:
1080         release_region(ioaddr, SMC_IO_EXTENT);
1081         return retval;
1082 }
1083
1084 #if SMC_DEBUG > 2
1085 static void print_packet( byte * buf, int length )
1086 {
1087 #if 0
1088         int i;
1089         int remainder;
1090         int lines;
1091
1092         printk("Packet of length %d \n", length );
1093         lines = length / 16;
1094         remainder = length % 16;
1095
1096         for ( i = 0; i < lines ; i ++ ) {
1097                 int cur;
1098
1099                 for ( cur = 0; cur < 8; cur ++ ) {
1100                         byte a, b;
1101
1102                         a = *(buf ++ );
1103                         b = *(buf ++ );
1104                         printk("%02x%02x ", a, b );
1105                 }
1106                 printk("\n");
1107         }
1108         for ( i = 0; i < remainder/2 ; i++ ) {
1109                 byte a, b;
1110
1111                 a = *(buf ++ );
1112                 b = *(buf ++ );
1113                 printk("%02x%02x ", a, b );
1114         }
1115         printk("\n");
1116 #endif
1117 }
1118 #endif
1119
1120
1121 /*
1122  * Open and Initialize the board
1123  *
1124  * Set up everything, reset the card, etc ..
1125  *
1126  */
1127 static int smc_open(struct net_device *dev)
1128 {
1129         int     ioaddr = dev->base_addr;
1130
1131         int     i;      /* used to set hw ethernet address */
1132
1133         /* clear out all the junk that was put here before... */
1134         memset(dev->priv, 0, sizeof(struct smc_local));
1135
1136         /* reset the hardware */
1137
1138         smc_reset( ioaddr );
1139         smc_enable( ioaddr );
1140
1141         /* Select which interface to use */
1142
1143         SMC_SELECT_BANK( 1 );
1144         if ( dev->if_port == 1 ) {
1145                 outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT,
1146                         ioaddr + CONFIG );
1147         }
1148         else if ( dev->if_port == 2 ) {
1149                 outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT,
1150                         ioaddr + CONFIG );
1151         }
1152
1153         /*
1154                 According to Becker, I have to set the hardware address
1155                 at this point, because the (l)user can set it with an
1156                 ioctl.  Easily done...
1157         */
1158         SMC_SELECT_BANK( 1 );
1159         for ( i = 0; i < 6; i += 2 ) {
1160                 word    address;
1161
1162                 address = dev->dev_addr[ i + 1 ] << 8 ;
1163                 address  |= dev->dev_addr[ i ];
1164                 outw( address, ioaddr + ADDR0 + i );
1165         }
1166
1167         netif_start_queue(dev);
1168         return 0;
1169 }
1170
1171 /*--------------------------------------------------------
1172  . Called by the kernel to send a packet out into the void
1173  . of the net.  This routine is largely based on
1174  . skeleton.c, from Becker.
1175  .--------------------------------------------------------
1176 */
1177
1178 static void smc_timeout(struct net_device *dev)
1179 {
1180         /* If we get here, some higher level has decided we are broken.
1181            There should really be a "kick me" function call instead. */
1182         printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n",
1183                 tx_done(dev) ? "IRQ conflict" :
1184                 "network cable problem");
1185         /* "kick" the adaptor */
1186         smc_reset( dev->base_addr );
1187         smc_enable( dev->base_addr );
1188         dev->trans_start = jiffies;
1189         /* clear anything saved */
1190         ((struct smc_local *)dev->priv)->saved_skb = NULL;
1191         netif_wake_queue(dev);
1192 }
1193
1194 /*-------------------------------------------------------------
1195  .
1196  . smc_rcv -  receive a packet from the card
1197  .
1198  . There is ( at least ) a packet waiting to be read from
1199  . chip-memory.
1200  .
1201  . o Read the status
1202  . o If an error, record it
1203  . o otherwise, read in the packet
1204  --------------------------------------------------------------
1205 */
1206 static void smc_rcv(struct net_device *dev)
1207 {
1208         struct smc_local *lp = netdev_priv(dev);
1209         int     ioaddr = dev->base_addr;
1210         int     packet_number;
1211         word    status;
1212         word    packet_length;
1213
1214         /* assume bank 2 */
1215
1216         packet_number = inw( ioaddr + FIFO_PORTS );
1217
1218         if ( packet_number & FP_RXEMPTY ) {
1219                 /* we got called , but nothing was on the FIFO */
1220                 PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO. \n"));
1221                 /* don't need to restore anything */
1222                 return;
1223         }
1224
1225         /*  start reading from the start of the packet */
1226         outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );
1227
1228         /* First two words are status and packet_length */
1229         status          = inw( ioaddr + DATA_1 );
1230         packet_length   = inw( ioaddr + DATA_1 );
1231
1232         packet_length &= 0x07ff;  /* mask off top bits */
1233
1234         PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));
1235         /*
1236          . the packet length contains 3 extra words :
1237          . status, length, and an extra word with an odd byte .
1238         */
1239         packet_length -= 6;
1240
1241         if ( !(status & RS_ERRORS ) ){
1242                 /* do stuff to make a new packet */
1243                 struct sk_buff  * skb;
1244                 byte            * data;
1245
1246                 /* read one extra byte */
1247                 if ( status & RS_ODDFRAME )
1248                         packet_length++;
1249
1250                 /* set multicast stats */
1251                 if ( status & RS_MULTICAST )
1252                         lp->stats.multicast++;
1253
1254                 skb = dev_alloc_skb( packet_length + 5);
1255
1256                 if ( skb == NULL ) {
1257                         printk(KERN_NOTICE CARDNAME ": Low memory, packet dropped.\n");
1258                         lp->stats.rx_dropped++;
1259                         goto done;
1260                 }
1261
1262                 /*
1263                  ! This should work without alignment, but it could be
1264                  ! in the worse case
1265                 */
1266
1267                 skb_reserve( skb, 2 );   /* 16 bit alignment */
1268
1269                 skb->dev = dev;
1270                 data = skb_put( skb, packet_length);
1271
1272 #ifdef USE_32_BIT
1273                 /* QUESTION:  Like in the TX routine, do I want
1274                    to send the DWORDs or the bytes first, or some
1275                    mixture.  A mixture might improve already slow PIO
1276                    performance  */
1277                 PRINTK3((" Reading %d dwords (and %d bytes) \n",
1278                         packet_length >> 2, packet_length & 3 ));
1279                 insl(ioaddr + DATA_1 , data, packet_length >> 2 );
1280                 /* read the left over bytes */
1281                 insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),
1282                         packet_length & 0x3  );
1283 #else
1284                 PRINTK3((" Reading %d words and %d byte(s) \n",
1285                         (packet_length >> 1 ), packet_length & 1 ));
1286                 insw(ioaddr + DATA_1 , data, packet_length >> 1);
1287                 if ( packet_length & 1 ) {
1288                         data += packet_length & ~1;
1289                         *(data++) = inb( ioaddr + DATA_1 );
1290                 }
1291 #endif
1292 #if     SMC_DEBUG > 2
1293                         print_packet( data, packet_length );
1294 #endif
1295
1296                 skb->protocol = eth_type_trans(skb, dev );
1297                 netif_rx(skb);
1298                 dev->last_rx = jiffies;
1299                 lp->stats.rx_packets++;
1300                 lp->stats.rx_bytes += packet_length;
1301         } else {
1302                 /* error ... */
1303                 lp->stats.rx_errors++;
1304
1305                 if ( status & RS_ALGNERR )  lp->stats.rx_frame_errors++;
1306                 if ( status & (RS_TOOSHORT | RS_TOOLONG ) )
1307                         lp->stats.rx_length_errors++;
1308                 if ( status & RS_BADCRC)        lp->stats.rx_crc_errors++;
1309         }
1310
1311 done:
1312         /*  error or good, tell the card to get rid of this packet */
1313         outw( MC_RELEASE, ioaddr + MMU_CMD );
1314 }
1315
1316
1317 /*************************************************************************
1318  . smc_tx
1319  .
1320  . Purpose:  Handle a transmit error message.   This will only be called
1321  .   when an error, because of the AUTO_RELEASE mode.
1322  .
1323  . Algorithm:
1324  .      Save pointer and packet no
1325  .      Get the packet no from the top of the queue
1326  .      check if it's valid ( if not, is this an error??? )
1327  .      read the status word
1328  .      record the error
1329  .      ( resend?  Not really, since we don't want old packets around )
1330  .      Restore saved values
1331  ************************************************************************/
1332 static void smc_tx( struct net_device * dev )
1333 {
1334         int     ioaddr = dev->base_addr;
1335         struct smc_local *lp = netdev_priv(dev);
1336         byte saved_packet;
1337         byte packet_no;
1338         word tx_status;
1339
1340
1341         /* assume bank 2  */
1342
1343         saved_packet = inb( ioaddr + PNR_ARR );
1344         packet_no = inw( ioaddr + FIFO_PORTS );
1345         packet_no &= 0x7F;
1346
1347         /* select this as the packet to read from */
1348         outb( packet_no, ioaddr + PNR_ARR );
1349
1350         /* read the first word from this packet */
1351         outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );
1352
1353         tx_status = inw( ioaddr + DATA_1 );
1354         PRINTK3((CARDNAME": TX DONE STATUS: %4x \n", tx_status ));
1355
1356         lp->stats.tx_errors++;
1357         if ( tx_status & TS_LOSTCAR ) lp->stats.tx_carrier_errors++;
1358         if ( tx_status & TS_LATCOL  ) {
1359                 printk(KERN_DEBUG CARDNAME
1360                         ": Late collision occurred on last xmit.\n");
1361                 lp->stats.tx_window_errors++;
1362         }
1363 #if 0
1364                 if ( tx_status & TS_16COL ) { ... }
1365 #endif
1366
1367         if ( tx_status & TS_SUCCESS ) {
1368                 printk(CARDNAME": Successful packet caused interrupt \n");
1369         }
1370         /* re-enable transmit */
1371         SMC_SELECT_BANK( 0 );
1372         outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );
1373
1374         /* kill the packet */
1375         SMC_SELECT_BANK( 2 );
1376         outw( MC_FREEPKT, ioaddr + MMU_CMD );
1377
1378         /* one less packet waiting for me */
1379         lp->packets_waiting--;
1380
1381         outb( saved_packet, ioaddr + PNR_ARR );
1382         return;
1383 }
1384
1385 /*--------------------------------------------------------------------
1386  .
1387  . This is the main routine of the driver, to handle the device when
1388  . it needs some attention.
1389  .
1390  . So:
1391  .   first, save state of the chipset
1392  .   branch off into routines to handle each case, and acknowledge
1393  .          each to the interrupt register
1394  .   and finally restore state.
1395  .
1396  ---------------------------------------------------------------------*/
1397
1398 static irqreturn_t smc_interrupt(int irq, void * dev_id,  struct pt_regs * regs)
1399 {
1400         struct net_device *dev  = dev_id;
1401         int ioaddr              = dev->base_addr;
1402         struct smc_local *lp = netdev_priv(dev);
1403
1404         byte    status;
1405         word    card_stats;
1406         byte    mask;
1407         int     timeout;
1408         /* state registers */
1409         word    saved_bank;
1410         word    saved_pointer;
1411         int handled = 0;
1412
1413
1414         PRINTK3((CARDNAME": SMC interrupt started \n"));
1415
1416         saved_bank = inw( ioaddr + BANK_SELECT );
1417
1418         SMC_SELECT_BANK(2);
1419         saved_pointer = inw( ioaddr + POINTER );
1420
1421         mask = inb( ioaddr + INT_MASK );
1422         /* clear all interrupts */
1423         outb( 0, ioaddr + INT_MASK );
1424
1425
1426         /* set a timeout value, so I don't stay here forever */
1427         timeout = 4;
1428
1429         PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x \n", mask ));
1430         do {
1431                 /* read the status flag, and mask it */
1432                 status = inb( ioaddr + INTERRUPT ) & mask;
1433                 if (!status )
1434                         break;
1435
1436                 handled = 1;
1437
1438                 PRINTK3((KERN_WARNING CARDNAME
1439                         ": Handling interrupt status %x \n", status ));
1440
1441                 if (status & IM_RCV_INT) {
1442                         /* Got a packet(s). */
1443                         PRINTK2((KERN_WARNING CARDNAME
1444                                 ": Receive Interrupt\n"));
1445                         smc_rcv(dev);
1446                 } else if (status & IM_TX_INT ) {
1447                         PRINTK2((KERN_WARNING CARDNAME
1448                                 ": TX ERROR handled\n"));
1449                         smc_tx(dev);
1450                         outb(IM_TX_INT, ioaddr + INTERRUPT );
1451                 } else if (status & IM_TX_EMPTY_INT ) {
1452                         /* update stats */
1453                         SMC_SELECT_BANK( 0 );
1454                         card_stats = inw( ioaddr + COUNTER );
1455                         /* single collisions */
1456                         lp->stats.collisions += card_stats & 0xF;
1457                         card_stats >>= 4;
1458                         /* multiple collisions */
1459                         lp->stats.collisions += card_stats & 0xF;
1460
1461                         /* these are for when linux supports these statistics */
1462
1463                         SMC_SELECT_BANK( 2 );
1464                         PRINTK2((KERN_WARNING CARDNAME
1465                                 ": TX_BUFFER_EMPTY handled\n"));
1466                         outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );
1467                         mask &= ~IM_TX_EMPTY_INT;
1468                         lp->stats.tx_packets += lp->packets_waiting;
1469                         lp->packets_waiting = 0;
1470
1471                 } else if (status & IM_ALLOC_INT ) {
1472                         PRINTK2((KERN_DEBUG CARDNAME
1473                                 ": Allocation interrupt \n"));
1474                         /* clear this interrupt so it doesn't happen again */
1475                         mask &= ~IM_ALLOC_INT;
1476
1477                         smc_hardware_send_packet( dev );
1478
1479                         /* enable xmit interrupts based on this */
1480                         mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );
1481
1482                         /* and let the card send more packets to me */
1483                         netif_wake_queue(dev);
1484
1485                         PRINTK2((CARDNAME": Handoff done successfully.\n"));
1486                 } else if (status & IM_RX_OVRN_INT ) {
1487                         lp->stats.rx_errors++;
1488                         lp->stats.rx_fifo_errors++;
1489                         outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );
1490                 } else if (status & IM_EPH_INT ) {
1491                         PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT \n"));
1492                 } else if (status & IM_ERCV_INT ) {
1493                         PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT \n"));
1494                         outb( IM_ERCV_INT, ioaddr + INTERRUPT );
1495                 }
1496         } while ( timeout -- );
1497
1498
1499         /* restore state register */
1500         SMC_SELECT_BANK( 2 );
1501         outb( mask, ioaddr + INT_MASK );
1502
1503         PRINTK3(( KERN_WARNING CARDNAME ": MASK is now %x \n", mask ));
1504         outw( saved_pointer, ioaddr + POINTER );
1505
1506         SMC_SELECT_BANK( saved_bank );
1507
1508         PRINTK3((CARDNAME ": Interrupt done\n"));
1509         return IRQ_RETVAL(handled);
1510 }
1511
1512
1513 /*----------------------------------------------------
1514  . smc_close
1515  .
1516  . this makes the board clean up everything that it can
1517  . and not talk to the outside world.   Caused by
1518  . an 'ifconfig ethX down'
1519  .
1520  -----------------------------------------------------*/
1521 static int smc_close(struct net_device *dev)
1522 {
1523         netif_stop_queue(dev);
1524         /* clear everything */
1525         smc_shutdown( dev->base_addr );
1526
1527         /* Update the statistics here. */
1528         return 0;
1529 }
1530
1531 /*------------------------------------------------------------
1532  . Get the current statistics.
1533  . This may be called with the card open or closed.
1534  .-------------------------------------------------------------*/
1535 static struct net_device_stats* smc_query_statistics(struct net_device *dev) {
1536         struct smc_local *lp = netdev_priv(dev);
1537
1538         return &lp->stats;
1539 }
1540
1541 /*-----------------------------------------------------------
1542  . smc_set_multicast_list
1543  .
1544  . This routine will, depending on the values passed to it,
1545  . either make it accept multicast packets, go into
1546  . promiscuous mode ( for TCPDUMP and cousins ) or accept
1547  . a select set of multicast packets
1548 */
1549 static void smc_set_multicast_list(struct net_device *dev)
1550 {
1551         short ioaddr = dev->base_addr;
1552
1553         SMC_SELECT_BANK(0);
1554         if ( dev->flags & IFF_PROMISC )
1555                 outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );
1556
1557 /* BUG?  I never disable promiscuous mode if multicasting was turned on.
1558    Now, I turn off promiscuous mode, but I don't do anything to multicasting
1559    when promiscuous mode is turned on.
1560 */
1561
1562         /* Here, I am setting this to accept all multicast packets.
1563            I don't need to zero the multicast table, because the flag is
1564            checked before the table is
1565         */
1566         else if (dev->flags & IFF_ALLMULTI)
1567                 outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );
1568
1569         /* We just get all multicast packets even if we only want them
1570          . from one source.  This will be changed at some future
1571          . point. */
1572         else if (dev->mc_count )  {
1573                 /* support hardware multicasting */
1574
1575                 /* be sure I get rid of flags I might have set */
1576                 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1577                         ioaddr + RCR );
1578                 /* NOTE: this has to set the bank, so make sure it is the
1579                    last thing called.  The bank is set to zero at the top */
1580                 smc_setmulticast( ioaddr, dev->mc_count, dev->mc_list );
1581         }
1582         else  {
1583                 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),
1584                         ioaddr + RCR );
1585
1586                 /*
1587                   since I'm disabling all multicast entirely, I need to
1588                   clear the multicast list
1589                 */
1590                 SMC_SELECT_BANK( 3 );
1591                 outw( 0, ioaddr + MULTICAST1 );
1592                 outw( 0, ioaddr + MULTICAST2 );
1593                 outw( 0, ioaddr + MULTICAST3 );
1594                 outw( 0, ioaddr + MULTICAST4 );
1595         }
1596 }
1597
1598 #ifdef MODULE
1599
1600 static struct net_device *devSMC9194;
1601 MODULE_LICENSE("GPL");
1602
1603 module_param(io, int, 0);
1604 module_param(irq, int, 0);
1605 module_param(ifport, int, 0);
1606 MODULE_PARM_DESC(io, "SMC 99194 I/O base address");
1607 MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");
1608 MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");
1609
1610 int init_module(void)
1611 {
1612         if (io == 0)
1613                 printk(KERN_WARNING
1614                 CARDNAME": You shouldn't use auto-probing with insmod!\n" );
1615
1616         /* copy the parameters from insmod into the device structure */
1617         devSMC9194 = smc_init(-1);
1618         if (IS_ERR(devSMC9194))
1619                 return PTR_ERR(devSMC9194);
1620         return 0;
1621 }
1622
1623 void cleanup_module(void)
1624 {
1625         unregister_netdev(devSMC9194);
1626         free_irq(devSMC9194->irq, devSMC9194);
1627         release_region(devSMC9194->base_addr, SMC_IO_EXTENT);
1628         free_netdev(devSMC9194);
1629 }
1630
1631 #endif /* MODULE */