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