root/drivers/net/smc9194.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. smc_reset
  2. smc_enable
  3. smc_shutdown
  4. smc_setmulticast
  5. crc32
  6. smc_wait_to_send_packet
  7. smc_hardware_send_packet
  8. smc_init
  9. smc_findirq
  10. smc_probe
  11. smc_initcard
  12. print_packet
  13. smc_open
  14. smc_send_packet
  15. smc_interrupt
  16. smc_rcv
  17. smc_tx
  18. smc_close
  19. smc_query_statistics
  20. smc_set_multicast_list
  21. init_module
  22. cleanup_module

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

/* [previous][next][first][last][top][bottom][index][help] */