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