drivers/net/3c509.c

/* */
This source file includes following definitions.
el3_probe
read_eeprom
id_read_eeprom
el3_open
el3_start_xmit
el3_interrupt
el3_get_stats
update_stats
el3_rx
set_multicast_list
el3_close
init_module
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 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)
     /*  */
 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         outb(0x00, ID_PORT);
 175         outb(0x00, ID_PORT);
 176         for(i = 0; i < 255; i++) {
 177                 outb(lrs_state, ID_PORT);
 178                 lrs_state <<= 1;
 179                 lrs_state = lrs_state & 0x100 ? lrs_state ^ 0xcf : lrs_state;
 180         }
 181 
 182         /* For the first probe, clear all board's tag registers. */
 183         if (current_tag == 0)
 184                 outb(0xd0, ID_PORT);
 185         else                            /* Otherwise kill off already-found boards. */
 186                 outb(0xd8, ID_PORT);
 187 
 188         if (id_read_eeprom(7) != 0x6d50) {
 189                 return -ENODEV;
 190         }
 191 
 192         /* Read in EEPROM data, which does contention-select.
 193            Only the lowest address board will stay "on-line".
 194            3Com got the byte order backwards. */
 195         for (i = 0; i < 3; i++) {
 196                 phys_addr[i] = htons(id_read_eeprom(i));
 197         }
 198 
 199         {
 200                 unsigned short iobase = id_read_eeprom(8);
 201                 if_port = iobase >> 14;
 202                 ioaddr = 0x200 + ((iobase & 0x1f) << 4);
 203         }
 204         irq = id_read_eeprom(9) >> 12;
 205 
 206         if (dev->base_addr != 0
 207                 &&      dev->base_addr != (unsigned short)ioaddr) {
 208                 return -ENODEV;
 209         }
 210 
 211         /* Set the adaptor tag so that the next card can be found. */
 212         outb(0xd0 + ++current_tag, ID_PORT);
 213 
 214         /* Activate the adaptor at the EEPROM location. */
 215         outb(0xff, ID_PORT);
 216 
 217         EL3WINDOW(0);
 218         if (inw(ioaddr) != 0x6d50)
 219                 return -ENODEV;
 220 
 221         /* Free the interrupt so that some other card can use it. */
 222         outw(0x0f00, ioaddr + WN0_IRQ);
 223  found:
 224         dev->base_addr = ioaddr;
 225         dev->irq = irq;
 226         dev->if_port = if_port;
 227         request_region(dev->base_addr, 16,"3c509");
 228 
 229         {
 230                 char *if_names[] = {"10baseT", "AUI", "undefined", "BNC"};
 231                 printk("%s: 3c509 at %#3.3lx tag %d, %s port, address ",
 232                            dev->name, dev->base_addr, current_tag, if_names[dev->if_port]);
 233         }
 234 
 235         /* Read in the station address. */
 236         for (i = 0; i < 6; i++)
 237                 printk(" %2.2x", dev->dev_addr[i]);
 238         printk(", IRQ %d.\n", dev->irq);
 239 
 240         /* Make up a EL3-specific-data structure. */
 241         dev->priv = kmalloc(sizeof(struct el3_private), GFP_KERNEL);
 242         memset(dev->priv, 0, sizeof(struct el3_private));
 243 
 244         if (el3_debug > 0)
 245                 printk(version);
 246 
 247         /* The EL3-specific entries in the device structure. */
 248         dev->open = &el3_open;
 249         dev->hard_start_xmit = &el3_start_xmit;
 250         dev->stop = &el3_close;
 251         dev->get_stats = &el3_get_stats;
 252 #ifdef HAVE_MULTICAST
 253                 dev->set_multicast_list = &set_multicast_list;
 254 #endif
 255 
 256         /* Fill in the generic fields of the device structure. */
 257         ether_setup(dev);
 258         return 0;
 259 }
 260 
 261 /* Read a word from the EEPROM using the regular EEPROM access register.
 262    Assume that we are in register window zero.
 263  */
 264 static ushort read_eeprom(short ioaddr, int index)
     /*  */
 265 {
 266         int timer;
 267 
 268         outw(EEPROM_READ + index, ioaddr + 10);
 269         /* Pause for at least 162 us. for the read to take place. */
 270         for (timer = 0; timer < 162*4 + 400; timer++)
 271                 SLOW_DOWN_IO;
 272         return inw(ioaddr + 12);
 273 }
 274 
 275 /* Read a word from the EEPROM when in the ISA ID probe state. */
 276 static ushort id_read_eeprom(int index)
     /*  */
 277 {
 278         int timer, bit, word = 0;
 279 
 280         /* Issue read command, and pause for at least 162 us. for it to complete.
 281            Assume extra-fast 16Mhz bus. */
 282         outb(EEPROM_READ + index, ID_PORT);
 283 
 284         /* This should really be done by looking at one of the timer channels. */
 285         for (timer = 0; timer < 162*4 + 400; timer++)
 286                 SLOW_DOWN_IO;
 287 
 288         for (bit = 15; bit >= 0; bit--)
 289                 word = (word << 1) + (inb(ID_PORT) & 0x01);
 290 
 291         if (el3_debug > 3)
 292                 printk("  3c509 EEPROM word %d %#4.4x.\n", index, word);
 293 
 294         return word;
 295 }
 296 
 297 
 298 
 299 static int
 300 el3_open(struct device *dev)
     /*  */
 301 {
 302         int ioaddr = dev->base_addr;
 303         int i;
 304 
 305         outw(TxReset, ioaddr + EL3_CMD);
 306         outw(RxReset, ioaddr + EL3_CMD);
 307         outw(SetReadZero | 0x00, ioaddr + EL3_CMD);
 308 
 309         if (request_irq(dev->irq, &el3_interrupt, 0, "3c509")) {
 310                 return -EAGAIN;
 311         }
 312 
 313         EL3WINDOW(0);
 314         if (el3_debug > 3)
 315                 printk("%s: Opening, IRQ %d      status@%x %4.4x.\n", dev->name,
 316                            dev->irq, ioaddr + EL3_STATUS, inw(ioaddr + EL3_STATUS));
 317 
 318         /* Activate board: this is probably unnecessary. */
 319         outw(0x0001, ioaddr + 4);
 320 
 321         irq2dev_map[dev->irq] = dev;
 322 
 323         /* Set the IRQ line. */
 324         outw((dev->irq << 12) | 0x0f00, ioaddr + WN0_IRQ);
 325 
 326         /* Set the station address in window 2 each time opened. */
 327         EL3WINDOW(2);
 328 
 329         for (i = 0; i < 6; i++)
 330                 outb(dev->dev_addr[i], ioaddr + i);
 331 
 332         if (dev->if_port == 3)
 333                 /* Start the thinnet transceiver. We should really wait 50ms...*/
 334                 outw(StartCoax, ioaddr + EL3_CMD);
 335         else if (dev->if_port == 0) {
 336                 /* 10baseT interface, enabled link beat and jabber check. */
 337                 EL3WINDOW(4);
 338                 outw(inw(ioaddr + WN4_MEDIA) | MEDIA_TP, ioaddr + WN4_MEDIA);
 339         }
 340 
 341         /* Switch to the stats window, and clear all stats by reading. */
 342         outw(StatsDisable, ioaddr + EL3_CMD);
 343         EL3WINDOW(6);
 344         for (i = 0; i < 9; i++)
 345                 inb(ioaddr + i);
 346         inb(ioaddr + 10);
 347         inb(ioaddr + 12);
 348 
 349         /* Switch to register set 1 for normal use. */
 350         EL3WINDOW(1);
 351 
 352         /* Accept b-case and phys addr only. */
 353         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
 354         outw(StatsEnable, ioaddr + EL3_CMD); /* Turn on statistics. */
 355 
 356         dev->interrupt = 0;
 357         dev->tbusy = 0;
 358         dev->start = 1;
 359 
 360         outw(RxEnable, ioaddr + EL3_CMD); /* Enable the receiver. */
 361         outw(TxEnable, ioaddr + EL3_CMD); /* Enable transmitter. */
 362         /* Allow status bits to be seen. */
 363         outw(SetReadZero | 0xff, ioaddr + EL3_CMD);
 364         outw(AckIntr | 0x69, ioaddr + EL3_CMD); /* Ack IRQ */
 365         outw(SetIntrMask | 0x98, ioaddr + EL3_CMD); /* Set interrupt mask. */
 366 
 367         if (el3_debug > 3)
 368                 printk("%s: Opened 3c509  IRQ %d  status %4.4x.\n",
 369                            dev->name, dev->irq, inw(ioaddr + EL3_STATUS));
 370 
 371 #ifdef MODULE
 372         MOD_INC_USE_COUNT;
 373 #endif
 374         return 0;                                       /* Always succeed */
 375 }
 376 
 377 static int
 378 el3_start_xmit(struct sk_buff *skb, struct device *dev)
     /*  */
 379 {
 380         struct el3_private *lp = (struct el3_private *)dev->priv;
 381         int ioaddr = dev->base_addr;
 382 
 383         /* Transmitter timeout, serious problems. */
 384         if (dev->tbusy) {
 385                 int tickssofar = jiffies - dev->trans_start;
 386                 if (tickssofar < 10)
 387                         return 1;
 388                 printk("%s: transmit timed out, tx_status %2.2x status %4.4x.\n",
 389                            dev->name, inb(ioaddr + TX_STATUS), inw(ioaddr + EL3_STATUS));
 390                 dev->trans_start = jiffies;
 391                 /* Issue TX_RESET and TX_START commands. */
 392                 outw(TxReset, ioaddr + EL3_CMD);
 393                 outw(TxEnable, ioaddr + EL3_CMD);
 394                 dev->tbusy = 0;
 395         }
 396 
 397         if (skb == NULL) {
 398                 dev_tint(dev);
 399                 return 0;
 400         }
 401 
 402         if (skb->len <= 0)
 403                 return 0;
 404 
 405         if (el3_debug > 4) {
 406                 printk("%s: el3_start_xmit(length = %ld) called, status %4.4x.\n",
 407                            dev->name, skb->len, inw(ioaddr + EL3_STATUS));
 408         }
 409 #ifndef final_version
 410         {       /* Error-checking code, delete for 1.30. */
 411                 ushort status = inw(ioaddr + EL3_STATUS);
 412                 if (status & 0x0001             /* IRQ line active, missed one. */
 413                         && inw(ioaddr + EL3_STATUS) & 1) {                      /* Make sure. */
 414                         printk("%s: Missed interrupt, status then %04x now %04x"
 415                                    "  Tx %2.2x Rx %4.4x.\n", dev->name, status,
 416                                    inw(ioaddr + EL3_STATUS), inb(ioaddr + TX_STATUS),
 417                                    inw(ioaddr + RX_STATUS));
 418                         /* Fake interrupt trigger by masking, acknowledge interrupts. */
 419                         outw(SetReadZero | 0x00, ioaddr + EL3_CMD);
 420                         outw(AckIntr | 0x69, ioaddr + EL3_CMD); /* Ack IRQ */
 421                         outw(SetReadZero | 0xff, ioaddr + EL3_CMD);
 422                 }
 423         }
 424 #endif
 425 
 426         /* Avoid timer-based retransmission conflicts. */
 427         if (set_bit(0, (void*)&dev->tbusy) != 0)
 428                 printk("%s: Transmitter access conflict.\n", dev->name);
 429         else {
 430                 /* Put out the doubleword header... */
 431                 outw(skb->len, ioaddr + TX_FIFO);
 432                 outw(0x00, ioaddr + TX_FIFO);
 433                 /* ... and the packet rounded to a doubleword. */
 434                 outsl(ioaddr + TX_FIFO, skb->data, (skb->len + 3) >> 2);
 435 
 436                 dev->trans_start = jiffies;
 437                 if (inw(ioaddr + TX_FREE) > 1536) {
 438                         dev->tbusy = 0;
 439                 } else
 440                         /* Interrupt us when the FIFO has room for max-sized packet. */
 441                         outw(SetTxThreshold + 1536, ioaddr + EL3_CMD);
 442         }
 443 
 444         dev_kfree_skb (skb, FREE_WRITE);
 445 
 446         /* Clear the Tx status stack. */
 447         {
 448                 short tx_status;
 449                 int i = 4;
 450 
 451                 while (--i > 0  &&      (tx_status = inb(ioaddr + TX_STATUS)) > 0) {
 452                         if (tx_status & 0x38) lp->stats.tx_aborted_errors++;
 453                         if (tx_status & 0x30) outw(TxReset, ioaddr + EL3_CMD);
 454                         if (tx_status & 0x3C) outw(TxEnable, ioaddr + EL3_CMD);
 455                         outb(0x00, ioaddr + TX_STATUS); /* Pop the status stack. */
 456                 }
 457         }
 458         return 0;
 459 }
 460 
 461 /* The EL3 interrupt handler. */
 462 static void
 463 el3_interrupt(int irq, struct pt_regs *regs)
     /*  */
 464 {
 465         struct device *dev = (struct device *)(irq2dev_map[irq]);
 466         int ioaddr, status;
 467         int i = 0;
 468 
 469         if (dev == NULL) {
 470                 printk ("el3_interrupt(): irq %d for unknown device.\n", irq);
 471                 return;
 472         }
 473 
 474         if (dev->interrupt)
 475                 printk("%s: Re-entering the interrupt handler.\n", dev->name);
 476         dev->interrupt = 1;
 477 
 478         ioaddr = dev->base_addr;
 479         status = inw(ioaddr + EL3_STATUS);
 480 
 481         if (el3_debug > 4)
 482                 printk("%s: interrupt, status %4.4x.\n", dev->name, status);
 483 
 484         while ((status = inw(ioaddr + EL3_STATUS)) & 0x91) {
 485 
 486                 if (status & 0x10)
 487                         el3_rx(dev);
 488 
 489                 if (status & 0x08) {
 490                         if (el3_debug > 5)
 491                                 printk("        TX room bit was handled.\n");
 492                         /* There's room in the FIFO for a full-sized packet. */
 493                         outw(AckIntr | 0x08, ioaddr + EL3_CMD);
 494                         dev->tbusy = 0;
 495                         mark_bh(NET_BH);
 496                 }
 497                 if (status & 0x80)                              /* Statistics full. */
 498                         update_stats(ioaddr, dev);
 499 
 500                 if (++i > 10) {
 501                         printk("%s: Infinite loop in interrupt, status %4.4x.\n",
 502                                    dev->name, status);
 503                         /* Clear all interrupts. */
 504                         outw(AckIntr | 0xFF, ioaddr + EL3_CMD);
 505                         break;
 506                 }
 507                 /* Acknowledge the IRQ. */
 508                 outw(AckIntr | 0x41, ioaddr + EL3_CMD); /* Ack IRQ */
 509 
 510         }
 511 
 512         if (el3_debug > 4) {
 513                 printk("%s: exiting interrupt, status %4.4x.\n", dev->name,
 514                            inw(ioaddr + EL3_STATUS));
 515         }
 516 
 517         dev->interrupt = 0;
 518         return;
 519 }
 520 
 521 
 522 static struct enet_statistics *
 523 el3_get_stats(struct device *dev)
     /*  */
 524 {
 525         struct el3_private *lp = (struct el3_private *)dev->priv;
 526         unsigned long flags;
 527 
 528         save_flags(flags);
 529         cli();
 530         update_stats(dev->base_addr, dev);
 531         restore_flags(flags);
 532         return &lp->stats;
 533 }
 534 
 535 /*  Update statistics.  We change to register window 6, so this should be run
 536         single-threaded if the device is active. This is expected to be a rare
 537         operation, and it's simpler for the rest of the driver to assume that
 538         window 1 is always valid rather than use a special window-state variable.
 539         */
 540 static void update_stats(int ioaddr, struct device *dev)
     /*  */
 541 {
 542         struct el3_private *lp = (struct el3_private *)dev->priv;
 543 
 544         if (el3_debug > 5)
 545                 printk("   Updating the statistics.\n");
 546         /* Turn off statistics updates while reading. */
 547         outw(StatsDisable, ioaddr + EL3_CMD);
 548         /* Switch to the stats window, and read everything. */
 549         EL3WINDOW(6);
 550         lp->stats.tx_carrier_errors     += inb(ioaddr + 0);
 551         lp->stats.tx_heartbeat_errors   += inb(ioaddr + 1);
 552         /* Multiple collisions. */              inb(ioaddr + 2);
 553         lp->stats.collisions                    += inb(ioaddr + 3);
 554         lp->stats.tx_window_errors              += inb(ioaddr + 4);
 555         lp->stats.rx_fifo_errors                += inb(ioaddr + 5);
 556         lp->stats.tx_packets                    += inb(ioaddr + 6);
 557         /* Rx packets   */                              inb(ioaddr + 7);
 558         /* Tx deferrals */                              inb(ioaddr + 8);
 559         inw(ioaddr + 10);       /* Total Rx and Tx octets. */
 560         inw(ioaddr + 12);
 561 
 562         /* Back to window 1, and turn statistics back on. */
 563         EL3WINDOW(1);
 564         outw(StatsEnable, ioaddr + EL3_CMD);
 565         return;
 566 }
 567 
 568 static int
 569 el3_rx(struct device *dev)
     /*  */
 570 {
 571         struct el3_private *lp = (struct el3_private *)dev->priv;
 572         int ioaddr = dev->base_addr;
 573         short rx_status;
 574 
 575         if (el3_debug > 5)
 576                 printk("   In rx_packet(), status %4.4x, rx_status %4.4x.\n",
 577                            inw(ioaddr+EL3_STATUS), inw(ioaddr+RX_STATUS));
 578         while ((rx_status = inw(ioaddr + RX_STATUS)) > 0) {
 579                 if (rx_status & 0x4000) { /* Error, update stats. */
 580                         short error = rx_status & 0x3800;
 581                         lp->stats.rx_errors++;
 582                         switch (error) {
 583                         case 0x0000:            lp->stats.rx_over_errors++; break;
 584                         case 0x0800:            lp->stats.rx_length_errors++; break;
 585                         case 0x1000:            lp->stats.rx_frame_errors++; break;
 586                         case 0x1800:            lp->stats.rx_length_errors++; break;
 587                         case 0x2000:            lp->stats.rx_frame_errors++; break;
 588                         case 0x2800:            lp->stats.rx_crc_errors++; break;
 589                         }
 590                 } else {
 591                         short pkt_len = rx_status & 0x7ff;
 592                         struct sk_buff *skb;
 593 
 594                         skb = dev_alloc_skb(pkt_len+5);
 595                         if (el3_debug > 4)
 596                                 printk("Receiving packet size %d status %4.4x.\n",
 597                                            pkt_len, rx_status);
 598                         if (skb != NULL) {
 599                                 skb->dev = dev;
 600                                 skb_reserve(skb,2);     /* Align IP on 16 byte boundaries */
 601 
 602                                 /* 'skb->data' points to the start of sk_buff data area. */
 603                                 insl(ioaddr+RX_FIFO, skb_put(skb,pkt_len),
 604                                                         (pkt_len + 3) >> 2);
 605 
 606                                 skb->protocol=eth_type_trans(skb,dev);
 607                                 netif_rx(skb);
 608                                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
 609                                 lp->stats.rx_packets++;
 610                                 continue;
 611                         } else if (el3_debug)
 612                                 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
 613                                            dev->name, pkt_len);
 614                 }
 615                 lp->stats.rx_dropped++;
 616                 outw(RxDiscard, ioaddr + EL3_CMD);
 617                 while (inw(ioaddr + EL3_STATUS) & 0x1000)
 618                         printk("        Waiting for 3c509 to discard packet, status %x.\n",
 619                                    inw(ioaddr + EL3_STATUS) );
 620         }
 621 
 622         return 0;
 623 }
 624 
 625 #ifdef HAVE_MULTICAST
 626 /* Set or clear the multicast filter for this adaptor.
 627    num_addrs == -1              Promiscuous mode, receive all packets
 628    num_addrs == 0               Normal mode, clear multicast list
 629    num_addrs > 0                Multicast mode, receive normal and MC packets, and do
 630                                                 best-effort filtering.
 631  */
 632 static void
 633 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
     /*  */
 634 {
 635         short ioaddr = dev->base_addr;
 636         if (el3_debug > 1) {
 637                 static int old = 0;
 638                 if (old != num_addrs) {
 639                         old = num_addrs;
 640                         printk("%s: Setting Rx mode to %d addresses.\n", dev->name, num_addrs);
 641                 }
 642         }
 643         if (num_addrs > 0) {
 644                 outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
 645         } else if (num_addrs < 0) {
 646                 outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
 647                          ioaddr + EL3_CMD);
 648         } else
 649                 outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
 650 }
 651 #endif
 652 
 653 static int
 654 el3_close(struct device *dev)
     /*  */
 655 {
 656         int ioaddr = dev->base_addr;
 657 
 658         if (el3_debug > 2)
 659                 printk("%s: Shutting down ethercard.\n", dev->name);
 660 
 661         dev->tbusy = 1;
 662         dev->start = 0;
 663 
 664         /* Turn off statistics ASAP.  We update lp->stats below. */
 665         outw(StatsDisable, ioaddr + EL3_CMD);
 666 
 667         /* Disable the receiver and transmitter. */
 668         outw(RxDisable, ioaddr + EL3_CMD);
 669         outw(TxDisable, ioaddr + EL3_CMD);
 670 
 671         if (dev->if_port == 3)
 672                 /* Turn off thinnet power.  Green! */
 673                 outw(StopCoax, ioaddr + EL3_CMD);
 674         else if (dev->if_port == 0) {
 675                 /* Disable link beat and jabber, if_port may change ere next open(). */
 676                 EL3WINDOW(4);
 677                 outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
 678         }
 679 
 680         free_irq(dev->irq);
 681         /* Switching back to window 0 disables the IRQ. */
 682         EL3WINDOW(0);
 683         /* But we explicitly zero the IRQ line select anyway. */
 684         outw(0x0f00, ioaddr + WN0_IRQ);
 685 
 686 
 687         irq2dev_map[dev->irq] = 0;
 688 
 689         update_stats(ioaddr, dev);
 690 #ifdef MODULE
 691         MOD_DEC_USE_COUNT;
 692 #endif
 693         return 0;
 694 }
 695 
 696 #ifdef MODULE
 697 char kernel_version[] = UTS_RELEASE;
 698 static struct device dev_3c509 = {
 699         "        " /*"3c509"*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, el3_probe };
 700 
 701 int
 702 init_module(void)
     /*  */
 703 {
 704         if (register_netdev(&dev_3c509) != 0)
 705                 return -EIO;
 706         return 0;
 707 }
 708 
 709 void
 710 cleanup_module(void)
     /*  */
 711 {
 712         if (MOD_IN_USE)
 713                 printk("3c509: device busy, remove delayed\n");
 714         else
 715         {
 716                 unregister_netdev(&dev_3c509);
 717                 kfree_s(dev_3c509.priv,sizeof(struct el3_private));
 718                 dev_3c509.priv=NULL;
 719         }
 720 }
 721 #endif /* MODULE */
 722 
 723 /*
 724  * Local variables:
 725  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 3c509.c"
 726  *  version-control: t
 727  *  kept-new-versions: 5
 728  *  tab-width: 4
 729  * End:
 730  */
/* */
root/drivers/net/3c509.c

DEFINITIONS
