drivers/net/8390.c

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

DEFINITIONS
