1536 lines · c
1/*------------------------------------------------------------------------2 . smc9194.c3 . This is a driver for SMC's 9000 series of Ethernet cards.4 .5 . Copyright (C) 1996 by Erik Stahlman6 . This software may be used and distributed according to the terms7 . 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 configuration12 . AUI/TP selection ( mine has 10Base2/10BaseT select )13 .14 . Arguments:15 . io = for the base address16 . irq = for the IRQ17 . 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 databook28 . 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 handled33 . 01/03/96 Erik Stahlman worked out some bugs, actually usable!!! :-)34 . 01/06/96 Erik Stahlman cleaned up some, better testing, etc35 . 01/29/96 Erik Stahlman fixed autoirq, added multicast36 . 02/01/96 Erik Stahlman 1. disabled all interrupts in smc_reset37 . 2. got rid of post-decrementing bug -- UGH.38 . 02/13/96 Erik Stahlman Tried to fix autoirq failure. Added more39 . descriptive error messages.40 . 02/15/96 Erik Stahlman Fixed typo that caused detection failure41 . 02/23/96 Erik Stahlman Modified it to fit into kernel tree42 . Added support to change hardware address43 . Cleared stats on opens44 . 02/26/96 Erik Stahlman Trial support for Kernel 1.2.1345 . Kludge for automatic IRQ detection46 . 03/04/96 Erik Stahlman Fixed kernel 1.3.70 +47 . Fixed bug reported by Gardner Buchanan in48 . smc_enable, with outw instead of outb49 . 03/06/96 Erik Stahlman Added hardware multicast from Peter Cammaert50 . 04/14/00 Heiko Pruessing (SMA Regelsysteme) Fixed bug in chip memory51 . allocation52 . 08/20/00 Arnaldo Melo fix kfree(skb) in smc_hardware_send_packet53 . 12/15/00 Christian Jullien fix "Warning: kfree_skb on hard IRQ"54 . 11/08/01 Matt Domsch Use common crc32 function55 ----------------------------------------------------------------------------*/56 57static const char version[] =58 "smc9194.c:v0.14 12/15/00 by Erik Stahlman (erik@vt.edu)";59 60#include <linux/module.h>61#include <linux/kernel.h>62#include <linux/types.h>63#include <linux/fcntl.h>64#include <linux/interrupt.h>65#include <linux/ioport.h>66#include <linux/in.h>67#include <linux/string.h>68#include <linux/init.h>69#include <linux/crc32.h>70#include <linux/errno.h>71#include <linux/netdevice.h>72#include <linux/etherdevice.h>73#include <linux/skbuff.h>74#include <linux/bitops.h>75 76#include <asm/io.h>77 78#include "smc9194.h"79 80#define DRV_NAME "smc9194"81 82/*------------------------------------------------------------------------83 .84 . Configuration options, for the experienced user to change.85 .86 -------------------------------------------------------------------------*/87 88/*89 . Do you want to use 32 bit xfers? This should work on all chips, as90 . the chipset is designed to accommodate them.91*/92#ifdef __sh__93#undef USE_32_BIT94#else95#define USE_32_BIT 196#endif97 98/*99 .the SMC9194 can be at any of the following port addresses. To change,100 .for a slightly different card, you can add it to the array. Keep in101 .mind that the array must end in zero.102*/103 104struct devlist {105 unsigned int port;106 unsigned int irq;107};108 109static struct devlist smc_devlist[] __initdata = {110 {.port = 0x200, .irq = 0},111 {.port = 0x220, .irq = 0},112 {.port = 0x240, .irq = 0},113 {.port = 0x260, .irq = 0},114 {.port = 0x280, .irq = 0},115 {.port = 0x2A0, .irq = 0},116 {.port = 0x2C0, .irq = 0},117 {.port = 0x2E0, .irq = 0},118 {.port = 0x300, .irq = 0},119 {.port = 0x320, .irq = 0},120 {.port = 0x340, .irq = 0},121 {.port = 0x360, .irq = 0},122 {.port = 0x380, .irq = 0},123 {.port = 0x3A0, .irq = 0},124 {.port = 0x3C0, .irq = 0},125 {.port = 0x3E0, .irq = 0},126 {.port = 0, .irq = 0},127};128/*129 . Wait time for memory to be free. This probably shouldn't be130 . tuned that much, as waiting for this means nothing else happens131 . in the system132*/133#define MEMORY_WAIT_TIME 16134 135/*136 . DEBUGGING LEVELS137 .138 . 0 for normal operation139 . 1 for slightly more details140 . >2 for various levels of increasingly useless information141 . 2 for interrupt tracking, status flags142 . 3 for packet dumps, etc.143*/144#define SMC_DEBUG 0145 146#if (SMC_DEBUG > 2 )147#define PRINTK3(x) printk x148#else149#define PRINTK3(x)150#endif151 152#if SMC_DEBUG > 1153#define PRINTK2(x) printk x154#else155#define PRINTK2(x)156#endif157 158#ifdef SMC_DEBUG159#define PRINTK(x) printk x160#else161#define PRINTK(x)162#endif163 164 165/*------------------------------------------------------------------------166 .167 . The internal workings of the driver. If you are changing anything168 . here with the SMC stuff, you should have the datasheet and known169 . what you are doing.170 .171 -------------------------------------------------------------------------*/172#define CARDNAME "SMC9194"173 174 175/* store this information for the driver.. */176struct smc_local {177 /*178 If I have to wait until memory is available to send179 a packet, I will store the skbuff here, until I get the180 desired memory. Then, I'll send it out and free it.181 */182 struct sk_buff * saved_skb;183 184 /*185 . This keeps track of how many packets that I have186 . sent out. When an TX_EMPTY interrupt comes, I know187 . that all of these have been sent.188 */189 int packets_waiting;190};191 192 193/*-----------------------------------------------------------------194 .195 . The driver can be entered at any of the following entry points.196 .197 .------------------------------------------------------------------ */198 199/*200 . This is called by register_netdev(). It is responsible for201 . checking the portlist for the SMC9000 series chipset. If it finds202 . one, then it will initialize the device, find the hardware information,203 . and sets up the appropriate device parameters.204 . NOTE: Interrupts are *OFF* when this procedure is called.205 .206 . NB:This shouldn't be static since it is referred to externally.207*/208struct net_device *smc_init(int unit);209 210/*211 . The kernel calls this function when someone wants to use the device,212 . typically 'ifconfig ethX up'.213*/214static int smc_open(struct net_device *dev);215 216/*217 . Our watchdog timed out. Called by the networking layer218*/219static void smc_timeout(struct net_device *dev, unsigned int txqueue);220 221/*222 . This is called by the kernel in response to 'ifconfig ethX down'. It223 . is responsible for cleaning up everything that the open routine224 . does, and maybe putting the card into a powerdown state.225*/226static int smc_close(struct net_device *dev);227 228/*229 . Finally, a call to set promiscuous mode ( for TCPDUMP and related230 . programs ) and multicast modes.231*/232static void smc_set_multicast_list(struct net_device *dev);233 234 235/*---------------------------------------------------------------236 .237 . Interrupt level calls..238 .239 ----------------------------------------------------------------*/240 241/*242 . Handles the actual interrupt243*/244static irqreturn_t smc_interrupt(int irq, void *);245/*246 . This is a separate procedure to handle the receipt of a packet, to247 . leave the interrupt code looking slightly cleaner248*/249static inline void smc_rcv( struct net_device *dev );250/*251 . This handles a TX interrupt, which is only called when an error252 . relating to a packet is sent.253*/254static inline void smc_tx( struct net_device * dev );255 256/*257 ------------------------------------------------------------258 .259 . Internal routines260 .261 ------------------------------------------------------------262*/263 264/*265 . Test if a given location contains a chip, trying to cause as266 . little damage as possible if it's not a SMC chip.267*/268static int smc_probe(struct net_device *dev, int ioaddr);269 270/*271 . A rather simple routine to print out a packet for debugging purposes.272*/273#if SMC_DEBUG > 2274static void print_packet( byte *, int );275#endif276 277#define tx_done(dev) 1278 279/* this is called to actually send the packet to the chip */280static void smc_hardware_send_packet( struct net_device * dev );281 282/* Since I am not sure if I will have enough room in the chip's ram283 . to store the packet, I call this routine, which either sends it284 . now, or generates an interrupt when the card is ready for the285 . packet */286static netdev_tx_t smc_wait_to_send_packet( struct sk_buff * skb,287 struct net_device *dev );288 289/* this does a soft reset on the device */290static void smc_reset( int ioaddr );291 292/* Enable Interrupts, Receive, and Transmit */293static void smc_enable( int ioaddr );294 295/* this puts the device in an inactive state */296static void smc_shutdown( int ioaddr );297 298/* This routine will find the IRQ of the driver if one is not299 . specified in the input to the device. */300static int smc_findirq( int ioaddr );301 302/*303 . Function: smc_reset( int ioaddr )304 . Purpose:305 . This sets the SMC91xx chip to its normal state, hopefully from whatever306 . mess that any other DOS driver has put it in.307 .308 . Maybe I should reset more registers to defaults in here? SOFTRESET should309 . do that for me.310 .311 . Method:312 . 1. send a SOFT RESET313 . 2. wait for it to finish314 . 3. enable autorelease mode315 . 4. reset the memory management unit316 . 5. clear all interrupts317 .318*/319static void smc_reset( int ioaddr )320{321 /* This resets the registers mostly to defaults, but doesn't322 affect EEPROM. That seems unnecessary */323 SMC_SELECT_BANK( 0 );324 outw( RCR_SOFTRESET, ioaddr + RCR );325 326 /* this should pause enough for the chip to be happy */327 SMC_DELAY( );328 329 /* Set the transmit and receive configuration registers to330 default values */331 outw( RCR_CLEAR, ioaddr + RCR );332 outw( TCR_CLEAR, ioaddr + TCR );333 334 /* set the control register to automatically335 release successfully transmitted packets, to make the best336 use out of our limited memory */337 SMC_SELECT_BANK( 1 );338 outw( inw( ioaddr + CONTROL ) | CTL_AUTO_RELEASE , ioaddr + CONTROL );339 340 /* Reset the MMU */341 SMC_SELECT_BANK( 2 );342 outw( MC_RESET, ioaddr + MMU_CMD );343 344 /* Note: It doesn't seem that waiting for the MMU busy is needed here,345 but this is a place where future chipsets _COULD_ break. Be wary346 of issuing another MMU command right after this */347 348 outb( 0, ioaddr + INT_MASK );349}350 351/*352 . Function: smc_enable353 . Purpose: let the chip talk to the outside work354 . Method:355 . 1. Enable the transmitter356 . 2. Enable the receiver357 . 3. Enable interrupts358*/359static void smc_enable( int ioaddr )360{361 SMC_SELECT_BANK( 0 );362 /* see the header file for options in TCR/RCR NORMAL*/363 outw( TCR_NORMAL, ioaddr + TCR );364 outw( RCR_NORMAL, ioaddr + RCR );365 366 /* now, enable interrupts */367 SMC_SELECT_BANK( 2 );368 outb( SMC_INTERRUPT_MASK, ioaddr + INT_MASK );369}370 371/*372 . Function: smc_shutdown373 . Purpose: closes down the SMC91xxx chip.374 . Method:375 . 1. zero the interrupt mask376 . 2. clear the enable receive flag377 . 3. clear the enable xmit flags378 .379 . TODO:380 . (1) maybe utilize power down mode.381 . Why not yet? Because while the chip will go into power down mode,382 . the manual says that it will wake up in response to any I/O requests383 . in the register space. Empirical results do not show this working.384*/385static void smc_shutdown( int ioaddr )386{387 /* no more interrupts for me */388 SMC_SELECT_BANK( 2 );389 outb( 0, ioaddr + INT_MASK );390 391 /* and tell the card to stay away from that nasty outside world */392 SMC_SELECT_BANK( 0 );393 outb( RCR_CLEAR, ioaddr + RCR );394 outb( TCR_CLEAR, ioaddr + TCR );395#if 0396 /* finally, shut the chip down */397 SMC_SELECT_BANK( 1 );398 outw( inw( ioaddr + CONTROL ), CTL_POWERDOWN, ioaddr + CONTROL );399#endif400}401 402 403/*404 . Function: smc_setmulticast( int ioaddr, struct net_device *dev )405 . Purpose:406 . This sets the internal hardware table to filter out unwanted multicast407 . packets before they take up memory.408 .409 . The SMC chip uses a hash table where the high 6 bits of the CRC of410 . address are the offset into the table. If that bit is 1, then the411 . multicast packet is accepted. Otherwise, it's dropped silently.412 .413 . To use the 6 bits as an offset into the table, the high 3 bits are the414 . number of the 8 bit register, while the low 3 bits are the bit within415 . that register.416 .417 . This routine is based very heavily on the one provided by Peter Cammaert.418*/419 420 421static void smc_setmulticast(int ioaddr, struct net_device *dev)422{423 int i;424 unsigned char multicast_table[ 8 ];425 struct netdev_hw_addr *ha;426 /* table for flipping the order of 3 bits */427 unsigned char invert3[] = { 0, 4, 2, 6, 1, 5, 3, 7 };428 429 /* start with a table of all zeros: reject all */430 memset( multicast_table, 0, sizeof( multicast_table ) );431 432 netdev_for_each_mc_addr(ha, dev) {433 int position;434 435 /* only use the low order bits */436 position = ether_crc_le(6, ha->addr) & 0x3f;437 438 /* do some messy swapping to put the bit in the right spot */439 multicast_table[invert3[position&7]] |=440 (1<<invert3[(position>>3)&7]);441 442 }443 /* now, the table can be loaded into the chipset */444 SMC_SELECT_BANK( 3 );445 446 for ( i = 0; i < 8 ; i++ ) {447 outb( multicast_table[i], ioaddr + MULTICAST1 + i );448 }449}450 451/*452 . Function: smc_wait_to_send_packet( struct sk_buff * skb, struct net_device * )453 . Purpose:454 . Attempt to allocate memory for a packet, if chip-memory is not455 . available, then tell the card to generate an interrupt when it456 . is available.457 .458 . Algorithm:459 .460 . o if the saved_skb is not currently null, then drop this packet461 . on the floor. This should never happen, because of TBUSY.462 . o if the saved_skb is null, then replace it with the current packet,463 . o See if I can sending it now.464 . o (NO): Enable interrupts and let the interrupt handler deal with it.465 . o (YES):Send it now.466*/467static netdev_tx_t smc_wait_to_send_packet(struct sk_buff *skb,468 struct net_device *dev)469{470 struct smc_local *lp = netdev_priv(dev);471 unsigned int ioaddr = dev->base_addr;472 word length;473 unsigned short numPages;474 word time_out;475 476 netif_stop_queue(dev);477 /* Well, I want to send the packet.. but I don't know478 if I can send it right now... */479 480 if ( lp->saved_skb) {481 /* THIS SHOULD NEVER HAPPEN. */482 dev->stats.tx_aborted_errors++;483 printk(CARDNAME": Bad Craziness - sent packet while busy.\n" );484 return NETDEV_TX_BUSY;485 }486 lp->saved_skb = skb;487 488 length = skb->len;489 490 if (length < ETH_ZLEN) {491 if (skb_padto(skb, ETH_ZLEN)) {492 netif_wake_queue(dev);493 return NETDEV_TX_OK;494 }495 length = ETH_ZLEN;496 }497 498 /*499 ** The MMU wants the number of pages to be the number of 256 bytes500 ** 'pages', minus 1 ( since a packet can't ever have 0 pages :) )501 **502 ** Pkt size for allocating is data length +6 (for additional status words,503 ** length and ctl!) If odd size last byte is included in this header.504 */505 numPages = ((length & 0xfffe) + 6) / 256;506 507 if (numPages > 7 ) {508 printk(CARDNAME": Far too big packet error.\n");509 /* freeing the packet is a good thing here... but should510 . any packets of this size get down here? */511 dev_kfree_skb (skb);512 lp->saved_skb = NULL;513 /* this IS an error, but, i don't want the skb saved */514 netif_wake_queue(dev);515 return NETDEV_TX_OK;516 }517 /* either way, a packet is waiting now */518 lp->packets_waiting++;519 520 /* now, try to allocate the memory */521 SMC_SELECT_BANK( 2 );522 outw( MC_ALLOC | numPages, ioaddr + MMU_CMD );523 /*524 . Performance Hack525 .526 . wait a short amount of time.. if I can send a packet now, I send527 . it now. Otherwise, I enable an interrupt and wait for one to be528 . available.529 .530 . I could have handled this a slightly different way, by checking to531 . see if any memory was available in the FREE MEMORY register. However,532 . either way, I need to generate an allocation, and the allocation works533 . no matter what, so I saw no point in checking free memory.534 */535 time_out = MEMORY_WAIT_TIME;536 do {537 word status;538 539 status = inb( ioaddr + INTERRUPT );540 if ( status & IM_ALLOC_INT ) {541 /* acknowledge the interrupt */542 outb( IM_ALLOC_INT, ioaddr + INTERRUPT );543 break;544 }545 } while ( -- time_out );546 547 if ( !time_out ) {548 /* oh well, wait until the chip finds memory later */549 SMC_ENABLE_INT( IM_ALLOC_INT );550 PRINTK2((CARDNAME": memory allocation deferred.\n"));551 /* it's deferred, but I'll handle it later */552 return NETDEV_TX_OK;553 }554 /* or YES! I can send the packet now.. */555 smc_hardware_send_packet(dev);556 netif_wake_queue(dev);557 return NETDEV_TX_OK;558}559 560/*561 . Function: smc_hardware_send_packet(struct net_device * )562 . Purpose:563 . This sends the actual packet to the SMC9xxx chip.564 .565 . Algorithm:566 . First, see if a saved_skb is available.567 . ( this should NOT be called if there is no 'saved_skb'568 . Now, find the packet number that the chip allocated569 . Point the data pointers at it in memory570 . Set the length word in the chip's memory571 . Dump the packet to chip memory572 . Check if a last byte is needed ( odd length packet )573 . if so, set the control flag right574 . Tell the card to send it575 . Enable the transmit interrupt, so I know if it failed576 . Free the kernel data if I actually sent it.577*/578static void smc_hardware_send_packet( struct net_device * dev )579{580 struct smc_local *lp = netdev_priv(dev);581 byte packet_no;582 struct sk_buff * skb = lp->saved_skb;583 word length;584 unsigned int ioaddr;585 byte * buf;586 587 ioaddr = dev->base_addr;588 589 if ( !skb ) {590 PRINTK((CARDNAME": In XMIT with no packet to send\n"));591 return;592 }593 length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;594 buf = skb->data;595 596 /* If I get here, I _know_ there is a packet slot waiting for me */597 packet_no = inb( ioaddr + PNR_ARR + 1 );598 if ( packet_no & 0x80 ) {599 /* or isn't there? BAD CHIP! */600 netdev_dbg(dev, CARDNAME": Memory allocation failed.\n");601 dev_kfree_skb_any(skb);602 lp->saved_skb = NULL;603 netif_wake_queue(dev);604 return;605 }606 607 /* we have a packet address, so tell the card to use it */608 outb( packet_no, ioaddr + PNR_ARR );609 610 /* point to the beginning of the packet */611 outw( PTR_AUTOINC , ioaddr + POINTER );612 613 PRINTK3((CARDNAME": Trying to xmit packet of length %x\n", length));614#if SMC_DEBUG > 2615 print_packet( buf, length );616#endif617 618 /* send the packet length ( +6 for status, length and ctl byte )619 and the status word ( set to zeros ) */620#ifdef USE_32_BIT621 outl( (length +6 ) << 16 , ioaddr + DATA_1 );622#else623 outw( 0, ioaddr + DATA_1 );624 /* send the packet length ( +6 for status words, length, and ctl*/625 outb( (length+6) & 0xFF,ioaddr + DATA_1 );626 outb( (length+6) >> 8 , ioaddr + DATA_1 );627#endif628 629 /* send the actual data630 . I _think_ it's faster to send the longs first, and then631 . mop up by sending the last word. It depends heavily632 . on alignment, at least on the 486. Maybe it would be633 . a good idea to check which is optimal? But that could take634 . almost as much time as is saved?635 */636#ifdef USE_32_BIT637 if ( length & 0x2 ) {638 outsl(ioaddr + DATA_1, buf, length >> 2 );639 outw( *((word *)(buf + (length & 0xFFFFFFFC))),ioaddr +DATA_1);640 }641 else642 outsl(ioaddr + DATA_1, buf, length >> 2 );643#else644 outsw(ioaddr + DATA_1 , buf, (length ) >> 1);645#endif646 /* Send the last byte, if there is one. */647 648 if ( (length & 1) == 0 ) {649 outw( 0, ioaddr + DATA_1 );650 } else {651 outb( buf[length -1 ], ioaddr + DATA_1 );652 outb( 0x20, ioaddr + DATA_1);653 }654 655 /* enable the interrupts */656 SMC_ENABLE_INT( (IM_TX_INT | IM_TX_EMPTY_INT) );657 658 /* and let the chipset deal with it */659 outw( MC_ENQUEUE , ioaddr + MMU_CMD );660 661 PRINTK2((CARDNAME": Sent packet of length %d\n", length));662 663 lp->saved_skb = NULL;664 dev_kfree_skb_any (skb);665 666 netif_trans_update(dev);667 668 /* we can send another packet */669 netif_wake_queue(dev);670}671 672/*-------------------------------------------------------------------------673 |674 | smc_init(int unit)675 | Input parameters:676 | dev->base_addr == 0, try to find all possible locations677 | dev->base_addr == 1, return failure code678 | dev->base_addr == 2, always allocate space, and return success679 | dev->base_addr == <anything else> this is the address to check680 |681 | Output:682 | pointer to net_device or ERR_PTR(error)683 |684 ---------------------------------------------------------------------------685*/686static int io;687static int irq;688static int ifport;689 690struct net_device * __init smc_init(int unit)691{692 struct net_device *dev = alloc_etherdev(sizeof(struct smc_local));693 struct devlist *smcdev = smc_devlist;694 int err = 0;695 696 if (!dev)697 return ERR_PTR(-ENODEV);698 699 if (unit >= 0) {700 sprintf(dev->name, "eth%d", unit);701 netdev_boot_setup_check(dev);702 io = dev->base_addr;703 irq = dev->irq;704 }705 706 if (io > 0x1ff) { /* Check a single specified location. */707 err = smc_probe(dev, io);708 } else if (io != 0) { /* Don't probe at all. */709 err = -ENXIO;710 } else {711 for (;smcdev->port; smcdev++) {712 if (smc_probe(dev, smcdev->port) == 0)713 break;714 }715 if (!smcdev->port)716 err = -ENODEV;717 }718 if (err)719 goto out;720 err = register_netdev(dev);721 if (err)722 goto out1;723 return dev;724out1:725 free_irq(dev->irq, dev);726 release_region(dev->base_addr, SMC_IO_EXTENT);727out:728 free_netdev(dev);729 return ERR_PTR(err);730}731 732/*----------------------------------------------------------------------733 . smc_findirq734 .735 . This routine has a simple purpose -- make the SMC chip generate an736 . interrupt, so an auto-detect routine can detect it, and find the IRQ,737 ------------------------------------------------------------------------738*/739static int __init smc_findirq(int ioaddr)740{741#ifndef NO_AUTOPROBE742 int timeout = 20;743 unsigned long cookie;744 745 746 cookie = probe_irq_on();747 748 /*749 * What I try to do here is trigger an ALLOC_INT. This is done750 * by allocating a small chunk of memory, which will give an interrupt751 * when done.752 */753 754 755 SMC_SELECT_BANK(2);756 /* enable ALLOCation interrupts ONLY */757 outb( IM_ALLOC_INT, ioaddr + INT_MASK );758 759 /*760 . Allocate 512 bytes of memory. Note that the chip was just761 . reset so all the memory is available762 */763 outw( MC_ALLOC | 1, ioaddr + MMU_CMD );764 765 /*766 . Wait until positive that the interrupt has been generated767 */768 while ( timeout ) {769 byte int_status;770 771 int_status = inb( ioaddr + INTERRUPT );772 773 if ( int_status & IM_ALLOC_INT )774 break; /* got the interrupt */775 timeout--;776 }777 /* there is really nothing that I can do here if timeout fails,778 as probe_irq_off will return a 0 anyway, which is what I779 want in this case. Plus, the clean up is needed in both780 cases. */781 782 /* DELAY HERE!783 On a fast machine, the status might change before the interrupt784 is given to the processor. This means that the interrupt was785 never detected, and probe_irq_off fails to report anything.786 This should fix probe_irq_* problems.787 */788 SMC_DELAY();789 SMC_DELAY();790 791 /* and disable all interrupts again */792 outb( 0, ioaddr + INT_MASK );793 794 /* and return what I found */795 return probe_irq_off(cookie);796#else /* NO_AUTOPROBE */797 struct devlist *smcdev;798 for (smcdev = smc_devlist; smcdev->port; smcdev++) {799 if (smcdev->port == ioaddr)800 return smcdev->irq;801 }802 return 0;803#endif804}805 806static const struct net_device_ops smc_netdev_ops = {807 .ndo_open = smc_open,808 .ndo_stop = smc_close,809 .ndo_start_xmit = smc_wait_to_send_packet,810 .ndo_tx_timeout = smc_timeout,811 .ndo_set_rx_mode = smc_set_multicast_list,812 .ndo_set_mac_address = eth_mac_addr,813 .ndo_validate_addr = eth_validate_addr,814};815 816/*----------------------------------------------------------------------817 . Function: smc_probe( int ioaddr )818 .819 . Purpose:820 . Tests to see if a given ioaddr points to an SMC9xxx chip.821 . Returns a 0 on success822 .823 . Algorithm:824 . (1) see if the high byte of BANK_SELECT is 0x33825 . (2) compare the ioaddr with the base register's address826 . (3) see if I recognize the chip ID in the appropriate register827 .828 .---------------------------------------------------------------------829 */830 831/*---------------------------------------------------------------832 . Here I do typical initialization tasks.833 .834 . o Initialize the structure if needed835 . o print out my vanity message if not done so already836 . o print out what type of hardware is detected837 . o print out the ethernet address838 . o find the IRQ839 . o set up my private data840 . o configure the dev structure with my subroutines841 . o actually GRAB the irq.842 . o GRAB the region843 .-----------------------------------------------------------------844*/845static int __init smc_probe(struct net_device *dev, int ioaddr)846{847 int i, memory, retval;848 unsigned int bank;849 850 const char *version_string;851 const char *if_string;852 853 /* registers */854 word revision_register;855 word base_address_register;856 word configuration_register;857 word memory_info_register;858 word memory_cfg_register;859 u8 addr[ETH_ALEN];860 861 /* Grab the region so that no one else tries to probe our ioports. */862 if (!request_region(ioaddr, SMC_IO_EXTENT, DRV_NAME))863 return -EBUSY;864 865 dev->irq = irq;866 dev->if_port = ifport;867 868 /* First, see if the high byte is 0x33 */869 bank = inw( ioaddr + BANK_SELECT );870 if ( (bank & 0xFF00) != 0x3300 ) {871 retval = -ENODEV;872 goto err_out;873 }874 /* The above MIGHT indicate a device, but I need to write to further875 test this. */876 outw( 0x0, ioaddr + BANK_SELECT );877 bank = inw( ioaddr + BANK_SELECT );878 if ( (bank & 0xFF00 ) != 0x3300 ) {879 retval = -ENODEV;880 goto err_out;881 }882 /* well, we've already written once, so hopefully another time won't883 hurt. This time, I need to switch the bank register to bank 1,884 so I can access the base address register */885 SMC_SELECT_BANK(1);886 base_address_register = inw( ioaddr + BASE );887 if ( ioaddr != ( base_address_register >> 3 & 0x3E0 ) ) {888 printk(CARDNAME ": IOADDR %x doesn't match configuration (%x). "889 "Probably not a SMC chip\n",890 ioaddr, base_address_register >> 3 & 0x3E0 );891 /* well, the base address register didn't match. Must not have892 been a SMC chip after all. */893 retval = -ENODEV;894 goto err_out;895 }896 897 /* check if the revision register is something that I recognize.898 These might need to be added to later, as future revisions899 could be added. */900 SMC_SELECT_BANK(3);901 revision_register = inw( ioaddr + REVISION );902 if ( !chip_ids[ ( revision_register >> 4 ) & 0xF ] ) {903 /* I don't recognize this chip, so... */904 printk(CARDNAME ": IO %x: Unrecognized revision register:"905 " %x, Contact author.\n", ioaddr, revision_register);906 907 retval = -ENODEV;908 goto err_out;909 }910 911 /* at this point I'll assume that the chip is an SMC9xxx.912 It might be prudent to check a listing of MAC addresses913 against the hardware address, or do some other tests. */914 915 pr_info_once("%s\n", version);916 917 /* fill in some of the fields */918 dev->base_addr = ioaddr;919 920 /*921 . Get the MAC address ( bank 1, regs 4 - 9 )922 */923 SMC_SELECT_BANK( 1 );924 for ( i = 0; i < 6; i += 2 ) {925 word address;926 927 address = inw( ioaddr + ADDR0 + i );928 addr[i + 1] = address >> 8;929 addr[i] = address & 0xFF;930 }931 eth_hw_addr_set(dev, addr);932 933 /* get the memory information */934 935 SMC_SELECT_BANK( 0 );936 memory_info_register = inw( ioaddr + MIR );937 memory_cfg_register = inw( ioaddr + MCR );938 memory = ( memory_cfg_register >> 9 ) & 0x7; /* multiplier */939 memory *= 256 * ( memory_info_register & 0xFF );940 941 /*942 Now, I want to find out more about the chip. This is sort of943 redundant, but it's cleaner to have it in both, rather than having944 one VERY long probe procedure.945 */946 SMC_SELECT_BANK(3);947 revision_register = inw( ioaddr + REVISION );948 version_string = chip_ids[ ( revision_register >> 4 ) & 0xF ];949 if ( !version_string ) {950 /* I shouldn't get here because this call was done before.... */951 retval = -ENODEV;952 goto err_out;953 }954 955 /* is it using AUI or 10BaseT ? */956 if ( dev->if_port == 0 ) {957 SMC_SELECT_BANK(1);958 configuration_register = inw( ioaddr + CONFIG );959 if ( configuration_register & CFG_AUI_SELECT )960 dev->if_port = 2;961 else962 dev->if_port = 1;963 }964 if_string = interfaces[ dev->if_port - 1 ];965 966 /* now, reset the chip, and put it into a known state */967 smc_reset( ioaddr );968 969 /*970 . If dev->irq is 0, then the device has to be banged on to see971 . what the IRQ is.972 .973 . This banging doesn't always detect the IRQ, for unknown reasons.974 . a workaround is to reset the chip and try again.975 .976 . Interestingly, the DOS packet driver *SETS* the IRQ on the card to977 . be what is requested on the command line. I don't do that, mostly978 . because the card that I have uses a non-standard method of accessing979 . the IRQs, and because this _should_ work in most configurations.980 .981 . Specifying an IRQ is done with the assumption that the user knows982 . what (s)he is doing. No checking is done!!!!983 .984 */985 if ( dev->irq < 2 ) {986 int trials;987 988 trials = 3;989 while ( trials-- ) {990 dev->irq = smc_findirq( ioaddr );991 if ( dev->irq )992 break;993 /* kick the card and try again */994 smc_reset( ioaddr );995 }996 }997 if (dev->irq == 0 ) {998 printk(CARDNAME": Couldn't autodetect your IRQ. Use irq=xx.\n");999 retval = -ENODEV;1000 goto err_out;1001 }1002 1003 /* now, print out the card info, in a short format.. */1004 1005 netdev_info(dev, "%s(r:%d) at %#3x IRQ:%d INTF:%s MEM:%db ",1006 version_string, revision_register & 0xF, ioaddr, dev->irq,1007 if_string, memory);1008 /*1009 . Print the Ethernet address1010 */1011 netdev_info(dev, "ADDR: %pM\n", dev->dev_addr);1012 1013 /* Grab the IRQ */1014 retval = request_irq(dev->irq, smc_interrupt, 0, DRV_NAME, dev);1015 if (retval) {1016 netdev_warn(dev, "%s: unable to get IRQ %d (irqval=%d).\n",1017 DRV_NAME, dev->irq, retval);1018 goto err_out;1019 }1020 1021 dev->netdev_ops = &smc_netdev_ops;1022 dev->watchdog_timeo = HZ/20;1023 1024 return 0;1025 1026err_out:1027 release_region(ioaddr, SMC_IO_EXTENT);1028 return retval;1029}1030 1031#if SMC_DEBUG > 21032static void print_packet( byte * buf, int length )1033{1034#if 01035 print_hex_dump_debug(DRV_NAME, DUMP_PREFIX_OFFSET, 16, 1,1036 buf, length, true);1037#endif1038}1039#endif1040 1041 1042/*1043 * Open and Initialize the board1044 *1045 * Set up everything, reset the card, etc ..1046 *1047 */1048static int smc_open(struct net_device *dev)1049{1050 int ioaddr = dev->base_addr;1051 1052 int i; /* used to set hw ethernet address */1053 1054 /* clear out all the junk that was put here before... */1055 memset(netdev_priv(dev), 0, sizeof(struct smc_local));1056 1057 /* reset the hardware */1058 1059 smc_reset( ioaddr );1060 smc_enable( ioaddr );1061 1062 /* Select which interface to use */1063 1064 SMC_SELECT_BANK( 1 );1065 if ( dev->if_port == 1 ) {1066 outw( inw( ioaddr + CONFIG ) & ~CFG_AUI_SELECT,1067 ioaddr + CONFIG );1068 }1069 else if ( dev->if_port == 2 ) {1070 outw( inw( ioaddr + CONFIG ) | CFG_AUI_SELECT,1071 ioaddr + CONFIG );1072 }1073 1074 /*1075 According to Becker, I have to set the hardware address1076 at this point, because the (l)user can set it with an1077 ioctl. Easily done...1078 */1079 SMC_SELECT_BANK( 1 );1080 for ( i = 0; i < 6; i += 2 ) {1081 word address;1082 1083 address = dev->dev_addr[ i + 1 ] << 8 ;1084 address |= dev->dev_addr[ i ];1085 outw( address, ioaddr + ADDR0 + i );1086 }1087 1088 netif_start_queue(dev);1089 return 0;1090}1091 1092/*--------------------------------------------------------1093 . Called by the kernel to send a packet out into the void1094 . of the net. This routine is largely based on1095 . skeleton.c, from Becker.1096 .--------------------------------------------------------1097*/1098 1099static void smc_timeout(struct net_device *dev, unsigned int txqueue)1100{1101 /* If we get here, some higher level has decided we are broken.1102 There should really be a "kick me" function call instead. */1103 netdev_warn(dev, CARDNAME": transmit timed out, %s?\n",1104 tx_done(dev) ? "IRQ conflict" : "network cable problem");1105 /* "kick" the adaptor */1106 smc_reset( dev->base_addr );1107 smc_enable( dev->base_addr );1108 netif_trans_update(dev); /* prevent tx timeout */1109 /* clear anything saved */1110 ((struct smc_local *)netdev_priv(dev))->saved_skb = NULL;1111 netif_wake_queue(dev);1112}1113 1114/*-------------------------------------------------------------1115 .1116 . smc_rcv - receive a packet from the card1117 .1118 . There is ( at least ) a packet waiting to be read from1119 . chip-memory.1120 .1121 . o Read the status1122 . o If an error, record it1123 . o otherwise, read in the packet1124 --------------------------------------------------------------1125*/1126static void smc_rcv(struct net_device *dev)1127{1128 int ioaddr = dev->base_addr;1129 int packet_number;1130 word status;1131 word packet_length;1132 1133 /* assume bank 2 */1134 1135 packet_number = inw( ioaddr + FIFO_PORTS );1136 1137 if ( packet_number & FP_RXEMPTY ) {1138 /* we got called , but nothing was on the FIFO */1139 PRINTK((CARDNAME ": WARNING: smc_rcv with nothing on FIFO.\n"));1140 /* don't need to restore anything */1141 return;1142 }1143 1144 /* start reading from the start of the packet */1145 outw( PTR_READ | PTR_RCV | PTR_AUTOINC, ioaddr + POINTER );1146 1147 /* First two words are status and packet_length */1148 status = inw( ioaddr + DATA_1 );1149 packet_length = inw( ioaddr + DATA_1 );1150 1151 packet_length &= 0x07ff; /* mask off top bits */1152 1153 PRINTK2(("RCV: STATUS %4x LENGTH %4x\n", status, packet_length ));1154 /*1155 . the packet length contains 3 extra words :1156 . status, length, and an extra word with an odd byte .1157 */1158 packet_length -= 6;1159 1160 if ( !(status & RS_ERRORS ) ){1161 /* do stuff to make a new packet */1162 struct sk_buff * skb;1163 byte * data;1164 1165 /* read one extra byte */1166 if ( status & RS_ODDFRAME )1167 packet_length++;1168 1169 /* set multicast stats */1170 if ( status & RS_MULTICAST )1171 dev->stats.multicast++;1172 1173 skb = netdev_alloc_skb(dev, packet_length + 5);1174 if ( skb == NULL ) {1175 dev->stats.rx_dropped++;1176 goto done;1177 }1178 1179 /*1180 ! This should work without alignment, but it could be1181 ! in the worse case1182 */1183 1184 skb_reserve( skb, 2 ); /* 16 bit alignment */1185 1186 data = skb_put( skb, packet_length);1187 1188#ifdef USE_32_BIT1189 /* QUESTION: Like in the TX routine, do I want1190 to send the DWORDs or the bytes first, or some1191 mixture. A mixture might improve already slow PIO1192 performance */1193 PRINTK3((" Reading %d dwords (and %d bytes)\n",1194 packet_length >> 2, packet_length & 3 ));1195 insl(ioaddr + DATA_1 , data, packet_length >> 2 );1196 /* read the left over bytes */1197 insb( ioaddr + DATA_1, data + (packet_length & 0xFFFFFC),1198 packet_length & 0x3 );1199#else1200 PRINTK3((" Reading %d words and %d byte(s)\n",1201 (packet_length >> 1 ), packet_length & 1 ));1202 insw(ioaddr + DATA_1 , data, packet_length >> 1);1203 if ( packet_length & 1 ) {1204 data += packet_length & ~1;1205 *(data++) = inb( ioaddr + DATA_1 );1206 }1207#endif1208#if SMC_DEBUG > 21209 print_packet( data, packet_length );1210#endif1211 1212 skb->protocol = eth_type_trans(skb, dev );1213 netif_rx(skb);1214 dev->stats.rx_packets++;1215 dev->stats.rx_bytes += packet_length;1216 } else {1217 /* error ... */1218 dev->stats.rx_errors++;1219 1220 if ( status & RS_ALGNERR ) dev->stats.rx_frame_errors++;1221 if ( status & (RS_TOOSHORT | RS_TOOLONG ) )1222 dev->stats.rx_length_errors++;1223 if ( status & RS_BADCRC) dev->stats.rx_crc_errors++;1224 }1225 1226done:1227 /* error or good, tell the card to get rid of this packet */1228 outw( MC_RELEASE, ioaddr + MMU_CMD );1229}1230 1231 1232/*************************************************************************1233 . smc_tx1234 .1235 . Purpose: Handle a transmit error message. This will only be called1236 . when an error, because of the AUTO_RELEASE mode.1237 .1238 . Algorithm:1239 . Save pointer and packet no1240 . Get the packet no from the top of the queue1241 . check if it's valid ( if not, is this an error??? )1242 . read the status word1243 . record the error1244 . ( resend? Not really, since we don't want old packets around )1245 . Restore saved values1246 ************************************************************************/1247static void smc_tx( struct net_device * dev )1248{1249 int ioaddr = dev->base_addr;1250 struct smc_local *lp = netdev_priv(dev);1251 byte saved_packet;1252 byte packet_no;1253 word tx_status;1254 1255 1256 /* assume bank 2 */1257 1258 saved_packet = inb( ioaddr + PNR_ARR );1259 packet_no = inw( ioaddr + FIFO_PORTS );1260 packet_no &= 0x7F;1261 1262 /* select this as the packet to read from */1263 outb( packet_no, ioaddr + PNR_ARR );1264 1265 /* read the first word from this packet */1266 outw( PTR_AUTOINC | PTR_READ, ioaddr + POINTER );1267 1268 tx_status = inw( ioaddr + DATA_1 );1269 PRINTK3((CARDNAME": TX DONE STATUS: %4x\n", tx_status));1270 1271 dev->stats.tx_errors++;1272 if ( tx_status & TS_LOSTCAR ) dev->stats.tx_carrier_errors++;1273 if ( tx_status & TS_LATCOL ) {1274 netdev_dbg(dev, CARDNAME": Late collision occurred on last xmit.\n");1275 dev->stats.tx_window_errors++;1276 }1277#if 01278 if ( tx_status & TS_16COL ) { ... }1279#endif1280 1281 if ( tx_status & TS_SUCCESS ) {1282 netdev_info(dev, CARDNAME": Successful packet caused interrupt\n");1283 }1284 /* re-enable transmit */1285 SMC_SELECT_BANK( 0 );1286 outw( inw( ioaddr + TCR ) | TCR_ENABLE, ioaddr + TCR );1287 1288 /* kill the packet */1289 SMC_SELECT_BANK( 2 );1290 outw( MC_FREEPKT, ioaddr + MMU_CMD );1291 1292 /* one less packet waiting for me */1293 lp->packets_waiting--;1294 1295 outb( saved_packet, ioaddr + PNR_ARR );1296}1297 1298/*--------------------------------------------------------------------1299 .1300 . This is the main routine of the driver, to handle the device when1301 . it needs some attention.1302 .1303 . So:1304 . first, save state of the chipset1305 . branch off into routines to handle each case, and acknowledge1306 . each to the interrupt register1307 . and finally restore state.1308 .1309 ---------------------------------------------------------------------*/1310 1311static irqreturn_t smc_interrupt(int irq, void * dev_id)1312{1313 struct net_device *dev = dev_id;1314 int ioaddr = dev->base_addr;1315 struct smc_local *lp = netdev_priv(dev);1316 1317 byte status;1318 word card_stats;1319 byte mask;1320 int timeout;1321 /* state registers */1322 word saved_bank;1323 word saved_pointer;1324 int handled = 0;1325 1326 1327 PRINTK3((CARDNAME": SMC interrupt started\n"));1328 1329 saved_bank = inw( ioaddr + BANK_SELECT );1330 1331 SMC_SELECT_BANK(2);1332 saved_pointer = inw( ioaddr + POINTER );1333 1334 mask = inb( ioaddr + INT_MASK );1335 /* clear all interrupts */1336 outb( 0, ioaddr + INT_MASK );1337 1338 1339 /* set a timeout value, so I don't stay here forever */1340 timeout = 4;1341 1342 PRINTK2((KERN_WARNING CARDNAME ": MASK IS %x\n", mask));1343 do {1344 /* read the status flag, and mask it */1345 status = inb( ioaddr + INTERRUPT ) & mask;1346 if (!status )1347 break;1348 1349 handled = 1;1350 1351 PRINTK3((KERN_WARNING CARDNAME1352 ": Handling interrupt status %x\n", status));1353 1354 if (status & IM_RCV_INT) {1355 /* Got a packet(s). */1356 PRINTK2((KERN_WARNING CARDNAME1357 ": Receive Interrupt\n"));1358 smc_rcv(dev);1359 } else if (status & IM_TX_INT ) {1360 PRINTK2((KERN_WARNING CARDNAME1361 ": TX ERROR handled\n"));1362 smc_tx(dev);1363 outb(IM_TX_INT, ioaddr + INTERRUPT );1364 } else if (status & IM_TX_EMPTY_INT ) {1365 /* update stats */1366 SMC_SELECT_BANK( 0 );1367 card_stats = inw( ioaddr + COUNTER );1368 /* single collisions */1369 dev->stats.collisions += card_stats & 0xF;1370 card_stats >>= 4;1371 /* multiple collisions */1372 dev->stats.collisions += card_stats & 0xF;1373 1374 /* these are for when linux supports these statistics */1375 1376 SMC_SELECT_BANK( 2 );1377 PRINTK2((KERN_WARNING CARDNAME1378 ": TX_BUFFER_EMPTY handled\n"));1379 outb( IM_TX_EMPTY_INT, ioaddr + INTERRUPT );1380 mask &= ~IM_TX_EMPTY_INT;1381 dev->stats.tx_packets += lp->packets_waiting;1382 lp->packets_waiting = 0;1383 1384 } else if (status & IM_ALLOC_INT ) {1385 PRINTK2((KERN_DEBUG CARDNAME1386 ": Allocation interrupt\n"));1387 /* clear this interrupt so it doesn't happen again */1388 mask &= ~IM_ALLOC_INT;1389 1390 smc_hardware_send_packet( dev );1391 1392 /* enable xmit interrupts based on this */1393 mask |= ( IM_TX_EMPTY_INT | IM_TX_INT );1394 1395 /* and let the card send more packets to me */1396 netif_wake_queue(dev);1397 1398 PRINTK2((CARDNAME": Handoff done successfully.\n"));1399 } else if (status & IM_RX_OVRN_INT ) {1400 dev->stats.rx_errors++;1401 dev->stats.rx_fifo_errors++;1402 outb( IM_RX_OVRN_INT, ioaddr + INTERRUPT );1403 } else if (status & IM_EPH_INT ) {1404 PRINTK((CARDNAME ": UNSUPPORTED: EPH INTERRUPT\n"));1405 } else if (status & IM_ERCV_INT ) {1406 PRINTK((CARDNAME ": UNSUPPORTED: ERCV INTERRUPT\n"));1407 outb( IM_ERCV_INT, ioaddr + INTERRUPT );1408 }1409 } while ( timeout -- );1410 1411 1412 /* restore state register */1413 SMC_SELECT_BANK( 2 );1414 outb( mask, ioaddr + INT_MASK );1415 1416 PRINTK3((KERN_WARNING CARDNAME ": MASK is now %x\n", mask));1417 outw( saved_pointer, ioaddr + POINTER );1418 1419 SMC_SELECT_BANK( saved_bank );1420 1421 PRINTK3((CARDNAME ": Interrupt done\n"));1422 return IRQ_RETVAL(handled);1423}1424 1425 1426/*----------------------------------------------------1427 . smc_close1428 .1429 . this makes the board clean up everything that it can1430 . and not talk to the outside world. Caused by1431 . an 'ifconfig ethX down'1432 .1433 -----------------------------------------------------*/1434static int smc_close(struct net_device *dev)1435{1436 netif_stop_queue(dev);1437 /* clear everything */1438 smc_shutdown( dev->base_addr );1439 1440 /* Update the statistics here. */1441 return 0;1442}1443 1444/*-----------------------------------------------------------1445 . smc_set_multicast_list1446 .1447 . This routine will, depending on the values passed to it,1448 . either make it accept multicast packets, go into1449 . promiscuous mode ( for TCPDUMP and cousins ) or accept1450 . a select set of multicast packets1451*/1452static void smc_set_multicast_list(struct net_device *dev)1453{1454 short ioaddr = dev->base_addr;1455 1456 SMC_SELECT_BANK(0);1457 if ( dev->flags & IFF_PROMISC )1458 outw( inw(ioaddr + RCR ) | RCR_PROMISC, ioaddr + RCR );1459 1460/* BUG? I never disable promiscuous mode if multicasting was turned on.1461 Now, I turn off promiscuous mode, but I don't do anything to multicasting1462 when promiscuous mode is turned on.1463*/1464 1465 /* Here, I am setting this to accept all multicast packets.1466 I don't need to zero the multicast table, because the flag is1467 checked before the table is1468 */1469 else if (dev->flags & IFF_ALLMULTI)1470 outw( inw(ioaddr + RCR ) | RCR_ALMUL, ioaddr + RCR );1471 1472 /* We just get all multicast packets even if we only want them1473 . from one source. This will be changed at some future1474 . point. */1475 else if (!netdev_mc_empty(dev)) {1476 /* support hardware multicasting */1477 1478 /* be sure I get rid of flags I might have set */1479 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),1480 ioaddr + RCR );1481 /* NOTE: this has to set the bank, so make sure it is the1482 last thing called. The bank is set to zero at the top */1483 smc_setmulticast(ioaddr, dev);1484 }1485 else {1486 outw( inw( ioaddr + RCR ) & ~(RCR_PROMISC | RCR_ALMUL),1487 ioaddr + RCR );1488 1489 /*1490 since I'm disabling all multicast entirely, I need to1491 clear the multicast list1492 */1493 SMC_SELECT_BANK( 3 );1494 outw( 0, ioaddr + MULTICAST1 );1495 outw( 0, ioaddr + MULTICAST2 );1496 outw( 0, ioaddr + MULTICAST3 );1497 outw( 0, ioaddr + MULTICAST4 );1498 }1499}1500 1501#ifdef MODULE1502 1503static struct net_device *devSMC9194;1504MODULE_DESCRIPTION("SMC 9194 Ethernet driver");1505MODULE_LICENSE("GPL");1506 1507module_param_hw(io, int, ioport, 0);1508module_param_hw(irq, int, irq, 0);1509module_param(ifport, int, 0);1510MODULE_PARM_DESC(io, "SMC 99194 I/O base address");1511MODULE_PARM_DESC(irq, "SMC 99194 IRQ number");1512MODULE_PARM_DESC(ifport, "SMC 99194 interface port (0-default, 1-TP, 2-AUI)");1513 1514static int __init smc_init_module(void)1515{1516 if (io == 0)1517 printk(KERN_WARNING1518 CARDNAME": You shouldn't use auto-probing with insmod!\n" );1519 1520 /* copy the parameters from insmod into the device structure */1521 devSMC9194 = smc_init(-1);1522 return PTR_ERR_OR_ZERO(devSMC9194);1523}1524module_init(smc_init_module);1525 1526static void __exit smc_cleanup_module(void)1527{1528 unregister_netdev(devSMC9194);1529 free_irq(devSMC9194->irq, devSMC9194);1530 release_region(devSMC9194->base_addr, SMC_IO_EXTENT);1531 free_netdev(devSMC9194);1532}1533module_exit(smc_cleanup_module);1534 1535#endif /* MODULE */1536