drivers/net/3c501.c

/* */
This source file includes following definitions.
el1_probe
el1_probe1
el_open
el_start_xmit
el_interrupt
el_receive
el_reset
el1_close
el1_get_stats
set_multicast_list
init_module
cleanup_module
   1 /* 3c501.c: A 3Com 3c501 ethernet driver for linux. */
   2 /*
   3     Written 1992,1993,1994  Donald Becker
   4 
   5     Copyright 1993 United States Government as represented by the
   6     Director, National Security Agency.  This software may be used and
   7     distributed according to the terms of the GNU Public License,
   8     incorporated herein by reference.
   9 
  10     This is a device driver for the 3Com Etherlink 3c501.
  11     Do not purchase this card, even as a joke.  It's performance is horrible,
  12     and it breaks in many ways.  
  13 
  14     The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O
  15     Center of Excellence in Space Data and Information Sciences
  16        Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
  17        
  18     Fixed (again!) the missing interrupt locking on TX/RX shifting.
  19                 Alan Cox <Alan.Cox@linux.org>
  20                 
  21     Removed calls to init_etherdev since they are no longer needed, and
  22     cleaned up modularization just a bit. The driver still allows only
  23     the default address for cards when loaded as a module, but that's
  24     really less braindead than anyone using a 3c501 board. :)
  25                     19950208 (invid@msen.com)
  26 
  27     Added traps for interrupts hitting the window as we clear and TX load
  28     the board. Now getting 150K/second FTP with a 3c501 card. Still playing
  29     with a TX-TX optimisation to see if we can touch 180-200K/second as seems
  30     theoretically maximum.
  31                 19950402 Alan Cox <Alan.Cox@linux.org>
  32                 
  33     Some notes on this thing if you have to hack it.  [Alan]
  34     
  35     1]  Some documentation is available from 3Com. Due to the boards age
  36         standard responses when you ask for this will range from 'be serious'
  37         to 'give it to a museum'. The documentation is incomplete and mostly
  38         of historical interest anyway.
  39         
  40     2]  The basic system is a single buffer which can be used to receive or
  41         transmit a packet. A third command mode exists when you are setting
  42         things up.
  43         
  44     3]  If it's transmitting it's not receiving and vice versa. In fact the 
  45         time to get the board back into useful state after an operation is
  46         quite large.
  47         
  48     4]  The driver works by keeping the board in receive mode waiting for a
  49         packet to arrive. When one arrives it is copied out of the buffer
  50         and delivered to the kernel. The card is reloaded and off we go.
  51         
  52     5]  When transmitting dev->tbusy is set and the card is reset (from
  53         receive mode) [possibly losing a packet just received] to command
  54         mode. A packet is loaded and transmit mode triggered. The interrupt
  55         handler runs different code for transmit interrupts and can handle
  56         returning to receive mode or retransmissions (yes you have to help
  57         out with those too).
  58         
  59     Problems:
  60         There are a wide variety of undocumented error returns from the card
  61     and you basically have to kick the board and pray if they turn up. Most 
  62     only occur under extreme load or if you do something the board doesn't
  63     like (eg touching a register at the wrong time).
  64     
  65         The driver is less efficient than it could be. It switches through
  66     receive mode even if more transmits are queued. If this worries you buy
  67     a real ethernet card.
  68     
  69         The combination of slow receive restart and no real multicast
  70     filter makes the board unusable with a kernel compiled for IP
  71     multicasting in a real multicast environment. Thats down to the board, 
  72     but even with no multicast programs running a multicast IP kernel is
  73     in group 224.0.0.1 and you will therefore be listening to all multicasts.
  74     One nv conference running over that ethernet and you can give up.
  75     
  76 */
  77 
  78 static char *version =
  79     "3c501.c: 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov).\n";
  80 
  81 /*
  82   Braindamage remaining:
  83   The 3c501 board.
  84   */
  85 
  86 #include <linux/config.h>
  87 #ifdef MODULE
  88 #include <linux/module.h>
  89 #include <linux/version.h>
  90 #else
  91 #define MOD_INC_USE_COUNT
  92 #define MOD_DEC_USE_COUNT
  93 #endif
  94 
  95 #include <linux/kernel.h>
  96 #include <linux/sched.h>
  97 #include <linux/ptrace.h>
  98 #include <linux/fcntl.h>
  99 #include <linux/ioport.h>
 100 #include <linux/interrupt.h>
 101 #include <linux/malloc.h>
 102 #include <linux/string.h>
 103 #include <linux/ioport.h>
 104 #include <linux/errno.h>
 105 
 106 #include <asm/bitops.h>
 107 #include <asm/io.h>
 108 
 109 #include <linux/netdevice.h>
 110 #include <linux/etherdevice.h>
 111 #include <linux/skbuff.h>
 112 
 113 /* A zero-terminated list of I/O addresses to be probed.
 114    The 3c501 can be at many locations, but here are the popular ones. */
 115 static unsigned int netcard_portlist[] =
 116    { 0x280, 0x300, 0};
 117 
 118 
 119 /* Index to functions. */
 120 int el1_probe(struct device *dev);
 121 static int  el1_probe1(struct device *dev, int ioaddr);
 122 static int  el_open(struct device *dev);
 123 static int  el_start_xmit(struct sk_buff *skb, struct device *dev);
 124 static void el_interrupt(int irq, struct pt_regs *regs);
 125 static void el_receive(struct device *dev);
 126 static void el_reset(struct device *dev);
 127 static int  el1_close(struct device *dev);
 128 static struct enet_statistics *el1_get_stats(struct device *dev);
 129 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
 130 
 131 #define EL1_IO_EXTENT   16
 132 
 133 #ifndef EL_DEBUG
 134 #define EL_DEBUG  2     /* use 0 for production, 1 for devel., >2 for debug */
 135 #endif                  /* Anything above 5 is wordy death! */
 136 static int el_debug = EL_DEBUG;
 137  
 138 /* Board-specific info in dev->priv. */
 139 struct net_local {
 140     struct enet_statistics stats;
 141     int tx_pkt_start;           /* The length of the current Tx packet. */
 142     int collisions;             /* Tx collisions this packet */
 143     int loading;                /* Spot buffer load collisions */
 144 };
 145 
 146 
 147 #define RX_STATUS (ioaddr + 0x06)
 148 #define RX_CMD    RX_STATUS
 149 #define TX_STATUS (ioaddr + 0x07)
 150 #define TX_CMD    TX_STATUS
 151 #define GP_LOW    (ioaddr + 0x08)
 152 #define GP_HIGH   (ioaddr + 0x09)
 153 #define RX_BUF_CLR (ioaddr + 0x0A)
 154 #define RX_LOW    (ioaddr + 0x0A)
 155 #define RX_HIGH   (ioaddr + 0x0B)
 156 #define SAPROM    (ioaddr + 0x0C)
 157 #define AX_STATUS (ioaddr + 0x0E)
 158 #define AX_CMD    AX_STATUS
 159 #define DATAPORT  (ioaddr + 0x0F)
 160 #define TX_RDY 0x08             /* In TX_STATUS */
 161 
 162 #define EL1_DATAPTR     0x08
 163 #define EL1_RXPTR       0x0A
 164 #define EL1_SAPROM      0x0C
 165 #define EL1_DATAPORT    0x0f
 166 
 167 /* Writes to the ax command register. */
 168 #define AX_OFF  0x00                    /* Irq off, buffer access on */
 169 #define AX_SYS  0x40                    /* Load the buffer */
 170 #define AX_XMIT 0x44                    /* Transmit a packet */
 171 #define AX_RX   0x48                    /* Receive a packet */
 172 #define AX_LOOP 0x0C                    /* Loopback mode */
 173 #define AX_RESET 0x80
 174 
 175 /* Normal receive mode written to RX_STATUS.  We must intr on short packets
 176    to avoid bogus rx lockups. */
 177 #define RX_NORM 0xA8            /* 0x68 == all addrs, 0xA8 only to me. */
 178 #define RX_PROM 0x68            /* Senior Prom, uhmm promiscuous mode. */
 179 #define RX_MULT 0xE8            /* Accept multicast packets. */
 180 #define TX_NORM 0x0A    /* Interrupt on everything that might hang the chip */
 181 
 182 /* TX_STATUS register. */
 183 #define TX_COLLISION 0x02
 184 #define TX_16COLLISIONS 0x04
 185 #define TX_READY 0x08
 186 
 187 #define RX_RUNT 0x08
 188 #define RX_MISSED 0x01          /* Missed a packet due to 3c501 braindamage. */
 189 #define RX_GOOD 0x30            /* Good packet 0x20, or simple overflow 0x10. */
 190 
 191 
 192 /* The boilerplate probe code. */
 193 #ifdef HAVE_DEVLIST
 194 struct netdev_entry el1_drv =
 195 {"3c501", el1_probe1, EL1_IO_EXTENT, netcard_portlist};
 196 #else
 197 int
 198 el1_probe(struct device *dev)
     /*  */
 199 {
 200     int i;
 201     int base_addr = dev ? dev->base_addr : 0;
 202 
 203     if (base_addr > 0x1ff)      /* Check a single specified location. */
 204         return el1_probe1(dev, base_addr);
 205     else if (base_addr != 0)    /* Don't probe at all. */
 206         return ENXIO;
 207 
 208     for (i = 0; netcard_portlist[i]; i++) {
 209         int ioaddr = netcard_portlist[i];
 210         if (check_region(ioaddr, EL1_IO_EXTENT))
 211             continue;
 212         if (el1_probe1(dev, ioaddr) == 0)
 213             return 0;
 214     }
 215 
 216     return ENODEV;
 217 }
 218 #endif
 219 
 220 /* The actual probe. */ 
 221 static int
 222 el1_probe1(struct device *dev, int ioaddr)
     /*  */
 223 {
 224     #ifndef MODULE
 225 
 226     char *mname;                /* Vendor name */
 227     unsigned char station_addr[6];
 228     int autoirq = 0;
 229     int i;
 230 
 231     /* Read the station address PROM data from the special port.  */
 232     for (i = 0; i < 6; i++) {
 233         outw(i, ioaddr + EL1_DATAPTR);
 234         station_addr[i] = inb(ioaddr + EL1_SAPROM);
 235     }
 236     /* Check the first three octets of the S.A. for 3Com's prefix, or
 237        for the Sager NP943 prefix. */ 
 238     if (station_addr[0] == 0x02  &&  station_addr[1] == 0x60
 239         && station_addr[2] == 0x8c) {
 240         mname = "3c501";
 241     } else if (station_addr[0] == 0x00  &&  station_addr[1] == 0x80
 242         && station_addr[2] == 0xC8) {
 243         mname = "NP943";
 244     } else
 245         return ENODEV;
 246 
 247     /* Grab the region so we can find the another board if autoIRQ fails. */
 248     request_region(ioaddr, EL1_IO_EXTENT,"3c501");
 249 
 250     /* We auto-IRQ by shutting off the interrupt line and letting it float
 251        high. */
 252     if (dev->irq < 2) {
 253 
 254         autoirq_setup(2);
 255 
 256         inb(RX_STATUS);         /* Clear pending interrupts. */
 257         inb(TX_STATUS);
 258         outb(AX_LOOP + 1, AX_CMD);
 259 
 260         outb(0x00, AX_CMD);
 261 
 262         autoirq = autoirq_report(1);
 263 
 264         if (autoirq == 0) {
 265             printk("%s probe at %#x failed to detect IRQ line.\n",
 266                    mname, ioaddr);
 267             return EAGAIN;
 268         }
 269     }
 270 
 271     outb(AX_RESET+AX_LOOP, AX_CMD);                     /* Loopback mode. */
 272 
 273     dev->base_addr = ioaddr;
 274     memcpy(dev->dev_addr, station_addr, ETH_ALEN);
 275     if (dev->mem_start & 0xf)
 276         el_debug = dev->mem_start & 0x7;
 277     if (autoirq)
 278         dev->irq = autoirq;
 279 
 280     printk("%s: %s EtherLink at %#lx, using %sIRQ %d.\n",
 281            dev->name, mname, dev->base_addr,
 282            autoirq ? "auto":"assigned ", dev->irq);
 283            
 284 #ifdef CONFIG_IP_MULTICAST
 285     printk("WARNING: Use of the 3c501 in a multicast kernel is NOT recommended.\n");
 286 #endif    
 287 
 288     if (el_debug)
 289         printk("%s", version);
 290 
 291     /* Initialize the device structure. */
 292     if (dev->priv == NULL)
 293         dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
 294     memset(dev->priv, 0, sizeof(struct net_local));
 295 
 296     /* The EL1-specific entries in the device structure. */
 297     dev->open = &el_open;
 298     dev->hard_start_xmit = &el_start_xmit;
 299     dev->stop = &el1_close;
 300     dev->get_stats = &el1_get_stats;
 301     dev->set_multicast_list = &set_multicast_list;
 302     /* Setup the generic properties */
 303     ether_setup(dev);
 304 
 305 #endif /* !MODULE */
 306     return 0;
 307 }
 308 
 309 /* Open/initialize the board. */
 310 static int
 311 el_open(struct device *dev)
     /*  */
 312 {
 313     int ioaddr = dev->base_addr;
 314 
 315     if (el_debug > 2)
 316         printk("%s: Doing el_open()...", dev->name);
 317 
 318     if (request_irq(dev->irq, &el_interrupt, 0, "3c501")) {
 319         return -EAGAIN;
 320     }
 321     irq2dev_map[dev->irq] = dev;
 322 
 323     el_reset(dev);
 324 
 325     dev->start = 1;
 326 
 327     outb(AX_RX, AX_CMD);        /* Aux control, irq and receive enabled */
 328     MOD_INC_USE_COUNT;
 329     return 0;
 330 }
 331 
 332 static int
 333 el_start_xmit(struct sk_buff *skb, struct device *dev)
     /*  */
 334 {
 335     struct net_local *lp = (struct net_local *)dev->priv;
 336     int ioaddr = dev->base_addr;
 337     unsigned long flags;
 338 
 339     if (dev->tbusy) {
 340         if (jiffies - dev->trans_start < 20) {
 341             if (el_debug > 2)
 342                 printk(" transmitter busy, deferred.\n");
 343             return 1;
 344         }
 345         if (el_debug)
 346             printk ("%s: transmit timed out, txsr %#2x axsr=%02x rxsr=%02x.\n",
 347                     dev->name, inb(TX_STATUS), inb(AX_STATUS), inb(RX_STATUS));
 348         lp->stats.tx_errors++;
 349         outb(TX_NORM, TX_CMD);
 350         outb(RX_NORM, RX_CMD);
 351         outb(AX_OFF, AX_CMD);   /* Just trigger a false interrupt. */
 352         outb(AX_RX, AX_CMD);    /* Aux control, irq and receive enabled */
 353         dev->tbusy = 0;
 354         dev->trans_start = jiffies;
 355     }
 356 
 357     if (skb == NULL) {
 358         dev_tint(dev);
 359         return 0;
 360     }
 361 
 362     save_flags(flags);
 363     /* Avoid incoming interrupts between us flipping tbusy and flipping
 364        mode as the driver assumes tbusy is a faithful indicator of card
 365        state */
 366     cli();
 367     /* Avoid timer-based retransmission conflicts. */
 368     if (set_bit(0, (void*)&dev->tbusy) != 0)
 369     {
 370         restore_flags(flags);
 371         printk("%s: Transmitter access conflict.\n", dev->name);
 372     }
 373     else {
 374         int gp_start = 0x800 - (ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN);
 375         unsigned char *buf = skb->data;
 376 
 377 load_it_again_sam:
 378         lp->tx_pkt_start = gp_start;
 379         lp->collisions = 0;
 380 
 381         /*
 382          *      Command mode with status cleared should [in theory]
 383          *      mean no more interrupts can be pending on the card.
 384          */
 385         outb(AX_SYS, AX_CMD);
 386         inb(RX_STATUS);
 387         inb(TX_STATUS);
 388         
 389         lp->loading=1;
 390         
 391         /* 
 392          *      Turn interrupts back on while we spend a pleasant afternoon
 393          *      loading bytes into the board 
 394          */
 395         restore_flags(flags);
 396         outw(0x00, RX_BUF_CLR);         /* Set rx packet area to 0. */
 397         outw(gp_start, GP_LOW);         /* aim - packet will be loaded into buffer start */
 398         outsb(DATAPORT,buf,skb->len);   /* load buffer (usual thing each byte increments the pointer) */
 399         outw(gp_start, GP_LOW);         /* the board reuses the same register */
 400         if(lp->loading==2)              /* A receive upset our load, despite our best efforts */
 401         {
 402                 if(el_debug>2)
 403                         printk("%s: burped during tx load.\n", dev->name);
 404                 goto load_it_again_sam; /* Sigh... */
 405         }
 406         outb(AX_XMIT, AX_CMD);          /* fire ... Trigger xmit.  */
 407         dev->trans_start = jiffies;
 408     }
 409 
 410     if (el_debug > 2)
 411         printk(" queued xmit.\n");
 412     dev_kfree_skb (skb, FREE_WRITE);
 413     return 0;
 414 }
 415 
 416 
 417 /* The typical workload of the driver:
 418    Handle the ether interface interrupts. */
 419 static void
 420 el_interrupt(int irq, struct pt_regs *regs)
     /*  */
 421 {
 422     struct device *dev = (struct device *)(irq2dev_map[irq]);
 423     struct net_local *lp;
 424     int ioaddr;
 425     int axsr;                   /* Aux. status reg. */
 426 
 427     if (dev == NULL  ||  dev->irq != irq) {
 428         printk ("3c501 driver: irq %d for unknown device.\n", irq);
 429         return;
 430     }
 431 
 432     ioaddr = dev->base_addr;
 433     lp = (struct net_local *)dev->priv;
 434     axsr = inb(AX_STATUS);
 435 
 436     if (el_debug > 3)
 437       printk("%s: el_interrupt() aux=%#02x", dev->name, axsr);
 438     if (dev->interrupt)
 439         printk("%s: Reentering the interrupt driver!\n", dev->name);
 440     dev->interrupt = 1;
 441     
 442     lp->loading=2;              /* So we can spot loading interruptions */
 443 
 444     if (dev->tbusy) {
 445     
 446         /*
 447          *      Board in transmit mode.
 448          */
 449          
 450         int txsr = inb(TX_STATUS);
 451 
 452         if (el_debug > 6)
 453             printk(" txsr=%02x gp=%04x rp=%04x", txsr, inw(GP_LOW),
 454                    inw(RX_LOW));
 455 
 456         if ((axsr & 0x80) && (txsr & TX_READY) == 0) {
 457         /*
 458          *      FIXME: is there a logic to whether to keep on trying or
 459          *      reset immediately ?
 460          */
 461             printk("%s: Unusual interrupt during Tx, txsr=%02x axsr=%02x"
 462                    " gp=%03x rp=%03x.\n", dev->name, txsr, axsr,
 463                    inw(ioaddr + EL1_DATAPTR), inw(ioaddr + EL1_RXPTR));
 464             dev->tbusy = 0;
 465             mark_bh(NET_BH);
 466         } else if (txsr & TX_16COLLISIONS) {
 467         /*
 468          *      Timed out
 469          */
 470             if (el_debug)
 471                 printk("%s: Transmit failed 16 times, ethernet jammed?\n",
 472                        dev->name);
 473             outb(AX_SYS, AX_CMD);
 474             lp->stats.tx_aborted_errors++;
 475         } else if (txsr & TX_COLLISION) {       /* Retrigger xmit. */
 476             if (el_debug > 6)
 477                 printk(" retransmitting after a collision.\n");
 478         /*
 479          *      Poor little chip can't reset its own start pointer
 480          */
 481             outb(AX_SYS, AX_CMD);
 482             outw(lp->tx_pkt_start, GP_LOW);
 483             outb(AX_XMIT, AX_CMD);
 484             lp->stats.collisions++;
 485             dev->interrupt = 0;
 486             return;
 487         } else {
 488         /*
 489          *      It worked.. we will now fall through and receive
 490          */
 491             lp->stats.tx_packets++;
 492             if (el_debug > 6)
 493                 printk(" Tx succeeded %s\n",
 494                        (txsr & TX_RDY) ? "." : "but tx is busy!");
 495         /*
 496          *      This is safe the interrupt is atomic WRT itself.
 497          */
 498             dev->tbusy = 0;
 499             mark_bh(NET_BH);    /* In case more to transmit */
 500         }
 501     } else {
 502     
 503         /*
 504          *      In receive mode.
 505          */
 506          
 507         int rxsr = inb(RX_STATUS);
 508         if (el_debug > 5)
 509             printk(" rxsr=%02x txsr=%02x rp=%04x", rxsr, inb(TX_STATUS),
 510                    inw(RX_LOW));
 511 
 512         /*
 513          *      Just reading rx_status fixes most errors. 
 514          */
 515         if (rxsr & RX_MISSED)
 516             lp->stats.rx_missed_errors++;
 517         if (rxsr & RX_RUNT) {   /* Handled to avoid board lock-up. */
 518             lp->stats.rx_length_errors++;
 519             if (el_debug > 5) printk(" runt.\n");
 520         } else if (rxsr & RX_GOOD) {
 521         /*
 522          *      Receive worked.
 523          */
 524             el_receive(dev);
 525         } else {                        /* Nothing?  Something is broken! */
 526             if (el_debug > 2)
 527                 printk("%s: No packet seen, rxsr=%02x **resetting 3c501***\n",
 528                        dev->name, rxsr);
 529             el_reset(dev);
 530         }
 531         if (el_debug > 3)
 532             printk(".\n");
 533     }
 534 
 535     /*
 536      *  Move into receive mode 
 537      */
 538     outb(AX_RX, AX_CMD);
 539     outw(0x00, RX_BUF_CLR);
 540     inb(RX_STATUS);             /* Be certain that interrupts are cleared. */
 541     inb(TX_STATUS);
 542     dev->interrupt = 0;
 543     return;
 544 }
 545 
 546 
 547 /* We have a good packet. Well, not really "good", just mostly not broken.
 548    We must check everything to see if it is good. */
 549 static void
 550 el_receive(struct device *dev)
     /*  */
 551 {
 552     struct net_local *lp = (struct net_local *)dev->priv;
 553     int ioaddr = dev->base_addr;
 554     int pkt_len;
 555     struct sk_buff *skb;
 556 
 557     pkt_len = inw(RX_LOW);
 558 
 559     if (el_debug > 4)
 560       printk(" el_receive %d.\n", pkt_len);
 561 
 562     if ((pkt_len < 60)  ||  (pkt_len > 1536)) {
 563         if (el_debug)
 564           printk("%s: bogus packet, length=%d\n", dev->name, pkt_len);
 565         lp->stats.rx_over_errors++;
 566         return;
 567     }
 568     
 569     /*
 570      *  Command mode so we can empty the buffer
 571      */
 572      
 573     outb(AX_SYS, AX_CMD);
 574 
 575     skb = dev_alloc_skb(pkt_len+2);
 576     /*
 577      *  Start of frame
 578      */
 579     outw(0x00, GP_LOW);
 580     if (skb == NULL) {
 581         printk("%s: Memory squeeze, dropping packet.\n", dev->name);
 582         lp->stats.rx_dropped++;
 583         return;
 584     } else {
 585         skb_reserve(skb,2);     /* Force 16 byte alignment */
 586         skb->dev = dev;
 587 
 588         /*
 589          *      The read increments through the bytes. The interrupt
 590          *      handler will fix the pointer when it returns to 
 591          *      receive mode.
 592          */
 593          
 594         insb(DATAPORT, skb_put(skb,pkt_len), pkt_len);
 595         skb->protocol=eth_type_trans(skb,dev);
 596         netif_rx(skb);
 597         lp->stats.rx_packets++;
 598     }
 599     return;
 600 }
 601 
 602 static void 
 603 el_reset(struct device *dev)
     /*  */
 604 {
 605     int ioaddr = dev->base_addr;
 606 
 607     if (el_debug> 2)
 608         printk("3c501 reset...");
 609     outb(AX_RESET, AX_CMD);     /* Reset the chip */
 610     outb(AX_LOOP, AX_CMD);      /* Aux control, irq and loopback enabled */
 611     {
 612         int i;
 613         for (i = 0; i < 6; i++) /* Set the station address. */
 614             outb(dev->dev_addr[i], ioaddr + i);
 615     }
 616     
 617     outw(0, RX_BUF_CLR);                /* Set rx packet area to 0. */
 618     cli();                      /* Avoid glitch on writes to CMD regs */
 619     outb(TX_NORM, TX_CMD);              /* tx irq on done, collision */
 620     outb(RX_NORM, RX_CMD);      /* Set Rx commands. */
 621     inb(RX_STATUS);             /* Clear status. */
 622     inb(TX_STATUS);
 623     dev->interrupt = 0;
 624     dev->tbusy = 0;
 625     sti();
 626 }
 627 
 628 static int
 629 el1_close(struct device *dev)
     /*  */
 630 {
 631     int ioaddr = dev->base_addr;
 632 
 633     if (el_debug > 2)
 634         printk("%s: Shutting down ethercard at %#x.\n", dev->name, ioaddr);
 635 
 636     dev->tbusy = 1;
 637     dev->start = 0;
 638 
 639     /* Free and disable the IRQ. */
 640     free_irq(dev->irq);
 641     outb(AX_RESET, AX_CMD);     /* Reset the chip */
 642     irq2dev_map[dev->irq] = 0;
 643 
 644     MOD_DEC_USE_COUNT;
 645     return 0;
 646 }
 647 
 648 static struct enet_statistics *
 649 el1_get_stats(struct device *dev)
     /*  */
 650 {
 651     struct net_local *lp = (struct net_local *)dev->priv;
 652     return &lp->stats;
 653 }
 654 
 655 /* Set or clear the multicast filter for this adaptor.
 656    num_addrs == -1      Promiscuous mode, receive all packets
 657    num_addrs == 0       Normal mode, clear multicast list
 658    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
 659                         best-effort filtering.
 660  */
 661 static void
 662 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
     /*  */
 663 {
 664     int ioaddr = dev->base_addr;
 665 
 666     if (num_addrs > 0) {
 667         outb(RX_MULT, RX_CMD);
 668         inb(RX_STATUS);         /* Clear status. */
 669     } else if (num_addrs < 0) {
 670         outb(RX_PROM, RX_CMD);
 671         inb(RX_STATUS);
 672     } else {
 673         outb(RX_NORM, RX_CMD);
 674         inb(RX_STATUS);
 675     }
 676 }
 677 #ifdef MODULE
 678 char kernel_version[] = UTS_RELEASE;
 679 static struct device dev_3c501 = {
 680         "        " /*"3c501"*/, 
 681                 0, 0, 0, 0,
 682                 0x280, 5,
 683                 0, 0, 0, NULL, el1_probe };
 684 
 685 int io=0x280;
 686 int irq=5;
 687         
 688 int
 689 init_module(void)
     /*  */
 690 {
 691         dev_3c501.irq=irq;
 692         dev_3c501.base_addr=io;
 693         if (register_netdev(&dev_3c501) != 0)
 694                 return -EIO;
 695         return 0;
 696 }
 697 
 698 void
 699 cleanup_module(void)
     /*  */
 700 {
 701         /* No need to check MOD_IN_USE, as sys_delete_module() checks. */
 702         unregister_netdev(&dev_3c501);
 703 
 704         /* Free up the private structure, or leak memory :-)  */
 705         kfree(dev_3c501.priv);
 706         dev_3c501.priv = NULL;  /* gets re-allocated by el1_probe1 */
 707 
 708         /* If we don't do this, we can't re-insmod it later. */
 709         release_region(dev_3c501.base_addr, EL1_IO_EXTENT);
 710 }
 711 #endif /* MODULE */
 712 
 713 /*
 714  * Local variables:
 715  *  compile-command: "gcc -D__KERNEL__ -Wall -Wstrict-prototypes -O6 -fomit-frame-pointer  -m486 -c -o 3c501.o 3c501.c"
 716  *  kept-new-versions: 5
 717  * End:
 718  */
/* */
root/drivers/net/3c501.c

DEFINITIONS
