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

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