root/drivers/net/8390.c

/* */

DEFINITIONS

1. ei_open
2. ei_close
3. ei_start_xmit
4. ei_interrupt
5. ei_tx_intr
6. ei_receive
7. ei_rx_overrun
8. get_stats
9. set_multicast_list
10. ethdev_init
11. NS8390_init
12. NS8390_trigger_send
13. init_module
14. cleanup_module

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

/* */