home *** CD-ROM | disk | FTP | other *** search
/ Il CD di internet / CD.iso / SOURCE / KERNEL-S / V1.2 / LINUX-1.2 / LINUX-1 / linux / drivers / net / 3c509.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-02-15  |  20.0 KB  |  730 lines
  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 = alloc_skb(pkt_len+3, GFP_ATOMIC);
  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->len = pkt_len;
  600.                 skb->dev = dev;
  601.  
  602.                 /* 'skb->data' points to the start of sk_buff data area. */
  603.                 insl(ioaddr+RX_FIFO, skb->data,
  604.                             (pkt_len + 3) >> 2);
  605.  
  606.                 netif_rx(skb);
  607.                 outw(RxDiscard, ioaddr + EL3_CMD); /* Pop top Rx packet. */
  608.                 lp->stats.rx_packets++;
  609.                 continue;
  610.             } else if (el3_debug)
  611.                 printk("%s: Couldn't allocate a sk_buff of size %d.\n",
  612.                        dev->name, pkt_len);
  613.         }
  614.         lp->stats.rx_dropped++;
  615.         outw(RxDiscard, ioaddr + EL3_CMD);
  616.         while (inw(ioaddr + EL3_STATUS) & 0x1000)
  617.             printk("    Waiting for 3c509 to discard packet, status %x.\n",
  618.                    inw(ioaddr + EL3_STATUS) );
  619.     }
  620.  
  621.     return 0;
  622. }
  623.  
  624. #ifdef HAVE_MULTICAST
  625. /* Set or clear the multicast filter for this adaptor.
  626.    num_addrs == -1        Promiscuous mode, receive all packets
  627.    num_addrs == 0        Normal mode, clear multicast list
  628.    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
  629.                         best-effort filtering.
  630.  */
  631. static void
  632. set_multicast_list(struct device *dev, int num_addrs, void *addrs)
  633. {
  634.     short ioaddr = dev->base_addr;
  635.     if (el3_debug > 1) {
  636.         static int old = 0;
  637.         if (old != num_addrs) {
  638.             old = num_addrs;
  639.             printk("%s: Setting Rx mode to %d addresses.\n", dev->name, num_addrs);
  640.         }
  641.     }
  642.     if (num_addrs > 0) {
  643.         outw(SetRxFilter|RxStation|RxMulticast|RxBroadcast, ioaddr + EL3_CMD);
  644.     } else if (num_addrs < 0) {
  645.         outw(SetRxFilter | RxStation | RxMulticast | RxBroadcast | RxProm,
  646.              ioaddr + EL3_CMD);
  647.     } else
  648.         outw(SetRxFilter | RxStation | RxBroadcast, ioaddr + EL3_CMD);
  649. }
  650. #endif
  651.  
  652. static int
  653. el3_close(struct device *dev)
  654. {
  655.     int ioaddr = dev->base_addr;
  656.  
  657.     if (el3_debug > 2)
  658.         printk("%s: Shutting down ethercard.\n", dev->name);
  659.  
  660.     dev->tbusy = 1;
  661.     dev->start = 0;
  662.  
  663.     /* Turn off statistics ASAP.  We update lp->stats below. */
  664.     outw(StatsDisable, ioaddr + EL3_CMD);
  665.  
  666.     /* Disable the receiver and transmitter. */
  667.     outw(RxDisable, ioaddr + EL3_CMD);
  668.     outw(TxDisable, ioaddr + EL3_CMD);
  669.  
  670.     if (dev->if_port == 3)
  671.         /* Turn off thinnet power.  Green! */
  672.         outw(StopCoax, ioaddr + EL3_CMD);
  673.     else if (dev->if_port == 0) {
  674.         /* Disable link beat and jabber, if_port may change ere next open(). */
  675.         EL3WINDOW(4);
  676.         outw(inw(ioaddr + WN4_MEDIA) & ~MEDIA_TP, ioaddr + WN4_MEDIA);
  677.     }
  678.  
  679.     free_irq(dev->irq);
  680.     /* Switching back to window 0 disables the IRQ. */
  681.     EL3WINDOW(0);
  682.     /* But we explicitly zero the IRQ line select anyway. */
  683.     outw(0x0f00, ioaddr + WN0_IRQ);
  684.  
  685.  
  686.     irq2dev_map[dev->irq] = 0;
  687.  
  688.     update_stats(ioaddr, dev);
  689. #ifdef MODULE
  690.     MOD_DEC_USE_COUNT;
  691. #endif
  692.     return 0;
  693. }
  694.  
  695. #ifdef MODULE
  696. char kernel_version[] = UTS_RELEASE;
  697. static struct device dev_3c509 = {
  698.     "        " /*"3c509"*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, el3_probe };
  699.  
  700. int
  701. init_module(void)
  702. {
  703.     if (register_netdev(&dev_3c509) != 0)
  704.         return -EIO;
  705.     return 0;
  706. }
  707.  
  708. void
  709. cleanup_module(void)
  710. {
  711.     if (MOD_IN_USE)
  712.         printk("3c509: device busy, remove delayed\n");
  713.     else
  714.     {
  715.         unregister_netdev(&dev_3c509);
  716.         kfree_s(dev_3c509.priv,sizeof(struct el3_private));
  717.         dev_3c509.priv=NULL;
  718.     }
  719. }
  720. #endif /* MODULE */
  721.  
  722. /*
  723.  * Local variables:
  724.  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 3c509.c"
  725.  *  version-control: t
  726.  *  kept-new-versions: 5
  727.  *  tab-width: 4
  728.  * End:
  729.  */
  730.