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 / 8390.c < prev    next >
Encoding:
C/C++ Source or Header  |  1995-01-23  |  23.0 KB  |  708 lines
  1. /* 8390.c: A general NS8390 ethernet driver core for linux. */
  2. /*
  3.     Written 1992-94 by Donald Becker.
  4.   
  5.     Copyright 1993 United States Government as represented by the
  6.     Director, National Security Agency.
  7.  
  8.     This software may be used and distributed according to the terms
  9.     of the GNU Public License, incorporated herein by reference.
  10.  
  11.     The author may be reached as becker@CESDIS.gsfc.nasa.gov, or C/O
  12.     Center of Excellence in Space Data and Information Sciences
  13.        Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771
  14.   
  15.   This is the chip-specific code for many 8390-based ethernet adaptors.
  16.   This is not a complete driver, it must be combined with board-specific
  17.   code such as ne.c, wd.c, 3c503.c, etc.
  18.   */
  19.  
  20. static char *version =
  21.     "8390.c:v1.10 9/23/94 Donald Becker (becker@cesdis.gsfc.nasa.gov)\n";
  22.  
  23. /*
  24.   Braindamage remaining:
  25.   Much of this code should have been cleaned up, but every attempt 
  26.   has broken some clone part.
  27.   
  28.   Sources:
  29.   The National Semiconductor LAN Databook, and the 3Com 3c503 databook.
  30.   */
  31.  
  32. #ifdef MODULE
  33. #include <linux/module.h>
  34. #include <linux/version.h>
  35. #endif
  36.  
  37. #include <linux/kernel.h>
  38. #include <linux/sched.h>
  39. #include <linux/fs.h>
  40. #include <linux/types.h>
  41. #include <linux/ptrace.h>
  42. #include <linux/string.h>
  43. #include <asm/system.h>
  44. #include <asm/segment.h>
  45. #include <asm/bitops.h>
  46. #include <asm/io.h>
  47. #include <linux/errno.h>
  48. #include <linux/fcntl.h>
  49. #include <linux/in.h>
  50. #include <linux/interrupt.h>
  51.  
  52. #include <linux/netdevice.h>
  53. #include <linux/etherdevice.h>
  54. #include <linux/skbuff.h>
  55.  
  56. #include "8390.h"
  57.  
  58. /* These are the operational function interfaces to board-specific
  59.    routines.
  60.     void reset_8390(struct device *dev)
  61.         Resets the board associated with DEV, including a hardware reset of
  62.         the 8390.  This is only called when there is a transmit timeout, and
  63.         it is always followed by 8390_init().
  64.     void block_output(struct device *dev, int count, const unsigned char *buf,
  65.                       int start_page)
  66.         Write the COUNT bytes of BUF to the packet buffer at START_PAGE.  The
  67.         "page" value uses the 8390's 256-byte pages.
  68.     int block_input(struct device *dev, int count, char *buf, int ring_offset)
  69.         Read COUNT bytes from the packet buffer into BUF.  Start reading from
  70.         RING_OFFSET, the address as the 8390 sees it.  The first read will
  71.         always be the 4 byte, page aligned 8390 header.  *If* there is a
  72.         subsequent read, it will be of the rest of the packet.
  73. */
  74. #define ei_reset_8390 (ei_local->reset_8390)
  75. #define ei_block_output (ei_local->block_output)
  76. #define ei_block_input (ei_local->block_input)
  77.  
  78. /* use 0 for production, 1 for verification, >2 for debug */
  79. #ifdef EI_DEBUG
  80. int ei_debug = EI_DEBUG;
  81. #else
  82. int ei_debug = 1;
  83. #endif
  84.  
  85. /* Max number of packets received at one Intr.
  86.    Current this may only be examined by a kernel debugger. */
  87. static int high_water_mark = 0;
  88.  
  89. /* Index to functions. */
  90. static void ei_tx_intr(struct device *dev);
  91. static void ei_receive(struct device *dev);
  92. static void ei_rx_overrun(struct device *dev);
  93.  
  94. /* Routines generic to NS8390-based boards. */
  95. static void NS8390_trigger_send(struct device *dev, unsigned int length,
  96.                                 int start_page);
  97. #ifdef HAVE_MULTICAST
  98. static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
  99. #endif
  100.  
  101.  
  102. /* Open/initialize the board.  This routine goes all-out, setting everything
  103.    up anew at each open, even though many of these registers should only
  104.    need to be set once at boot.
  105.    */
  106. int ei_open(struct device *dev)
  107. {
  108.     struct ei_device *ei_local = (struct ei_device *) dev->priv;
  109.     
  110.     if ( ! ei_local) {
  111.         printk("%s: Opening a non-existent physical device\n", dev->name);
  112.         return ENXIO;
  113.     }
  114.     
  115.     irq2dev_map[dev->irq] = dev;
  116.     NS8390_init(dev, 1);
  117.     dev->start = 1;
  118.     ei_local->irqlock = 0;
  119.     return 0;
  120. }
  121.  
  122. static int ei_start_xmit(struct sk_buff *skb, struct device *dev)
  123. {
  124.     int e8390_base = dev->base_addr;
  125.     struct ei_device *ei_local = (struct ei_device *) dev->priv;
  126.     int length, send_length;
  127.     
  128.     /* We normally shouldn't be called if dev->tbusy is set, but the
  129.        existing code does anyway.
  130.        If it has been too long (> 100 or 150ms.) since the last Tx we assume
  131.        the board has died and kick it. */
  132.  
  133.     if (dev->tbusy) {    /* Do timeouts, just like the 8003 driver. */
  134.         int txsr = inb(e8390_base+EN0_TSR), isr;
  135.         int tickssofar = jiffies - dev->trans_start;
  136.         if (tickssofar < 10    ||    (tickssofar < 15 && ! (txsr & ENTSR_PTX))) {
  137.             return 1;
  138.         }
  139.         isr = inb(e8390_base+EN0_ISR);
  140.         if (dev->start == 0) {
  141.             printk("%s: xmit on stopped card\n", dev->name);
  142.             return 1;
  143.         }
  144.         printk(KERN_DEBUG "%s: transmit timed out, TX status %#2x, ISR %#2x.\n",
  145.                dev->name, txsr, isr);
  146.         /* Does the 8390 thinks it has posted an interrupt? */
  147.         if (isr)
  148.             printk(KERN_DEBUG "%s: Possible IRQ conflict on IRQ%d?\n", dev->name, dev->irq);
  149.         else {
  150.             /* The 8390 probably hasn't gotten on the cable yet. */
  151.             printk(KERN_DEBUG "%s: Possible network cable problem?\n", dev->name);
  152.             if(ei_local->stat.tx_packets==0)
  153.                 ei_local->interface_num ^= 1;     /* Try a different xcvr.  */
  154.         }
  155.         /* Try to restart the card.  Perhaps the user has fixed something. */
  156.         ei_reset_8390(dev);
  157.         NS8390_init(dev, 1);
  158.         dev->trans_start = jiffies;
  159.     }
  160.     
  161.     /* Sending a NULL skb means some higher layer thinks we've missed an
  162.        tx-done interrupt. Caution: dev_tint() handles the cli()/sti()
  163.        itself. */
  164.     if (skb == NULL) {
  165.         dev_tint(dev);
  166.         return 0;
  167.     }
  168.     
  169.     length = skb->len;
  170.     if (skb->len <= 0)
  171.         return 0;
  172.  
  173.     /* Block a timer-based transmit from overlapping. */
  174.     if (set_bit(0, (void*)&dev->tbusy) != 0) {
  175.         printk("%s: Transmitter access conflict.\n", dev->name);
  176.         return 1;
  177.     }
  178.  
  179.     /* Mask interrupts from the ethercard. */
  180.     outb(0x00,    e8390_base + EN0_IMR);
  181.     ei_local->irqlock = 1;
  182.  
  183.     send_length = ETH_ZLEN < length ? length : ETH_ZLEN;
  184.  
  185.     if (ei_local->pingpong) {
  186.         int output_page;
  187.         if (ei_local->tx1 == 0) {
  188.             output_page = ei_local->tx_start_page;
  189.             ei_local->tx1 = send_length;
  190.             if (ei_debug  &&  ei_local->tx2 > 0)
  191.                 printk("%s: idle transmitter tx2=%d, lasttx=%d, txing=%d.\n",
  192.                        dev->name, ei_local->tx2, ei_local->lasttx,
  193.                        ei_local->txing);
  194.         } else if (ei_local->tx2 == 0) {
  195.             output_page = ei_local->tx_start_page + 6;
  196.             ei_local->tx2 = send_length;
  197.             if (ei_debug  &&  ei_local->tx1 > 0)
  198.                 printk("%s: idle transmitter, tx1=%d, lasttx=%d, txing=%d.\n",
  199.                        dev->name, ei_local->tx1, ei_local->lasttx,
  200.                        ei_local->txing);
  201.         } else {    /* We should never get here. */
  202.             if (ei_debug)
  203.                 printk("%s: No packet buffer space for ping-pong use.\n",
  204.                        dev->name);
  205.             ei_local->irqlock = 0;
  206.             dev->tbusy = 1;
  207.             outb_p(ENISR_ALL,  e8390_base + EN0_IMR);
  208.             return 1;
  209.         }
  210.         ei_block_output(dev, length, skb->data, output_page);
  211.         if (! ei_local->txing) {
  212.             NS8390_trigger_send(dev, send_length, output_page);
  213.             dev->trans_start = jiffies;
  214.             if (output_page == ei_local->tx_start_page)
  215.                 ei_local->tx1 = -1, ei_local->lasttx = -1;
  216.             else
  217.                 ei_local->tx2 = -1, ei_local->lasttx = -2;
  218.             ei_local->txing = 1;
  219.         } else
  220.             ei_local->txqueue++;
  221.  
  222.         dev->tbusy = (ei_local->tx1  &&  ei_local->tx2);
  223.     } else {  /* No pingpong, just a single Tx buffer. */
  224.         ei_block_output(dev, length, skb->data, ei_local->tx_start_page);
  225.         NS8390_trigger_send(dev, send_length, ei_local->tx_start_page);
  226.         dev->trans_start = jiffies;
  227.         dev->tbusy = 1;
  228.     }
  229.     
  230.     /* Turn 8390 interrupts back on. */
  231.     ei_local->irqlock = 0;
  232.     outb_p(ENISR_ALL, e8390_base + EN0_IMR);
  233.  
  234.     dev_kfree_skb (skb, FREE_WRITE);
  235.     
  236.     return 0;
  237. }
  238.  
  239. /* The typical workload of the driver:
  240.    Handle the ether interface interrupts. */
  241. void ei_interrupt(int irq, struct pt_regs * regs)
  242. {
  243.     struct device *dev = (struct device *)(irq2dev_map[irq]);
  244.     int e8390_base;
  245.     int interrupts, boguscount = 0;
  246.     struct ei_device *ei_local;
  247.     
  248.     if (dev == NULL) {
  249.         printk ("net_interrupt(): irq %d for unknown device.\n", irq);
  250.         return;
  251.     }
  252.     e8390_base = dev->base_addr;
  253.     ei_local = (struct ei_device *) dev->priv;
  254.     if (dev->interrupt || ei_local->irqlock) {
  255.         /* The "irqlock" check is only for testing. */
  256.         sti();
  257.         printk(ei_local->irqlock
  258.                ? "%s: Interrupted while interrupts are masked! isr=%#2x imr=%#2x.\n"
  259.                : "%s: Reentering the interrupt handler! isr=%#2x imr=%#2x.\n",
  260.                dev->name, inb_p(e8390_base + EN0_ISR),
  261.                inb_p(e8390_base + EN0_IMR));
  262.         return;
  263.     }
  264.     
  265.     dev->interrupt = 1;
  266.     sti(); /* Allow other interrupts. */
  267.     
  268.     /* Change to page 0 and read the intr status reg. */
  269.     outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
  270.     if (ei_debug > 3)
  271.         printk("%s: interrupt(isr=%#2.2x).\n", dev->name,
  272.                inb_p(e8390_base + EN0_ISR));
  273.     
  274.     /* !!Assumption!! -- we stay in page 0.     Don't break this. */
  275.     while ((interrupts = inb_p(e8390_base + EN0_ISR)) != 0
  276.            && ++boguscount < 9) {
  277.         if (dev->start == 0) {
  278.             printk("%s: interrupt from stopped card\n", dev->name);
  279.             interrupts = 0;
  280.             break;
  281.         }
  282.         if (interrupts & ENISR_RDC) {
  283.             /* Ack meaningless DMA complete. */
  284.             outb_p(ENISR_RDC, e8390_base + EN0_ISR);
  285.         }
  286.         if (interrupts & ENISR_OVER) {
  287.             ei_rx_overrun(dev);
  288.         } else if (interrupts & (ENISR_RX+ENISR_RX_ERR)) {
  289.             /* Got a good (?) packet. */
  290.             ei_receive(dev);
  291.         }
  292.         /* Push the next to-transmit packet through. */
  293.         if (interrupts & ENISR_TX) {
  294.             ei_tx_intr(dev);
  295.         } else if (interrupts & ENISR_COUNTERS) {
  296.             ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
  297.             ei_local->stat.rx_crc_errors   += inb_p(e8390_base + EN0_COUNTER1);
  298.             ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
  299.             outb_p(ENISR_COUNTERS, e8390_base + EN0_ISR); /* Ack intr. */
  300.         }
  301.         
  302.         /* Ignore the transmit errs and reset intr for now. */
  303.         if (interrupts & ENISR_TX_ERR) {
  304.             outb_p(ENISR_TX_ERR, e8390_base + EN0_ISR); /* Ack intr. */
  305.         }
  306.         outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
  307.     }
  308.     
  309.     if (interrupts && ei_debug) {
  310.         if (boguscount == 9)
  311.             printk("%s: Too much work at interrupt, status %#2.2x\n",
  312.                    dev->name, interrupts);
  313.         else
  314.             printk("%s: unknown interrupt %#2x\n", dev->name, interrupts);
  315.         outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
  316.         outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
  317.     }
  318.     dev->interrupt = 0;
  319.     return;
  320. }
  321.  
  322. /* We have finished a transmit: check for errors and then trigger the next
  323.    packet to be sent. */
  324. static void ei_tx_intr(struct device *dev)
  325. {
  326.     int e8390_base = dev->base_addr;
  327.     int status = inb(e8390_base + EN0_TSR);
  328.     struct ei_device *ei_local = (struct ei_device *) dev->priv;
  329.     
  330.     outb_p(ENISR_TX, e8390_base + EN0_ISR); /* Ack intr. */
  331.     
  332.     if (ei_local->pingpong) {
  333.         ei_local->txqueue--;
  334.         if (ei_local->tx1 < 0) {
  335.             if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
  336.                 printk("%s: bogus last_tx_buffer %d, tx1=%d.\n",
  337.                        ei_local->name, ei_local->lasttx, ei_local->tx1);
  338.             ei_local->tx1 = 0;
  339.             dev->tbusy = 0;
  340.             if (ei_local->tx2 > 0) {
  341.                 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
  342.                 dev->trans_start = jiffies;
  343.                 ei_local->txing = 1;
  344.                 ei_local->tx2 = -1,
  345.                 ei_local->lasttx = 2;
  346.             } else
  347.                 ei_local->lasttx = 20, ei_local->txing = 0;
  348.         } else if (ei_local->tx2 < 0) {
  349.             if (ei_local->lasttx != 2  &&  ei_local->lasttx != -2)
  350.                 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
  351.                        ei_local->name, ei_local->lasttx, ei_local->tx2);
  352.             ei_local->tx2 = 0;
  353.             dev->tbusy = 0;
  354.             if (ei_local->tx1 > 0) {
  355.                 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
  356.                 dev->trans_start = jiffies;
  357.                 ei_local->txing = 1;
  358.                 ei_local->tx1 = -1;
  359.                 ei_local->lasttx = 1;
  360.             } else
  361.                 ei_local->lasttx = 10, ei_local->txing = 0;
  362.         } else
  363.             printk("%s: unexpected TX-done interrupt, lasttx=%d.\n",
  364.                    dev->name, ei_local->lasttx);
  365.     } else {
  366.         ei_local->txing = 0;
  367.         dev->tbusy = 0;
  368.     }
  369.  
  370.     /* Minimize Tx latency: update the statistics after we restart TXing. */
  371.     if (status & ENTSR_COL) ei_local->stat.collisions++;
  372.     if (status & ENTSR_PTX)
  373.         ei_local->stat.tx_packets++;
  374.     else {
  375.         ei_local->stat.tx_errors++;
  376.         if (status & ENTSR_ABT) ei_local->stat.tx_aborted_errors++;
  377.         if (status & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
  378.         if (status & ENTSR_FU)  ei_local->stat.tx_fifo_errors++;
  379.         if (status & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
  380.         if (status & ENTSR_OWC) ei_local->stat.tx_window_errors++;
  381.     }
  382.     
  383.     mark_bh (NET_BH);
  384. }
  385.  
  386. /* We have a good packet(s), get it/them out of the buffers. */
  387.  
  388. static void ei_receive(struct device *dev)
  389. {
  390.     int e8390_base = dev->base_addr;
  391.     struct ei_device *ei_local = (struct ei_device *) dev->priv;
  392.     int rxing_page, this_frame, next_frame, current_offset;
  393.     int rx_pkt_count = 0;
  394.     struct e8390_pkt_hdr rx_frame;
  395.     int num_rx_pages = ei_local->stop_page-ei_local->rx_start_page;
  396.     
  397.     while (++rx_pkt_count < 10) {
  398.         int pkt_len;
  399.         
  400.         /* Get the rx page (incoming packet pointer). */
  401.         outb_p(E8390_NODMA+E8390_PAGE1, e8390_base + E8390_CMD);
  402.         rxing_page = inb_p(e8390_base + EN1_CURPAG);
  403.         outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
  404.         
  405.         /* Remove one frame from the ring.  Boundary is alway a page behind. */
  406.         this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
  407.         if (this_frame >= ei_local->stop_page)
  408.             this_frame = ei_local->rx_start_page;
  409.         
  410.         /* Someday we'll omit the previous, iff we never get this message.
  411.            (There is at least one clone claimed to have a problem.)  */
  412.         if (ei_debug > 0  &&  this_frame != ei_local->current_page)
  413.             printk("%s: mismatched read page pointers %2x vs %2x.\n",
  414.                    dev->name, this_frame, ei_local->current_page);
  415.         
  416.         if (this_frame == rxing_page)    /* Read all the frames? */
  417.             break;                /* Done for now */
  418.         
  419.         current_offset = this_frame << 8;
  420.         ei_block_input(dev, sizeof(rx_frame), (char *)&rx_frame,
  421.                        current_offset);
  422.         
  423.         pkt_len = rx_frame.count - sizeof(rx_frame);
  424.         
  425.         next_frame = this_frame + 1 + ((pkt_len+4)>>8);
  426.         
  427.         /* Check for bogosity warned by 3c503 book: the status byte is never
  428.            written.  This happened a lot during testing! This code should be
  429.            cleaned up someday. */
  430.         if (rx_frame.next != next_frame
  431.             && rx_frame.next != next_frame + 1
  432.             && rx_frame.next != next_frame - num_rx_pages
  433.             && rx_frame.next != next_frame + 1 - num_rx_pages) {
  434.             ei_local->current_page = rxing_page;
  435.             outb(ei_local->current_page-1, e8390_base+EN0_BOUNDARY);
  436.             ei_local->stat.rx_errors++;
  437.             continue;
  438.         }
  439.  
  440.         if (pkt_len < 60  ||  pkt_len > 1518) {
  441.             if (ei_debug)
  442.                 printk("%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
  443.                        dev->name, rx_frame.count, rx_frame.status,
  444.                        rx_frame.next);
  445.             ei_local->stat.rx_errors++;
  446.         } else if ((rx_frame.status & 0x0F) == ENRSR_RXOK) {
  447.             struct sk_buff *skb;
  448.             
  449.             skb = alloc_skb(pkt_len, GFP_ATOMIC);
  450.             if (skb == NULL) {
  451.                 if (ei_debug > 1)
  452.                     printk("%s: Couldn't allocate a sk_buff of size %d.\n",
  453.                            dev->name, pkt_len);
  454.                 ei_local->stat.rx_dropped++;
  455.                 break;
  456.             } else {
  457.                 skb->len = pkt_len;
  458.                 skb->dev = dev;
  459.                 
  460.                 ei_block_input(dev, pkt_len, (char *) skb->data,
  461.                                current_offset + sizeof(rx_frame));
  462.                 netif_rx(skb);
  463.                 ei_local->stat.rx_packets++;
  464.             }
  465.         } else {
  466.             int errs = rx_frame.status;
  467.             if (ei_debug)
  468.                 printk("%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
  469.                        dev->name, rx_frame.status, rx_frame.next,
  470.                        rx_frame.count);
  471.             if (errs & ENRSR_FO)
  472.                 ei_local->stat.rx_fifo_errors++;
  473.         }
  474.         next_frame = rx_frame.next;
  475.         
  476.         /* This _should_ never happen: it's here for avoiding bad clones. */
  477.         if (next_frame >= ei_local->stop_page) {
  478.             printk("%s: next frame inconsistency, %#2x..", dev->name,
  479.                    next_frame);
  480.             next_frame = ei_local->rx_start_page;
  481.         }
  482.         ei_local->current_page = next_frame;
  483.         outb(next_frame-1, e8390_base+EN0_BOUNDARY);
  484.     }
  485.     /* If any worth-while packets have been received, dev_rint()
  486.        has done a mark_bh(NET_BH) for us and will work on them
  487.        when we get to the bottom-half routine. */
  488.  
  489.     /* Record the maximum Rx packet queue. */
  490.     if (rx_pkt_count > high_water_mark)
  491.         high_water_mark = rx_pkt_count;
  492.  
  493.     /* Bug alert!  Reset ENISR_OVER to avoid spurious overruns! */
  494.     outb_p(ENISR_RX+ENISR_RX_ERR+ENISR_OVER, e8390_base+EN0_ISR);
  495.     return;
  496. }
  497.  
  498. /* We have a receiver overrun: we have to kick the 8390 to get it started
  499.    again.*/
  500. static void ei_rx_overrun(struct device *dev)
  501. {
  502.     int e8390_base = dev->base_addr;
  503.     int reset_start_time = jiffies;
  504.     struct ei_device *ei_local = (struct ei_device *) dev->priv;
  505.     
  506.     /* We should already be stopped and in page0.  Remove after testing. */
  507.     outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
  508.     
  509.     if (ei_debug > 1)
  510.         printk("%s: Receiver overrun.\n", dev->name);
  511.     ei_local->stat.rx_over_errors++;
  512.     
  513.     /* The old Biro driver does dummy = inb_p( RBCR[01] ); at this point.
  514.        It might mean something -- magic to speed up a reset?  A 8390 bug?*/
  515.     
  516.     /* Wait for the reset to complete.    This should happen almost instantly,
  517.        but could take up to 1.5msec in certain rare instances.  There is no
  518.        easy way of timing something in that range, so we use 'jiffies' as
  519.        a sanity check. */
  520.     while ((inb_p(e8390_base+EN0_ISR) & ENISR_RESET) == 0)
  521.         if (jiffies - reset_start_time > 1) {
  522.             printk("%s: reset did not complete at ei_rx_overrun.\n",
  523.                    dev->name);
  524.             NS8390_init(dev, 1);
  525.             return;
  526.         }
  527.     
  528.     /* Remove packets right away. */
  529.     ei_receive(dev);
  530.     
  531.     outb_p(0xff, e8390_base+EN0_ISR);
  532.     /* Generic 8390 insns to start up again, same as in open_8390(). */
  533.     outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
  534.     outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
  535. }
  536.  
  537. static struct enet_statistics *get_stats(struct device *dev)
  538. {
  539.     short ioaddr = dev->base_addr;
  540.     struct ei_device *ei_local = (struct ei_device *) dev->priv;
  541.     
  542.     /* Read the counter registers, assuming we are in page 0. */
  543.     ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
  544.     ei_local->stat.rx_crc_errors   += inb_p(ioaddr + EN0_COUNTER1);
  545.     ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
  546.     
  547.     return &ei_local->stat;
  548. }
  549.  
  550. #ifdef HAVE_MULTICAST
  551. /* Set or clear the multicast filter for this adaptor.
  552.    num_addrs == -1    Promiscuous mode, receive all packets
  553.    num_addrs == 0    Normal mode, clear multicast list
  554.    num_addrs > 0    Multicast mode, receive normal and MC packets, and do
  555.    .                   best-effort filtering.
  556.    */
  557. static void set_multicast_list(struct device *dev, int num_addrs, void *addrs)
  558. {
  559.     short ioaddr = dev->base_addr;
  560.     
  561.     if (num_addrs > 0) {
  562.         /* The multicast-accept list is initialized to accept-all, and we
  563.            rely on higher-level filtering for now. */
  564.         outb_p(E8390_RXCONFIG | 0x08, ioaddr + EN0_RXCR);
  565.     } else if (num_addrs < 0)
  566.         outb_p(E8390_RXCONFIG | 0x18, ioaddr + EN0_RXCR);
  567.     else
  568.         outb_p(E8390_RXCONFIG, ioaddr + EN0_RXCR);
  569. }
  570. #endif
  571.  
  572. /* Initialize the rest of the 8390 device structure. */
  573. int ethdev_init(struct device *dev)
  574. {
  575.     if (ei_debug > 1)
  576.         printk(version);
  577.     
  578.     if (dev->priv == NULL) {
  579.         struct ei_device *ei_local;
  580.         
  581.         dev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL);
  582.         memset(dev->priv, 0, sizeof(struct ei_device));
  583.         ei_local = (struct ei_device *)dev->priv;
  584. #ifndef NO_PINGPONG
  585.         ei_local->pingpong = 1;
  586. #endif
  587.     }
  588.     
  589.     /* The open call may be overridden by the card-specific code. */
  590.     if (dev->open == NULL)
  591.         dev->open = &ei_open;
  592.     /* We should have a dev->stop entry also. */
  593.     dev->hard_start_xmit = &ei_start_xmit;
  594.     dev->get_stats    = get_stats;
  595. #ifdef HAVE_MULTICAST
  596.     dev->set_multicast_list = &set_multicast_list;
  597. #endif
  598.  
  599.     ether_setup(dev);
  600.         
  601.     return 0;
  602. }
  603.  
  604.  
  605. /* This page of functions should be 8390 generic */
  606. /* Follow National Semi's recommendations for initializing the "NIC". */
  607. void NS8390_init(struct device *dev, int startp)
  608. {
  609.     int e8390_base = dev->base_addr;
  610.     struct ei_device *ei_local = (struct ei_device *) dev->priv;
  611.     int i;
  612.     int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48;
  613.     
  614.     /* Follow National Semi's recommendations for initing the DP83902. */
  615.     outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base); /* 0x21 */
  616.     outb_p(endcfg, e8390_base + EN0_DCFG);    /* 0x48 or 0x49 */
  617.     /* Clear the remote byte count registers. */
  618.     outb_p(0x00,  e8390_base + EN0_RCNTLO);
  619.     outb_p(0x00,  e8390_base + EN0_RCNTHI);
  620.     /* Set to monitor and loopback mode -- this is vital!. */
  621.     outb_p(E8390_RXOFF, e8390_base + EN0_RXCR); /* 0x20 */
  622.     outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
  623.     /* Set the transmit page and receive ring. */
  624.     outb_p(ei_local->tx_start_page,     e8390_base + EN0_TPSR);
  625.     ei_local->tx1 = ei_local->tx2 = 0;
  626.     outb_p(ei_local->rx_start_page,     e8390_base + EN0_STARTPG);
  627.     outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
  628.     ei_local->current_page = ei_local->rx_start_page;        /* assert boundary+1 */
  629.     outb_p(ei_local->stop_page,      e8390_base + EN0_STOPPG);
  630.     /* Clear the pending interrupts and mask. */
  631.     outb_p(0xFF, e8390_base + EN0_ISR);
  632.     outb_p(0x00,  e8390_base + EN0_IMR);
  633.     
  634.     /* Copy the station address into the DS8390 registers,
  635.        and set the multicast hash bitmap to receive all multicasts. */
  636.     cli();
  637.     outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base); /* 0x61 */
  638.     for(i = 0; i < 6; i++) {
  639.         outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS + i);
  640.     }
  641.     /* Initialize the multicast list to accept-all.  If we enable multicast
  642.        the higher levels can do the filtering. */
  643.     for(i = 0; i < 8; i++)
  644.         outb_p(0xff, e8390_base + EN1_MULT + i);
  645.     
  646.     outb_p(ei_local->rx_start_page,     e8390_base + EN1_CURPAG);
  647.     outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base);
  648.     sti();
  649.     dev->tbusy = 0;
  650.     dev->interrupt = 0;
  651.     ei_local->tx1 = ei_local->tx2 = 0;
  652.     ei_local->txing = 0;
  653.     if (startp) {
  654.         outb_p(0xff,  e8390_base + EN0_ISR);
  655.         outb_p(ENISR_ALL,  e8390_base + EN0_IMR);
  656.         outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base);
  657.         outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
  658.         /* 3c503 TechMan says rxconfig only after the NIC is started. */
  659.         outb_p(E8390_RXCONFIG,    e8390_base + EN0_RXCR); /* rx on,  */
  660.     }
  661.     return;
  662. }
  663.  
  664. /* Trigger a transmit start, assuming the length is valid. */
  665. static void NS8390_trigger_send(struct device *dev, unsigned int length,
  666.                                 int start_page)
  667. {
  668.     int e8390_base = dev->base_addr;
  669.     
  670.     ei_status.txing = 1;
  671.     outb_p(E8390_NODMA+E8390_PAGE0, e8390_base);
  672.     
  673.     if (inb_p(e8390_base) & E8390_TRANS) {
  674.         printk("%s: trigger_send() called with the transmitter busy.\n",
  675.                dev->name);
  676.         return;
  677.     }
  678.     outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
  679.     outb_p(length >> 8, e8390_base + EN0_TCNTHI);
  680.     outb_p(start_page, e8390_base + EN0_TPSR);
  681.     outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base);
  682.     return;
  683. }
  684.  
  685. #ifdef MODULE
  686. char kernel_version[] = UTS_RELEASE;
  687.  
  688. int init_module(void)
  689. {
  690.      return 0;
  691. }
  692.  
  693. void
  694. cleanup_module(void)
  695. {
  696. }
  697. #endif /* MODULE */
  698.  
  699. /*
  700.  * Local variables:
  701.  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 8390.c"
  702.  *  version-control: t
  703.  *  kept-new-versions: 5
  704.  *  c-indent-level: 4
  705.  *  tab-width: 4
  706.  * End:
  707.  */
  708.