root/drivers/net/3c509.c

/* [previous][next][first][last][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. el3_probe
  2. read_eeprom
  3. id_read_eeprom
  4. el3_open
  5. el3_start_xmit
  6. el3_interrupt
  7. el3_get_stats
  8. update_stats
  9. el3_rx
  10. set_multicast_list
  11. el3_close
  12. init_module
  13. cleanup_module

   1 /* 3c509.c: A 3c509 EtherLink3 ethernet driver for linux. */
   2 /*
   3         Written 1993,1994 by Donald Becker.
   4 
   5         Copyright 1994 by Donald Becker.
   6         Copyright 1993 United States Government as represented by the
   7         Director, National Security Agency.      This software may be used and
   8         distributed according to the terms of the GNU Public License,
   9         incorporated herein by reference.
  10 
  11         This driver is for the 3Com EtherLinkIII series.
  12 
  13         The author may be reached as becker@cesdis.gsfc.nasa.gov or
  14         C/O Center of Excellence in Space Data and Information Sciences
  15                 Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
  16 
  17         Known limitations:
  18         Because of the way 3c509 ISA detection works it's difficult to predict
  19         a priori which of several ISA-mode cards will be detected first.
  20 
  21         This driver does not use predictive interrupt mode, resulting in higher
  22         packet latency but lower overhead.  If interrupts are disabled for an
  23         unusually long time it could also result in missed packets, but in
  24         practice this rarely happens.
  25 */
  26 
  27 static const  char *version = "3c509.c:1.03 10/8/94 becker@cesdis.gsfc.nasa.gov\n";
  28 
  29 #include <linux/config.h>
  30 #ifdef MODULE
  31 #include <linux/module.h>
  32 #include <linux/version.h>
  33 #endif
  34 
  35 #include <linux/kernel.h>
  36 #include <linux/sched.h>
  37 #include <linux/string.h>
  38 #include <linux/interrupt.h>
  39 #include <linux/ptrace.h>
  40 #include <linux/errno.h>
  41 #include <linux/in.h>
  42 #include <linux/malloc.h>
  43 #include <linux/ioport.h>
  44 #include <asm/bitops.h>
  45 #include <asm/io.h>
  46 
  47 #include <linux/netdevice.h>
  48 #include <linux/etherdevice.h>
  49 #include <linux/skbuff.h>
  50 
  51 
  52 #ifdef EL3_DEBUG
  53 int el3_debug = EL3_DEBUG;
  54 #else
  55 int el3_debug = 2;
  56 #endif
  57 
  58 /* To minimize the size of the driver source I only define operating
  59    constants if they are used several times.  You'll need the manual
  60    if you want to understand driver details. */
  61 /* Offsets from base I/O address. */
  62 #define EL3_DATA 0x00
  63 #define EL3_CMD 0x0e
  64 #define EL3_STATUS 0x0e
  65 #define ID_PORT 0x100
  66 #define  EEPROM_READ 0x80
  67 
  68 #define EL3WINDOW(win_num) outw(SelectWindow + (win_num), ioaddr + EL3_CMD)
  69 
  70 
  71 /* The top five bits written to EL3_CMD are a command, the lower
  72    11 bits are the parameter, if applicable. */
  73 enum c509cmd {
  74         TotalReset = 0<<11, SelectWindow = 1<<11, StartCoax = 2<<11,
  75         RxDisable = 3<<11, RxEnable = 4<<11, RxReset = 5<<11, RxDiscard = 8<<11,
  76         TxEnable = 9<<11, TxDisable = 10<<11, TxReset = 11<<11,
  77         FakeIntr = 12<<11, AckIntr = 13<<11, SetIntrMask = 14<<11,
  78         SetReadZero = 15<<11, SetRxFilter = 16<<11, SetRxThreshold = 17<<11,
  79         SetTxThreshold = 18<<11, SetTxStart = 19<<11, StatsEnable = 21<<11,
  80         StatsDisable = 22<<11, StopCoax = 23<<11,};
  81 
  82 /* The SetRxFilter command accepts the following classes: */
  83 enum RxFilter {
  84         RxStation = 1, RxMulticast = 2, RxBroadcast = 4, RxProm = 8 };
  85 
  86 /* Register window 1 offsets, the window used in normal operation. */
  87 #define TX_FIFO         0x00
  88 #define RX_FIFO         0x00
  89 #define RX_STATUS       0x08
  90 #define TX_STATUS       0x0B
  91 #define TX_FREE         0x0C            /* Remaining free bytes in Tx buffer. */
  92 
  93 #define WN0_IRQ         0x08            /* Window 0: Set IRQ line in bits 12-15. */
  94 #define WN4_MEDIA       0x0A            /* Window 4: Various transcvr/media bits. */
  95 #define  MEDIA_TP       0x00C0          /* Enable link beat and jabber for 10baseT. */
  96 
  97 struct el3_private {
  98         struct enet_statistics stats;
  99 };
 100 
 101 static ushort id_read_eeprom(int index);
 102 static ushort read_eeprom(short ioaddr, int index);
 103 static int el3_open(struct device *dev);
 104 static int el3_start_xmit(struct sk_buff *skb, struct device *dev);
 105 static void el3_interrupt(int irq, struct pt_regs *regs);
 106 static void update_stats(int addr, struct device *dev);
 107 static struct enet_statistics *el3_get_stats(struct device *dev);
 108 static int el3_rx(struct device *dev);
 109 static int el3_close(struct device *dev);
 110 #ifdef HAVE_MULTICAST
 111 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
 112 #endif
 113 
 114 
 115 
 116 int el3_probe(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 117 {
 118         short lrs_state = 0xff, i;
 119         ushort ioaddr, irq, if_port;
 120         short *phys_addr = (short *)dev->dev_addr;
 121         static int current_tag = 0;
 122 
 123         /* First check all slots of the EISA bus.  The next slot address to
 124            probe is kept in 'eisa_addr' to support multiple probe() calls. */
 125         if (EISA_bus) {
 126                 static int eisa_addr = 0x1000;
 127                 while (eisa_addr < 0x9000) {
 128                         ioaddr = eisa_addr;
 129                         eisa_addr += 0x1000;
 130 
 131                         /* Check the standard EISA ID register for an encoded '3Com'. */
 132                         if (inw(ioaddr + 0xC80) != 0x6d50)
 133                                 continue;
 134 
 135                         /* Change the register set to the configuration window 0. */
 136                         outw(SelectWindow | 0, ioaddr + 0xC80 + EL3_CMD);
 137 
 138                         irq = inw(ioaddr + WN0_IRQ) >> 12;
 139                         if_port = inw(ioaddr + 6)>>14;
 140                         for (i = 0; i < 3; i++)
 141                                 phys_addr[i] = htons(read_eeprom(ioaddr, i));
 142 
 143                         /* Restore the "Product ID" to the EEPROM read register. */
 144                         read_eeprom(ioaddr, 3);
 145 
 146                         /* Was the EISA code an add-on hack?  Nahhhhh... */
 147                         goto found;
 148                 }
 149         }
 150 
 151 #ifdef CONFIG_MCA
 152         if (MCA_bus) {
 153                 mca_adaptor_select_mode(1);
 154                 for (i = 0; i < 8; i++)
 155                         if ((mca_adaptor_id(i) | 1) == 0x627c) {
 156                                 ioaddr = mca_pos_base_addr(i);
 157                                 irq = inw(ioaddr + WN0_IRQ) >> 12;
 158                                 if_port = inw(ioaddr + 6)>>14;
 159                                 for (i = 0; i < 3; i++)
 160                                         phys_addr[i] = htons(read_eeprom(ioaddr, i));
 161 
 162                                 mca_adaptor_select_mode(0);
 163                                 goto found;
 164                         }
 165                 mca_adaptor_select_mode(0);
 166 
 167         }
 168 #endif
 169 
 170         /* Next check for all ISA bus boards by sending the ID sequence to the
 171            ID_PORT.  We find cards past the first by setting the 'current_tag'
 172            on cards as they are found.  Cards with their tag set will not
 173            respond to subsequent ID sequences. */
 174 
 175         if (check_region(ID_PORT,1)) {
 176           static int once = 1;
 177           if (once) printk("3c509: Somebody has reserved 0x%x, can't do ID_PORT lookup, nor card auto-probing\n",ID_PORT);
 178           once = 0;
 179           return -ENODEV;
 180         }
 181 
 182         outb(0x00, ID_PORT);
 183         outb(0x00, ID_PORT);
 184         for(i = 0; i < 255; i++) {
 185                 outb(lrs_state, ID_PORT);
 186                 lrs_state <<= 1;
 187                 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
 188         }
 189 
 190         /* For the first probe, clear all board's tag registers. */
 191         if (current_tag == 0)
 192                 outb(0xd0, ID_PORT);
 193         else                            /* Otherwise kill off already-found boards. */
 194                 outb(0xd8, ID_PORT);
 195 
 196         if (id_read_eeprom(7) != 0x6d50) {
 197                 return -ENODEV;
 198         }
 199 
 200         /* Read in EEPROM data, which does contention-select.
 201            Only the lowest address board will stay "on-line".
 202            3Com got the byte order backwards. */
 203         for (i = 0; i < 3; i++) {
 204                 phys_addr[i] = htons(id_read_eeprom(i));
 205         }
 206 
 207         {
 208                 unsigned short iobase = id_read_eeprom(8);
 209                 if_port = iobase >> 14;
 210                 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
 211         }
 212         irq = id_read_eeprom(9) >> 12;
 213 
 214         if (dev->base_addr != 0
 215                 &&      dev->base_addr != (unsigned short)ioaddr) {
 216                 return -ENODEV;
 217         }
 218 
 219         /* Set the adaptor tag so that the next card can be found. */
 220         outb(0xd0 + ++current_tag, ID_PORT);
 221 
 222         /* Activate the adaptor at the EEPROM location. */
 223         outb(0xff, ID_PORT);
 224 
 225         EL3WINDOW(0);
 226         if (inw(ioaddr) != 0x6d50)
 227                 return -ENODEV;
 228 
 229         /* Free the interrupt so that some other card can use it. */
 230         outw(0x0f00, ioaddr + WN0_IRQ);
 231  found:
 232         dev->base_addr = ioaddr;
 233         dev->irq = irq;
 234         dev->if_port = if_port;
 235         request_region(dev->base_addr, 16,"3c509");
 236 
 237         {
 238                 const char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
 239                 printk("%s: 3c509 at %#3.3lx tag %d, %s port, address ",
 240                            dev->name, dev->base_addr, current_tag, if_names[dev->if_port]);
 241         }
 242 
 243         /* Read in the station address. */
 244         for (i = 0; i < 6; i++)
 245                 printk(" %2.2x", dev->dev_addr[i]);
 246         printk(", IRQ %d.\n", dev->irq);
 247 
 248         /* Make up a EL3-specific-data structure. */
 249         dev->priv = kmalloc(sizeof(struct el3_private), GFP_KERNEL);
 250         memset(dev->priv, 0, sizeof(struct el3_private));
 251 
 252         if (el3_debug > 0)
 253                 printk(version);
 254 
 255         /* The EL3-specific entries in the device structure. */
 256         dev->open = &el3_open;
 257         dev->hard_start_xmit = &el3_start_xmit;
 258         dev->stop = &el3_close;
 259         dev->get_stats = &el3_get_stats;
 260 #ifdef HAVE_MULTICAST
 261                 dev->set_multicast_list = &set_multicast_list;
 262 #endif
 263 
 264         /* Fill in the generic fields of the device structure. */
 265         ether_setup(dev);
 266         return 0;
 267 }
 268 
 269 /* Read a word from the EEPROM using the regular EEPROM access register.
 270    Assume that we are in register window zero.
 271  */
 272 static ushort read_eeprom(short ioaddr, int index)
     /* [previous][next][first][last][top][bottom][index][help] */
 273 {
 274         int timer;
 275 
 276         outw(EEPROM_READ + index, ioaddr + 10);
 277         /* Pause for at least 162 us. for the read to take place. */
 278         for (timer = 0; timer < 162*4 + 400; timer++)
 279                 SLOW_DOWN_IO;
 280         return inw(ioaddr + 12);
 281 }
 282 
 283 /* Read a word from the EEPROM when in the ISA ID probe state. */
 284 static ushort id_read_eeprom(int index)
     /* [previous][next][first][last][top][bottom][index][help] */
 285 {
 286         int timer, bit, word = 0;
 287 
 288         /* Issue read command, and pause for at least 162 us. for it to complete.
 289            Assume extra-fast 16Mhz bus. */
 290         outb(EEPROM_READ + index, ID_PORT);
 291 
 292         /* This should really be done by looking at one of the timer channels. */
 293         for (timer = 0; timer < 162*4 + 400; timer++)
 294                 SLOW_DOWN_IO;
 295 
 296         for (bit = 15; bit >= 0; bit--)
 297                 word = (word << 1) + (inb(ID_PORT) & 0x01);
 298 
 299         if (el3_debug > 3)
 300                 printk("  3c509 EEPROM word %d %#4.4x.\n", index, word);
 301 
 302         return word;
 303 }
 304 
 305 
 306 
 307 static int
 308 el3_open(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 309 {
 310         int ioaddr = dev->base_addr;
 311         int i;
 312 
 313         outw(TxReset, ioaddr + EL3_CMD);
 314         outw(RxReset, ioaddr + EL3_CMD);
 315         outw(SetReadZero | 0x00, ioaddr + EL3_CMD);
 316 
 317         if (request_irq(dev->irq, &el3_interrupt, 0, "3c509")) {
 318                 return -EAGAIN;
 319         }
 320 
 321         EL3WINDOW(0);
 322         if (el3_debug > 3)
 323                 printk("%s: Opening, IRQ %d      status@%x %4.4x.\n", dev->name,
 324                            dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
 325 
 326         /* Activate board: this is probably unnecessary. */
 327         outw(0x0001, ioaddr + 4);
 328 
 329         irq2dev_map[dev->irq] = dev;
 330 
 331         /* Set the IRQ line. */
 332         outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
 333 
 334         /* Set the station address in window 2 each time opened. */
 335         EL3WINDOW(2);
 336 
 337         for (i = 0; i < 6; i++)
 338                 outb(dev->dev_addr[i], ioaddr + i);
 339 
 340         if (dev->if_port == 3)
 341                 /* Start the thinnet transceiver. We should really wait 50ms...*/
 342                 outw(StartCoax, ioaddr + EL3_CMD);
 343         else if (dev->if_port == 0) {
 344                 /* 10baseT interface, enabled link beat and jabber check. */
 345                 EL3WINDOW(4);
 346                 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
 347         }
 348 
 349         /* Switch to the stats window, and clear all stats by reading. */
 350         outw(StatsDisable, ioaddr + EL3_CMD);
 351         EL3WINDOW(6);
 352         for (i = 0; i < 9; i++)
 353                 inb(ioaddr + i);
 354         inb(ioaddr + 10);
 355         inb(ioaddr + 12);
 356 
 357         /* Switch to register set 1 for normal use. */
 358         EL3WINDOW(1);
 359 
 360         /* Accept b-case and phys addr only. */
 361         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
 362         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
 363 
 364         dev->interrupt = 0;
 365         dev->tbusy = 0;
 366         dev->start = 1;
 367 
 368         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
 369         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
 370         /* Allow status bits to be seen. */
 371         outw(SetReadZero | 0xff, ioaddr + EL3_CMD);
 372         outw(AckIntr | 0x69, ioaddr + EL3_CMD); /* Ack IRQ */
 373         outw(SetIntrMask | 0x98, ioaddr + EL3_CMD); /* Set interrupt mask. */
 374 
 375         if (el3_debug > 3)
 376                 printk("%s: Opened 3c509  IRQ %d  status %4.4x.\n",
 377                            dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
 378 
 379 #ifdef MODULE
 380         MOD_INC_USE_COUNT;
 381 #endif
 382         return 0;                                       /* Always succeed */
 383 }
 384 
 385 static int
 386 el3_start_xmit(struct sk_buff *skb, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 387 {
 388         struct el3_private *lp = (struct el3_private *)dev->priv;
 389         int ioaddr = dev->base_addr;
 390 
 391         /* Transmitter timeout, serious problems. */
 392         if (dev->tbusy) {
 393                 int tickssofar = jiffies - dev->trans_start;
 394                 if (tickssofar < 10)
 395                         return 1;
 396                 printk("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
 397                            dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS));
 398                 dev->trans_start = jiffies;
 399                 /* Issue TX_RESET and TX_START commands. */
 400                 outw(TxReset, ioaddr + EL3_CMD);
 401                 outw(TxEnable, ioaddr + EL3_CMD);
 402                 dev->tbusy = 0;
 403         }
 404 
 405         if (skb == NULL) {
 406                 dev_tint(dev);
 407                 return 0;
 408         }
 409 
 410         if (skb->len <= 0)
 411                 return 0;
 412 
 413         if (el3_debug > 4) {
 414                 printk("%s: el3_start_xmit(length = %ld) called, status %4.4x.\n",
 415                            dev->name, skb->len, inw(ioaddr + EL3_STATUS));
 416         }
 417 #ifndef final_version
 418         {       /* Error-checking code, delete for 1.30. */
 419                 ushort status = inw(ioaddr + EL3_STATUS);
 420                 if (status & 0x0001             /* IRQ line active, missed one. */
 421                         && inw(ioaddr + EL3_STATUS) & 1) {                      /* Make sure. */
 422                         printk("%s: Missed interrupt, status then %04x now %04x"
 423                                    "  Tx %2.2x Rx %4.4x.\n", dev->name, status,
 424                                    inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
 425                                    inw(ioaddr + RX_STATUS));
 426                         /* Fake interrupt trigger by masking, acknowledge interrupts. */
 427                         outw(SetReadZero | 0x00, ioaddr + EL3_CMD);
 428                         outw(AckIntr | 0x69, ioaddr + EL3_CMD); /* Ack IRQ */
 429                         outw(SetReadZero | 0xff, ioaddr + EL3_CMD);
 430                 }
 431         }
 432 #endif
 433 
 434         /* Avoid timer-based retransmission conflicts. */
 435         if (set_bit(0, (void*)&dev->tbusy) != 0)
 436                 printk("%s: Transmitter access conflict.\n", dev->name);
 437         else {
 438                 /* Put out the doubleword header... */
 439                 outw(skb->len, ioaddr + TX_FIFO);
 440                 outw(0x00, ioaddr + TX_FIFO);
 441                 /* ... and the packet rounded to a doubleword. */
 442                 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 443 
 444                 dev->trans_start = jiffies;
 445                 if (inw(ioaddr + TX_FREE) > 1536) {
 446                         dev->tbusy = 0;
 447                 } else
 448                         /* Interrupt us when the FIFO has room for max-sized packet. */
 449                         outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
 450         }
 451 
 452         dev_kfree_skb (skb, FREE_WRITE);
 453 
 454         /* Clear the Tx status stack. */
 455         {
 456                 short tx_status;
 457                 int i = 4;
 458 
 459                 while (--i > 0  &&      (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 460                         if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
 461                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 462                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 463                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 464                 }
 465         }
 466         return 0;
 467 }
 468 
 469 /* The EL3 interrupt handler. */
 470 static void
 471 el3_interrupt(int irq, struct pt_regs *regs)
     /* [previous][next][first][last][top][bottom][index][help] */
 472 {
 473         struct device *dev = (struct device *)(irq2dev_map[irq]);
 474         int ioaddr, status;
 475         int i = 0;
 476 
 477         if (dev == NULL) {
 478                 printk ("el3_interrupt(): irq %d for unknown device.\n", irq);
 479                 return;
 480         }
 481 
 482         if (dev->interrupt)
 483                 printk("%s: Re-entering the interrupt handler.\n", dev->name);
 484         dev->interrupt = 1;
 485 
 486         ioaddr = dev->base_addr;
 487         status = inw(ioaddr + EL3_STATUS);
 488 
 489         if (el3_debug > 4)
 490                 printk("%s: interrupt, status %4.4x.\n", dev->name, status);
 491 
 492         while ((status = inw(ioaddr + EL3_STATUS)) & 0x91) {
 493 
 494                 if (status & 0x10)
 495                         el3_rx(dev);
 496 
 497                 if (status & 0x08) {
 498                         if (el3_debug > 5)
 499                                 printk("        TX room bit was handled.\n");
 500                         /* There's room in the FIFO for a full-sized packet. */
 501                         outw(AckIntr | 0x08, ioaddr + EL3_CMD);
 502                         dev->tbusy = 0;
 503                         mark_bh(NET_BH);
 504                 }
 505                 if (status & 0x80)                              /* Statistics full. */
 506                         update_stats(ioaddr, dev);
 507 
 508                 if (++i > 10) {
 509                         printk("%s: Infinite loop in interrupt, status %4.4x.\n",
 510                                    dev->name, status);
 511                         /* Clear all interrupts. */
 512                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 513                         break;
 514                 }
 515                 /* Acknowledge the IRQ. */
 516                 outw(AckIntr | 0x41, ioaddr + EL3_CMD); /* Ack IRQ */
 517 
 518         }
 519 
 520         if (el3_debug > 4) {
 521                 printk("%s: exiting interrupt, status %4.4x.\n", dev->name,
 522                            inw(ioaddr + EL3_STATUS));
 523         }
 524 
 525         dev->interrupt = 0;
 526         return;
 527 }
 528 
 529 
 530 static struct enet_statistics *
 531 el3_get_stats(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 532 {
 533         struct el3_private *lp = (struct el3_private *)dev->priv;
 534         unsigned long flags;
 535 
 536         save_flags(flags);
 537         cli();
 538         update_stats(dev->base_addr, dev);
 539         restore_flags(flags);
 540         return &lp->stats;
 541 }
 542 
 543 /*  Update statistics.  We change to register window 6, so this should be run
 544         single-threaded if the device is active. This is expected to be a rare
 545         operation, and it's simpler for the rest of the driver to assume that
 546         window 1 is always valid rather than use a special window-state variable.
 547         */
 548 static void update_stats(int ioaddr, struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 549 {
 550         struct el3_private *lp = (struct el3_private *)dev->priv;
 551 
 552         if (el3_debug > 5)
 553                 printk("   Updating the statistics.\n");
 554         /* Turn off statistics updates while reading. */
 555         outw(StatsDisable, ioaddr + EL3_CMD);
 556         /* Switch to the stats window, and read everything. */
 557         EL3WINDOW(6);
 558         lp->stats.tx_carrier_errors     += inb(ioaddr + 0);
 559         lp->stats.tx_heartbeat_errors   += inb(ioaddr + 1);
 560         /* Multiple collisions. */              inb(ioaddr + 2);
 561         lp->stats.collisions                    += inb(ioaddr + 3);
 562         lp->stats.tx_window_errors              += inb(ioaddr + 4);
 563         lp->stats.rx_fifo_errors                += inb(ioaddr + 5);
 564         lp->stats.tx_packets                    += inb(ioaddr + 6);
 565         /* Rx packets   */                              inb(ioaddr + 7);
 566         /* Tx deferrals */                              inb(ioaddr + 8);
 567         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
 568         inw(ioaddr + 12);
 569 
 570         /* Back to window 1, and turn statistics back on. */
 571         EL3WINDOW(1);
 572         outw(StatsEnable, ioaddr + EL3_CMD);
 573         return;
 574 }
 575 
 576 static int
 577 el3_rx(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 578 {
 579         struct el3_private *lp = (struct el3_private *)dev->priv;
 580         int ioaddr = dev->base_addr;
 581         short rx_status;
 582 
 583         if (el3_debug > 5)
 584                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
 585                            inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
 586         while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
 587                 if (rx_status & 0x4000) { /* Error, update stats. */
 588                         short error = rx_status & 0x3800;
 589                         lp->stats.rx_errors++;
 590                         switch (error) {
 591                         case 0x0000:            lp->stats.rx_over_errors++; break;
 592                         case 0x0800:            lp->stats.rx_length_errors++; break;
 593                         case 0x1000:            lp->stats.rx_frame_errors++; break;
 594                         case 0x1800:            lp->stats.rx_length_errors++; break;
 595                         case 0x2000:            lp->stats.rx_frame_errors++; break;
 596                         case 0x2800:            lp->stats.rx_crc_errors++; break;
 597                         }
 598                 } else {
 599                         short pkt_len = rx_status & 0x7ff;
 600                         struct sk_buff *skb;
 601 
 602                         skb = dev_alloc_skb(pkt_len+5);
 603                         if (el3_debug > 4)
 604                                 printk("Receiving packet size %d status %4.4x.\n",
 605                                            pkt_len, rx_status);
 606                         if (skb != NULL) {
 607                                 skb->dev = dev;
 608                                 skb_reserve(skb,2);     /* Align IP on 16 byte boundaries */
 609 
 610                                 /* 'skb->data' points to the start of sk_buff data area. */
 611                                 insl(ioaddr+RX_FIFO, skb_put(skb,pkt_len),
 612                                                         (pkt_len + 3) >> 2);
 613 
 614                                 skb->protocol=eth_type_trans(skb,dev);
 615                                 netif_rx(skb);
 616                                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
 617                                 lp->stats.rx_packets++;
 618                                 continue;
 619                         } else if (el3_debug)
 620                                 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
 621                                            dev->name, pkt_len);
 622                 }
 623                 lp->stats.rx_dropped++;
 624                 outw(RxDiscard, ioaddr + EL3_CMD);
 625                 while (inw(ioaddr + EL3_STATUS) & 0x1000)
 626                         printk("        Waiting for 3c509 to discard packet, status %x.\n",
 627                                    inw(ioaddr + EL3_STATUS) );
 628         }
 629 
 630         return 0;
 631 }
 632 
 633 #ifdef HAVE_MULTICAST
 634 /* Set or clear the multicast filter for this adaptor.
 635    num_addrs == -1              Promiscuous mode, receive all packets
 636    num_addrs == 0               Normal mode, clear multicast list
 637    num_addrs > 0                Multicast mode, receive normal and MC packets, and do
 638                                                 best-effort filtering.
 639  */
 640 static void
 641 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
     /* [previous][next][first][last][top][bottom][index][help] */
 642 {
 643         short ioaddr = dev->base_addr;
 644         if (el3_debug > 1) {
 645                 static int old = 0;
 646                 if (old != num_addrs) {
 647                         old = num_addrs;
 648                         printk("%s: Setting Rx mode to %d addresses.\n", dev->name, num_addrs);
 649                 }
 650         }
 651         if (num_addrs > 0) {
 652                 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
 653         } else if (num_addrs < 0) {
 654                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
 655                          ioaddr + EL3_CMD);
 656         } else
 657                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
 658 }
 659 #endif
 660 
 661 static int
 662 el3_close(struct device *dev)
     /* [previous][next][first][last][top][bottom][index][help] */
 663 {
 664         int ioaddr = dev->base_addr;
 665 
 666         if (el3_debug > 2)
 667                 printk("%s: Shutting down ethercard.\n", dev->name);
 668 
 669         dev->tbusy = 1;
 670         dev->start = 0;
 671 
 672         /* Turn off statistics ASAP.  We update lp->stats below. */
 673         outw(StatsDisable, ioaddr + EL3_CMD);
 674 
 675         /* Disable the receiver and transmitter. */
 676         outw(RxDisable, ioaddr + EL3_CMD);
 677         outw(TxDisable, ioaddr + EL3_CMD);
 678 
 679         if (dev->if_port == 3)
 680                 /* Turn off thinnet power.  Green! */
 681                 outw(StopCoax, ioaddr + EL3_CMD);
 682         else if (dev->if_port == 0) {
 683                 /* Disable link beat and jabber, if_port may change ere next open(). */
 684                 EL3WINDOW(4);
 685                 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
 686         }
 687 
 688         free_irq(dev->irq);
 689         /* Switching back to window 0 disables the IRQ. */
 690         EL3WINDOW(0);
 691         /* But we explicitly zero the IRQ line select anyway. */
 692         outw(0x0f00, ioaddr + WN0_IRQ);
 693 
 694 
 695         irq2dev_map[dev->irq] = 0;
 696 
 697         update_stats(ioaddr, dev);
 698 #ifdef MODULE
 699         MOD_DEC_USE_COUNT;
 700 #endif
 701         return 0;
 702 }
 703 
 704 #ifdef MODULE
 705 char kernel_version[] = UTS_RELEASE;
 706 static struct device dev_3c509 = {
 707         "        " /*"3c509"*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, el3_probe };
 708 
 709 int io = 0;
 710 int irq = 0;
 711 
 712 int
 713 init_module(void)
     /* [previous][next][first][last][top][bottom][index][help] */
 714 {
 715         dev_3c509.base_addr = io;
 716         dev_3c509.irq       = irq;
 717         if (!EISA_bus) {
 718                 printk("3c509: WARNING! Module load-time probing works reliably only for EISA-bus!\n");
 719         }
 720         if (register_netdev(&dev_3c509) != 0)
 721                 return -EIO;
 722         return 0;
 723 }
 724 
 725 void
 726 cleanup_module(void)
     /* [previous][next][first][last][top][bottom][index][help] */
 727 {
 728         if (MOD_IN_USE)
 729                 printk("3c509: device busy, remove delayed\n");
 730         else
 731         {
 732                 unregister_netdev(&dev_3c509);
 733                 kfree_s(dev_3c509.priv,sizeof(struct el3_private));
 734                 dev_3c509.priv=NULL;
 735         }
 736 }
 737 #endif /* MODULE */
 738 
 739 /*
 740  * Local variables:
 741  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 3c509.c"
 742  *  version-control: t
 743  *  kept-new-versions: 5
 744  *  tab-width: 4
 745  * End:
 746  */

/* [previous][next][first][last][top][bottom][index][help] */