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} 411 412 413/* 414 . Function: smc_setmulticast( int ioaddr, struct net_device *dev ) 415 . Purpose: 416 . This sets the internal hardware table to filter out unwanted multicast 417 . packets before they take up memory. 418 . 419 . The SMC chip uses a hash table where the high 6 bits of the CRC of 420 . address are the offset into the table. If that bit is 1, then the 421 . multicast packet is accepted. Otherwise, it's dropped silently. 422 . 423 . To use the 6 bits as an offset into the table, the high 3 bits are the 424 . number of the 8 bit register, while the low 3 bits are the bit within 425 . that register. 426 . 427 . This routine is based very heavily on the one provided by Peter Cammaert. 428*/ 429 430 431static void smc_setmulticast(int ioaddr, struct net_device *dev) 432{ 433 int i; 434 unsigned char multicast_table[ 8 ]; 435 struct netdev_hw_addr *ha; 436 /* table for flipping the order of 3 bits */ 437 unsigned char invert3[] = { 0, 4, 2, 6, 1, 5, 3, 7 }; 438 439 /* start with a table of all zeros: reject all */ 440 memset( multicast_table, 0, sizeof( multicast_table ) ); 441 442 netdev_for_each_mc_addr(ha, dev) { 443 int position; 444 445 /* make sure this is a multicast address - shouldn't this 446 be a given if we have it here ? */ 447 if (!(*ha->addr & 1)) 448 continue; 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_multicast_list = 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 if ( dev->irq < 2 ) { 995 int trials; 996 997 trials = 3; 998 while ( trials-- ) { 999 dev->irq = smc_findirq( ioaddr ); 1000 if ( dev->irq ) 1001 break; 1002 /* kick the card and try again */ 1003 smc_reset( ioaddr ); 1004 } 1005 } 1006 if (dev->irq == 0 ) { 1007 printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n"); 1008 retval = -ENODEV; 1009 goto err_out; 1010 } 1011 1012 /* now, print out the card info, in a short format.. */ 1013 1014 printk("%s: %s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ", dev->name, 1015 version_string, revision_register & 0xF, ioaddr, dev->irq, 1016 if_string, memory ); 1017 /* 1018 . Print the Ethernet address 1019 */ 1020 printk("ADDR: %pM\n", dev->dev_addr); 1021 1022 /* Grab the IRQ */ 1023 retval = request_irq(dev->irq, smc_interrupt, 0, DRV_NAME, dev); 1024 if (retval) { 1025 printk("%s: unable to get IRQ %d (irqval=%d).\n", DRV_NAME, 1026 dev->irq, retval); 1027 goto err_out; 1028 } 1029 1030 dev->netdev_ops = &smc_netdev_ops; 1031 dev->watchdog_timeo = HZ/20; 1032 1033 return 0; 1034 1035err_out: 1036 release_region(ioaddr, SMC_IO_EXTENT); 1037 return retval; 1038} 1039 1040#if SMC_DEBUG > 2 1041static void print_packet( byte * buf, int length ) 1042{ 1043} 1044#endif 1045 1046 1047/* 1048 * Open and Initialize the board 1049 * 1050 * Set up everything, reset the card, etc .. 1051 * 1052 */ 1053static int smc_open(struct net_device *dev) 1054{ 1055 int ioaddr = dev->base_addr; 1056 1057 int i; /* used to set hw ethernet address */ 1058 1059 /* clear out all the junk that was put here before... */ 1060 memset(netdev_priv(dev), 0, sizeof(struct smc_local)); 1061 1062 /* reset the hardware */ 1063 1064 smc_reset( ioaddr ); 1065 smc_enable( ioaddr ); 1066 1067 /* Select which interface to use */ 1068 1069 SMC_SELECT_BANK( 1 ); 1070 if ( dev->if_port == 1 ) { 1071 outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT, 1072 ioaddr + CONFIG ); 1073 } 1074 else if ( dev->if_port == 2 ) { 1075 outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT, 1076 ioaddr + CONFIG ); 1077 } 1078 1079 /* 1080 According to Becker, I have to set the hardware address 1081 at this point, because the (l)user can set it with an 1082 ioctl. Easily done... 1083 */ 1084 SMC_SELECT_BANK( 1 ); 1085 for ( i = 0; i < 6; i += 2 ) { 1086 word address; 1087 1088 address = dev->dev_addr[ i + 1 ] << 8 ; 1089 address |= dev->dev_addr[ i ]; 1090 outw( address, ioaddr + ADDR0 + i ); 1091 } 1092 1093 netif_start_queue(dev); 1094 return 0; 1095} 1096 1097/*-------------------------------------------------------- 1098 . Called by the kernel to send a packet out into the void 1099 . of the net. This routine is largely based on 1100 . skeleton.c, from Becker. 1101 .-------------------------------------------------------- 1102*/ 1103 1104static void smc_timeout(struct net_device *dev) 1105{ 1106 /* If we get here, some higher level has decided we are broken. 1107 There should really be a "kick me" function call instead. */ 1108 printk(KERN_WARNING CARDNAME": transmit timed out, %s?\n", 1109 tx_done(dev) ? "IRQ conflict" : 1110 "network cable problem"); 1111 /* "kick" the adaptor */ 1112 smc_reset( dev->base_addr ); 1113 smc_enable( dev->base_addr ); 1114 dev->trans_start = jiffies; /* prevent tx timeout */ 1115 /* clear anything saved */ 1116 ((struct smc_local *)netdev_priv(dev))->saved_skb = NULL; 1117 netif_wake_queue(dev); 1118} 1119 1120/*------------------------------------------------------------- 1121 . 1122 . smc_rcv - receive a packet from the card 1123 . 1124 . There is ( at least ) a packet waiting to be read from 1125 . chip-memory. 1126 . 1127 . o Read the status 1128 . o If an error, record it 1129 . o otherwise, read in the packet 1130 -------------------------------------------------------------- 1131*/ 1132static void smc_rcv(struct net_device *dev) 1133{ 1134 int ioaddr = dev->base_addr; 1135 int packet_number; 1136 word status; 1137 word packet_length; 1138 1139 /* assume bank 2 */ 1140 1141 packet_number = inw( ioaddr + FIFO_PORTS ); 1142 1143 if ( packet_number & FP_RXEMPTY ) { 1144 /* we got called , but nothing was on the FIFO */ 1145 PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO.\n")); 1146 /* don't need to restore anything */ 1147 return; 1148 } 1149 1150 /* start reading from the start of the packet */ 1151 outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER ); 1152 1153 /* First two words are status and packet_length */ 1154 status = inw( ioaddr + DATA_1 ); 1155 packet_length = inw( ioaddr + DATA_1 ); 1156 1157 packet_length &= 0x07ff; /* mask off top bits */ 1158 1159 PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length )); 1160 /* 1161 . the packet length contains 3 extra words : 1162 . status, length, and an extra word with an odd byte . 1163 */ 1164 packet_length -= 6; 1165 1166 if ( !(status & RS_ERRORS ) ){ 1167 /* do stuff to make a new packet */ 1168 struct sk_buff * skb; 1169 byte * data; 1170 1171 /* read one extra byte */ 1172 if ( status & RS_ODDFRAME ) 1173 packet_length++; 1174 1175 /* set multicast stats */ 1176 if ( status & RS_MULTICAST ) 1177 dev->stats.multicast++; 1178 1179 skb = dev_alloc_skb( packet_length + 5); 1180 1181 if ( skb == NULL ) { 1182 printk(KERN_NOTICE CARDNAME ": Low memory, packet dropped.\n"); 1183 dev->stats.rx_dropped++; 1184 goto done; 1185 } 1186 1187 /* 1188 ! This should work without alignment, but it could be 1189 ! in the worse case 1190 */ 1191 1192 skb_reserve( skb, 2 ); /* 16 bit alignment */ 1193 1194 data = skb_put( skb, packet_length); 1195 1196#ifdef USE_32_BIT 1197 /* QUESTION: Like in the TX routine, do I want 1198 to send the DWORDs or the bytes first, or some 1199 mixture. A mixture might improve already slow PIO 1200 performance */ 1201 PRINTK3((" Reading %d dwords (and %d bytes)\n", 1202 packet_length >> 2, packet_length & 3 )); 1203 insl(ioaddr + DATA_1 , data, packet_length >> 2 ); 1204 /* read the left over bytes */ 1205 insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC), 1206 packet_length & 0x3 ); 1207#else 1208 PRINTK3((" Reading %d words and %d byte(s)\n", 1209 (packet_length >> 1 ), packet_length & 1 )); 1210 insw(ioaddr + DATA_1 , data, packet_length >> 1); 1211 if ( packet_length & 1 ) { 1212 data += packet_length & ~1; 1213 *(data++) = inb( ioaddr + DATA_1 ); 1214 } 1215#endif 1216#if SMC_DEBUG > 2 1217 print_packet( data, packet_length ); 1218#endif 1219 1220 skb->protocol = eth_type_trans(skb, dev ); 1221 netif_rx(skb); 1222 dev->stats.rx_packets++; 1223 dev->stats.rx_bytes += packet_length; 1224 } else { 1225 /* error ... */ 1226 dev->stats.rx_errors++; 1227 1228 if ( status & RS_ALGNERR ) dev->stats.rx_frame_errors++; 1229 if ( status & (RS_TOOSHORT | RS_TOOLONG ) ) 1230 dev->stats.rx_length_errors++; 1231 if ( status & RS_BADCRC) dev->stats.rx_crc_errors++; 1232 } 1233 1234done: 1235 /* error or good, tell the card to get rid of this packet */ 1236 outw( MC_RELEASE, ioaddr + MMU_CMD ); 1237} 1238 1239 1240/************************************************************************* 1241 . smc_tx 1242 . 1243 . Purpose: Handle a transmit error message. This will only be called 1244 . when an error, because of the AUTO_RELEASE mode. 1245 . 1246 . Algorithm: 1247 . Save pointer and packet no 1248 . Get the packet no from the top of the queue 1249 . check if it's valid ( if not, is this an error??? ) 1250 . read the status word 1251 . record the error 1252 . ( resend? Not really, since we don't want old packets around ) 1253 . Restore saved values 1254 ************************************************************************/ 1255static void smc_tx( struct net_device * dev ) 1256{ 1257 int ioaddr = dev->base_addr; 1258 struct smc_local *lp = netdev_priv(dev); 1259 byte saved_packet; 1260 byte packet_no; 1261 word tx_status; 1262 1263 1264 /* assume bank 2 */ 1265 1266 saved_packet = inb( ioaddr + PNR_ARR ); 1267 packet_no = inw( ioaddr + FIFO_PORTS ); 1268 packet_no &= 0x7F; 1269 1270 /* select this as the packet to read from */ 1271 outb( packet_no, ioaddr + PNR_ARR ); 1272 1273 /* read the first word from this packet */ 1274 outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER ); 1275 1276 tx_status = inw( ioaddr + DATA_1 ); 1277 PRINTK3((CARDNAME": TX DONE STATUS: %4x\n", tx_status)); 1278 1279 dev->stats.tx_errors++; 1280 if ( tx_status & TS_LOSTCAR ) dev->stats.tx_carrier_errors++; 1281 if ( tx_status & TS_LATCOL ) { 1282 printk(KERN_DEBUG CARDNAME 1283 ": Late collision occurred on last xmit.\n"); 1284 dev->stats.tx_window_errors++; 1285 } 1286 1287 if ( tx_status & TS_SUCCESS ) { 1288 printk(CARDNAME": Successful packet caused interrupt\n"); 1289 } 1290 /* re-enable transmit */ 1291 SMC_SELECT_BANK( 0 ); 1292 outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR ); 1293 1294 /* kill the packet */ 1295 SMC_SELECT_BANK( 2 ); 1296 outw( MC_FREEPKT, ioaddr + MMU_CMD ); 1297 1298 /* one less packet waiting for me */ 1299 lp->packets_waiting--; 1300 1301 outb( saved_packet, ioaddr + PNR_ARR ); 1302} 1303 1304/*-------------------------------------------------------------------- 1305 . 1306 . This is the main routine of the driver, to handle the device when 1307 . it needs some attention. 1308 . 1309 . So: 1310 . first, save state of the chipset 1311 . branch off into routines to handle each case, and acknowledge 1312 . each to the interrupt register 1313 . and finally restore state. 1314 . 1315 ---------------------------------------------------------------------*/ 1316 1317static irqreturn_t smc_interrupt(int irq, void * dev_id) 1318{ 1319 struct net_device *dev = dev_id; 1320 int ioaddr = dev->base_addr; 1321 struct smc_local *lp = netdev_priv(dev); 1322 1323 byte status; 1324 word card_stats; 1325 byte mask; 1326 int timeout; 1327 /* state registers */ 1328 word saved_bank; 1329 word saved_pointer; 1330 int handled = 0; 1331 1332 1333 PRINTK3((CARDNAME": SMC interrupt started\n")); 1334 1335 saved_bank = inw( ioaddr + BANK_SELECT ); 1336 1337 SMC_SELECT_BANK(2); 1338 saved_pointer = inw( ioaddr + POINTER ); 1339 1340 mask = inb( ioaddr + INT_MASK ); 1341 /* clear all interrupts */ 1342 outb( 0, ioaddr + INT_MASK ); 1343 1344 1345 /* set a timeout value, so I don't stay here forever */ 1346 timeout = 4; 1347 1348 PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x\n", mask)); 1349 do { 1350 /* read the status flag, and mask it */ 1351 status = inb( ioaddr + INTERRUPT ) & mask; 1352 if (!status ) 1353 break; 1354 1355 handled = 1; 1356 1357 PRINTK3((KERN_WARNING CARDNAME 1358 ": Handling interrupt status %x\n", status)); 1359 1360 if (status & IM_RCV_INT) { 1361 /* Got a packet(s). */ 1362 PRINTK2((KERN_WARNING CARDNAME 1363 ": Receive Interrupt\n")); 1364 smc_rcv(dev); 1365 } else if (status & IM_TX_INT ) { 1366 PRINTK2((KERN_WARNING CARDNAME 1367 ": TX ERROR handled\n")); 1368 smc_tx(dev); 1369 outb(IM_TX_INT, ioaddr + INTERRUPT ); 1370 } else if (status & IM_TX_EMPTY_INT ) { 1371 /* update stats */ 1372 SMC_SELECT_BANK( 0 ); 1373 card_stats = inw( ioaddr + COUNTER ); 1374 /* single collisions */ 1375 dev->stats.collisions += card_stats & 0xF; 1376 card_stats >>= 4; 1377 /* multiple collisions */ 1378 dev->stats.collisions += card_stats & 0xF; 1379 1380 /* these are for when linux supports these statistics */ 1381 1382 SMC_SELECT_BANK( 2 ); 1383 PRINTK2((KERN_WARNING CARDNAME 1384 ": TX_BUFFER_EMPTY handled\n")); 1385 outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT ); 1386 mask &= ~IM_TX_EMPTY_INT; 1387 dev->stats.tx_packets += lp->packets_waiting; 1388 lp->packets_waiting = 0; 1389 1390 } else if (status & IM_ALLOC_INT ) { 1391 PRINTK2((KERN_DEBUG CARDNAME 1392 ": Allocation interrupt\n")); 1393 /* clear this interrupt so it doesn't happen again */ 1394 mask &= ~IM_ALLOC_INT; 1395 1396 smc_hardware_send_packet( dev ); 1397 1398 /* enable xmit interrupts based on this */ 1399 mask |= ( IM_TX_EMPTY_INT | IM_TX_INT ); 1400 1401 /* and let the card send more packets to me */ 1402 netif_wake_queue(dev); 1403 1404 PRINTK2((CARDNAME": Handoff done successfully.\n")); 1405 } else if (status & IM_RX_OVRN_INT ) { 1406 dev->stats.rx_errors++; 1407 dev->stats.rx_fifo_errors++; 1408 outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT ); 1409 } else if (status & IM_EPH_INT ) { 1410 PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT\n")); 1411 } else if (status & IM_ERCV_INT ) { 1412 PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT\n")); 1413 outb( IM_ERCV_INT, ioaddr + INTERRUPT ); 1414 } 1415 } while ( timeout -- ); 1416 1417 1418 /* restore state register */ 1419 SMC_SELECT_BANK( 2 ); 1420 outb( mask, ioaddr + INT_MASK ); 1421 1422 PRINTK3((KERN_WARNING CARDNAME ": MASK is now %x\n", mask)); 1423 outw( saved_pointer, ioaddr + POINTER ); 1424 1425 SMC_SELECT_BANK( saved_bank ); 1426 1427 PRINTK3((CARDNAME ": Interrupt done\n")); 1428 return IRQ_RETVAL(handled); 1429} 1430 1431 1432/*---------------------------------------------------- 1433 . smc_close 1434 . 1435 . this makes the board clean up everything that it can 1436 . and not talk to the outside world. Caused by 1437 . an 'ifconfig ethX down' 1438 . 1439 -----------------------------------------------------*/ 1440static int smc_close(struct net_device *dev) 1441{ 1442 netif_stop_queue(dev); 1443 /* clear everything */ 1444 smc_shutdown( dev->base_addr ); 1445 1446 /* Update the statistics here. */ 1447 return 0; 1448} 1449 1450/*----------------------------------------------------------- 1451 . smc_set_multicast_list 1452 . 1453 . This routine will, depending on the values passed to it, 1454 . either make it accept multicast packets, go into 1455 . promiscuous mode ( for TCPDUMP and cousins ) or accept 1456 . a select set of multicast packets 1457*/ 1458static void smc_set_multicast_list(struct net_device *dev) 1459{ 1460 short ioaddr = dev->base_addr; 1461 1462 SMC_SELECT_BANK(0); 1463 if ( dev->flags & IFF_PROMISC ) 1464 outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR ); 1465 1466/* BUG? I never disable promiscuous mode if multicasting was turned on. 1467 Now, I turn off promiscuous mode, but I don't do anything to multicasting 1468 when promiscuous mode is turned on. 1469*/ 1470 1471 /* Here, I am setting this to accept all multicast packets. 1472 I don't need to zero the multicast table, because the flag is 1473 checked before the table is 1474 */ 1475 else if (dev->flags & IFF_ALLMULTI) 1476 outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR ); 1477 1478 /* We just get all multicast packets even if we only want them 1479 . from one source. This will be changed at some future 1480 . point. */ 1481 else if (!netdev_mc_empty(dev)) { 1482 /* support hardware multicasting */ 1483 1484 /* be sure I get rid of flags I might have set */ 1485 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL), 1486 ioaddr + RCR ); 1487 /* NOTE: this has to set the bank, so make sure it is the 1488 last thing called. The bank is set to zero at the top */ 1489 smc_setmulticast(ioaddr, dev); 1490 } 1491 else { 1492 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL), 1493 ioaddr + RCR ); 1494 1495 /* 1496 since I'm disabling all multicast entirely, I need to 1497 clear the multicast list 1498 */ 1499 SMC_SELECT_BANK( 3 ); 1500 outw( 0, ioaddr + MULTICAST1 ); 1501 outw( 0, ioaddr + MULTICAST2 ); 1502 outw( 0, ioaddr + MULTICAST3 ); 1503 outw( 0, ioaddr + MULTICAST4 ); 1504 } 1505} 1506 1507#ifdef MODULE 1508 1509static struct net_device *devSMC9194; 1510MODULE_LICENSE("GPL"); 1511 1512module_param(io, int, 0); 1513module_param(irq, int, 0); 1514module_param(ifport, int, 0); 1515MODULE_PARM_DESC(io, "SMC 99194 I/O base address"); 1516MODULE_PARM_DESC(irq, "SMC 99194 IRQ number"); 1517MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)"); 1518 1519int __init init_module(void) 1520{ 1521 if (io == 0) 1522 printk(KERN_WARNING 1523 CARDNAME": You shouldn't use auto-probing with insmod!\n" ); 1524 1525 /* copy the parameters from insmod into the device structure */ 1526 devSMC9194 = smc_init(-1); 1527 if (IS_ERR(devSMC9194)) 1528 return PTR_ERR(devSMC9194); 1529 return 0; 1530} 1531 1532void __exit cleanup_module(void) 1533{ 1534 unregister_netdev(devSMC9194); 1535 free_irq(devSMC9194->irq, devSMC9194); 1536 release_region(devSMC9194->base_addr, SMC_IO_EXTENT); 1537 free_netdev(devSMC9194); 1538} 1539 1540#endif /* MODULE */ 1541