root/drivers/net/8390.c

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

DEFINITIONS

This source file includes following definitions.
  1. ei_open
  2. ei_start_xmit
  3. ei_interrupt
  4. ei_tx_intr
  5. ei_receive
  6. ei_rx_overrun
  7. get_stats
  8. set_multicast_list
  9. ethdev_init
  10. NS8390_init
  11. NS8390_trigger_send

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

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