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