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,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 #ifdef MODULE
  57 #include <linux/module.h>
  58 #include "../../tools/version.h"
  59 #endif
  60 
  61 /* These are the operational function interfaces to board-specific
  62    routines.
  63         void reset_8390(struct device *dev)
  64                 Resets the board associated with DEV, including a hardware reset of
  65                 the 8390.  This is only called when there is a transmit timeout, and
  66                 it is always followed by 8390_init().
  67         void block_output(struct device *dev, int count, const unsigned char *buf,
  68                                           int start_page)
  69                 Write the COUNT bytes of BUF to the packet buffer at START_PAGE.  The
  70                 "page" value uses the 8390's 256-byte pages.
  71         int block_input(struct device *dev, int count, char *buf, int ring_offset)
  72                 Read COUNT bytes from the packet buffer into BUF.  Start reading from
  73                 RING_OFFSET, the address as the 8390 sees it.  The first read will
  74                 always be the 4 byte, page aligned 8390 header.  *If* there is a
  75                 subsequent read, it will be of the rest of the packet.
  76 */
  77 #define ei_reset_8390 (ei_local->reset_8390)
  78 #define ei_block_output (ei_local->block_output)
  79 #define ei_block_input (ei_local->block_input)
  80 
  81 /* use 0 for production, 1 for verification, >2 for debug */
  82 #ifdef EI_DEBUG
  83 int ei_debug = EI_DEBUG;
  84 #else
  85 int ei_debug = 1;
  86 #endif
  87 
  88 /* Max number of packets received at one Intr.
  89    Current this may only be examined by a kernel debugger. */
  90 static int high_water_mark = 0;
  91 
  92 /* Index to functions. */
  93 static void ei_tx_intr(struct device *dev);
  94 static void ei_receive(struct device *dev);
  95 static void ei_rx_overrun(struct device *dev);
  96 
  97 /* Routines generic to NS8390-based boards. */
  98 static void NS8390_trigger_send(struct device *dev, unsigned int length,
  99                                                                 int start_page);
 100 #ifdef HAVE_MULTICAST
 101 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
 102 #endif
 103 
 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)
     /*  */
 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)
     /*  */
 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)
     /*  */
 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                         ei_local->stat.rx_frame_errors += inb_p(e8390_base + EN0_COUNTER0);
 292                         ei_local->stat.rx_crc_errors   += inb_p(e8390_base + EN0_COUNTER1);
 293                         ei_local->stat.rx_missed_errors+= inb_p(e8390_base + EN0_COUNTER2);
 294                         outb_p(ENISR_COUNTERS, e8390_base + EN0_ISR); /* Ack intr. */
 295                 }
 296                 
 297                 /* Ignore the transmit errs and reset intr for now. */
 298                 if (interrupts & ENISR_TX_ERR) {
 299                         outb_p(ENISR_TX_ERR, e8390_base + EN0_ISR); /* Ack intr. */
 300                 }
 301                 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
 302     }
 303     
 304     if (interrupts && ei_debug) {
 305                 printk("%s: unknown interrupt %#2x\n", dev->name, interrupts);
 306                 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base + E8390_CMD);
 307                 outb_p(0xff, e8390_base + EN0_ISR); /* Ack. all intrs. */
 308     }
 309     dev->interrupt = 0;
 310     return;
 311 }
 312 
 313 /* We have finished a transmit: check for errors and then trigger the next
 314    packet to be sent. */
 315 static void ei_tx_intr(struct device *dev)
     /*  */
 316 {
 317     int e8390_base = dev->base_addr;
 318     int status = inb(e8390_base + EN0_TSR);
 319     struct ei_device *ei_local = (struct ei_device *) dev->priv;
 320     
 321     outb_p(ENISR_TX, e8390_base + EN0_ISR); /* Ack intr. */
 322     
 323     if (ei_local->pingpong) {
 324                 ei_local->txqueue--;
 325                 if (ei_local->tx1 < 0) {
 326                         if (ei_local->lasttx != 1 && ei_local->lasttx != -1)
 327                                 printk("%s: bogus last_tx_buffer %d, tx1=%d.\n",
 328                                            ei_local->name, ei_local->lasttx, ei_local->tx1);
 329                         ei_local->tx1 = 0;
 330                         dev->tbusy = 0;
 331                         if (ei_local->tx2 > 0) {
 332                                 NS8390_trigger_send(dev, ei_local->tx2, ei_local->tx_start_page + 6);
 333                                 dev->trans_start = jiffies;
 334                                 ei_local->txing = 1;
 335                                 ei_local->tx2 = -1,
 336                                 ei_local->lasttx = 2;
 337                         } else
 338                                 ei_local->lasttx = 20, ei_local->txing = 0;
 339                 } else if (ei_local->tx2 < 0) {
 340                         if (ei_local->lasttx != 2  &&  ei_local->lasttx != -2)
 341                                 printk("%s: bogus last_tx_buffer %d, tx2=%d.\n",
 342                                            ei_local->name, ei_local->lasttx, ei_local->tx2);
 343                         ei_local->tx2 = 0;
 344                         dev->tbusy = 0;
 345                         if (ei_local->tx1 > 0) {
 346                                 NS8390_trigger_send(dev, ei_local->tx1, ei_local->tx_start_page);
 347                                 dev->trans_start = jiffies;
 348                                 ei_local->txing = 1;
 349                                 ei_local->tx1 = -1;
 350                                 ei_local->lasttx = 1;
 351                         } else
 352                                 ei_local->lasttx = 10, ei_local->txing = 0;
 353                 } else
 354                         printk("%s: unexpected TX-done interrupt, lasttx=%d.\n",
 355                                    dev->name, ei_local->lasttx);
 356     } else {
 357                 ei_local->txing = 0;
 358                 dev->tbusy = 0;
 359     }
 360 
 361     /* Minimize Tx latency: update the statistics after we restart TXing. */
 362         if (status & ENTSR_COL) ei_local->stat.collisions++;
 363     if (status & ENTSR_PTX)
 364                 ei_local->stat.tx_packets++;
 365     else {
 366                 ei_local->stat.tx_errors++;
 367                 if (status & ENTSR_ABT) ei_local->stat.tx_aborted_errors++;
 368                 if (status & ENTSR_CRS) ei_local->stat.tx_carrier_errors++;
 369                 if (status & ENTSR_FU)  ei_local->stat.tx_fifo_errors++;
 370                 if (status & ENTSR_CDH) ei_local->stat.tx_heartbeat_errors++;
 371                 if (status & ENTSR_OWC) ei_local->stat.tx_window_errors++;
 372         }
 373     
 374     mark_bh (NET_BH);
 375 }
 376 
 377 /* We have a good packet(s), get it/them out of the buffers. */
 378 
 379 static void ei_receive(struct device *dev)
     /*  */
 380 {
 381     int e8390_base = dev->base_addr;
 382     struct ei_device *ei_local = (struct ei_device *) dev->priv;
 383     int rxing_page, this_frame, next_frame, current_offset;
 384     int rx_pkt_count = 0;
 385     struct e8390_pkt_hdr rx_frame;
 386     int num_rx_pages = ei_local->stop_page-ei_local->rx_start_page;
 387     
 388     while (++rx_pkt_count < 10) {
 389                 int pkt_len;
 390                 
 391                 /* Get the rx page (incoming packet pointer). */
 392                 outb_p(E8390_NODMA+E8390_PAGE1, e8390_base + E8390_CMD);
 393                 rxing_page = inb_p(e8390_base + EN1_CURPAG);
 394                 outb_p(E8390_NODMA+E8390_PAGE0, e8390_base + E8390_CMD);
 395                 
 396                 /* Remove one frame from the ring.  Boundary is alway a page behind. */
 397                 this_frame = inb_p(e8390_base + EN0_BOUNDARY) + 1;
 398                 if (this_frame >= ei_local->stop_page)
 399                         this_frame = ei_local->rx_start_page;
 400                 
 401                 /* Someday we'll omit the previous, iff we never get this message.
 402                    (There is at least one clone claimed to have a problem.)  */
 403                 if (ei_debug > 0  &&  this_frame != ei_local->current_page)
 404                         printk("%s: mismatched read page pointers %2x vs %2x.\n",
 405                                    dev->name, this_frame, ei_local->current_page);
 406                 
 407                 if (this_frame == rxing_page)   /* Read all the frames? */
 408                         break;                          /* Done for now */
 409                 
 410                 current_offset = this_frame << 8;
 411                 ei_block_input(dev, sizeof(rx_frame), (char *)&rx_frame,
 412                                            current_offset);
 413                 
 414                 pkt_len = rx_frame.count - sizeof(rx_frame);
 415                 
 416                 next_frame = this_frame + 1 + ((pkt_len+4)>>8);
 417                 
 418                 /* Check for bogosity warned by 3c503 book: the status byte is never
 419                    written.  This happened a lot during testing! This code should be
 420                    cleaned up someday. */
 421                 if (rx_frame.next != next_frame
 422                         && rx_frame.next != next_frame + 1
 423                         && rx_frame.next != next_frame - num_rx_pages
 424                         && rx_frame.next != next_frame + 1 - num_rx_pages) {
 425                         ei_local->current_page = rxing_page;
 426                         outb(ei_local->current_page-1, e8390_base+EN0_BOUNDARY);
 427                         ei_local->stat.rx_errors++;
 428                         continue;
 429                 }
 430 
 431                 if (pkt_len < 60  ||  pkt_len > 1518) {
 432                         if (ei_debug)
 433                                 printk("%s: bogus packet size: %d, status=%#2x nxpg=%#2x.\n",
 434                                            dev->name, rx_frame.count, rx_frame.status,
 435                                            rx_frame.next);
 436                         ei_local->stat.rx_errors++;
 437                 } else if ((rx_frame.status & 0x0F) == ENRSR_RXOK) {
 438                         struct sk_buff *skb;
 439                         
 440                         skb = alloc_skb(pkt_len, GFP_ATOMIC);
 441                         if (skb == NULL) {
 442                                 if (ei_debug > 1)
 443                                         printk("%s: Couldn't allocate a sk_buff of size %d.\n",
 444                                                    dev->name, pkt_len);
 445                                 ei_local->stat.rx_dropped++;
 446                                 break;
 447                         } else {
 448                                 skb->len = pkt_len;
 449                                 skb->dev = dev;
 450                                 
 451                                 ei_block_input(dev, pkt_len, (char *) skb->data,
 452                                                            current_offset + sizeof(rx_frame));
 453                                 netif_rx(skb);
 454                                 ei_local->stat.rx_packets++;
 455                         }
 456                 } else {
 457                         int errs = rx_frame.status;
 458                         if (ei_debug)
 459                                 printk("%s: bogus packet: status=%#2x nxpg=%#2x size=%d\n",
 460                                            dev->name, rx_frame.status, rx_frame.next,
 461                                            rx_frame.count);
 462                         if (errs & ENRSR_FO)
 463                                 ei_local->stat.rx_fifo_errors++;
 464                 }
 465                 next_frame = rx_frame.next;
 466                 
 467                 /* This _should_ never happen: it's here for avoiding bad clones. */
 468                 if (next_frame >= ei_local->stop_page) {
 469                         printk("%s: next frame inconsistency, %#2x..", dev->name,
 470                                    next_frame);
 471                         next_frame = ei_local->rx_start_page;
 472                 }
 473                 ei_local->current_page = next_frame;
 474                 outb(next_frame-1, e8390_base+EN0_BOUNDARY);
 475     }
 476     /* If any worth-while packets have been received, dev_rint()
 477        has done a mark_bh(NET_BH) for us and will work on them
 478        when we get to the bottom-half routine. */
 479 
 480         /* Record the maximum Rx packet queue. */
 481         if (rx_pkt_count > high_water_mark)
 482                 high_water_mark = rx_pkt_count;
 483 
 484     /* Bug alert!  Reset ENISR_OVER to avoid spurious overruns! */
 485     outb_p(ENISR_RX+ENISR_RX_ERR+ENISR_OVER, e8390_base+EN0_ISR);
 486     return;
 487 }
 488 
 489 /* We have a receiver overrun: we have to kick the 8390 to get it started
 490    again.*/
 491 static void ei_rx_overrun(struct device *dev)
     /*  */
 492 {
 493     int e8390_base = dev->base_addr;
 494     int reset_start_time = jiffies;
 495     struct ei_device *ei_local = (struct ei_device *) dev->priv;
 496     
 497     /* We should already be stopped and in page0.  Remove after testing. */
 498     outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base+E8390_CMD);
 499     
 500     if (ei_debug > 1)
 501                 printk("%s: Receiver overrun.\n", dev->name);
 502     ei_local->stat.rx_over_errors++;
 503     
 504     /* The old Biro driver does dummy = inb_p( RBCR[01] ); at this point.
 505        It might mean something -- magic to speed up a reset?  A 8390 bug?*/
 506     
 507     /* Wait for the reset to complete.  This should happen almost instantly,
 508            but could take up to 1.5msec in certain rare instances.  There is no
 509            easy way of timing something in that range, so we use 'jiffies' as
 510            a sanity check. */
 511     while ((inb_p(e8390_base+EN0_ISR) & ENISR_RESET) == 0)
 512                 if (jiffies - reset_start_time > 1) {
 513                         printk("%s: reset did not complete at ei_rx_overrun.\n",
 514                                    dev->name);
 515                         NS8390_init(dev, 1);
 516                         return;
 517                 }
 518     
 519     /* Remove packets right away. */
 520     ei_receive(dev);
 521     
 522     outb_p(0xff, e8390_base+EN0_ISR);
 523     /* Generic 8390 insns to start up again, same as in open_8390(). */
 524     outb_p(E8390_NODMA + E8390_PAGE0 + E8390_START, e8390_base + E8390_CMD);
 525     outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
 526 }
 527 
 528 static struct enet_statistics *get_stats(struct device *dev)
     /*  */
 529 {
 530     short ioaddr = dev->base_addr;
 531     struct ei_device *ei_local = (struct ei_device *) dev->priv;
 532     
 533     /* Read the counter registers, assuming we are in page 0. */
 534     ei_local->stat.rx_frame_errors += inb_p(ioaddr + EN0_COUNTER0);
 535     ei_local->stat.rx_crc_errors   += inb_p(ioaddr + EN0_COUNTER1);
 536     ei_local->stat.rx_missed_errors+= inb_p(ioaddr + EN0_COUNTER2);
 537     
 538     return &ei_local->stat;
 539 }
 540 
 541 #ifdef HAVE_MULTICAST
 542 /* Set or clear the multicast filter for this adaptor.
 543    num_addrs == -1      Promiscuous mode, receive all packets
 544    num_addrs == 0       Normal mode, clear multicast list
 545    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
 546    .                            best-effort filtering.
 547    */
 548 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs)
     /*  */
 549 {
 550     short ioaddr = dev->base_addr;
 551     
 552     if (num_addrs > 0) {
 553                 /* The multicast-accept list is initialized to accept-all, and we
 554                    rely on higher-level filtering for now. */
 555                 outb_p(E8390_RXCONFIG | 0x08, ioaddr + EN0_RXCR);
 556     } else if (num_addrs < 0)
 557                 outb_p(E8390_RXCONFIG | 0x18, ioaddr + EN0_RXCR);
 558     else
 559                 outb_p(E8390_RXCONFIG, ioaddr + EN0_RXCR);
 560 }
 561 #endif
 562 
 563 /* Initialize the rest of the 8390 device structure. */
 564 int ethdev_init(struct device *dev)
     /*  */
 565 {
 566     if (ei_debug > 1)
 567                 printk(version);
 568     
 569     if (dev->priv == NULL) {
 570                 struct ei_device *ei_local;
 571                 
 572                 dev->priv = kmalloc(sizeof(struct ei_device), GFP_KERNEL);
 573                 memset(dev->priv, 0, sizeof(struct ei_device));
 574                 ei_local = (struct ei_device *)dev->priv;
 575 #ifndef NO_PINGPONG
 576                 ei_local->pingpong = 1;
 577 #endif
 578     }
 579     
 580     /* The open call may be overridden by the card-specific code. */
 581     if (dev->open == NULL)
 582                 dev->open = &ei_open;
 583     /* We should have a dev->stop entry also. */
 584     dev->hard_start_xmit = &ei_start_xmit;
 585     dev->get_stats      = get_stats;
 586 #ifdef HAVE_MULTICAST
 587     dev->set_multicast_list = &set_multicast_list;
 588 #endif
 589 
 590     ether_setup(dev);
 591         
 592     return 0;
 593 }
 594 
 595 
 596 /* This page of functions should be 8390 generic */
 597 /* Follow National Semi's recommendations for initializing the "NIC". */
 598 void NS8390_init(struct device *dev, int startp)
     /*  */
 599 {
 600     int e8390_base = dev->base_addr;
 601     struct ei_device *ei_local = (struct ei_device *) dev->priv;
 602     int i;
 603     int endcfg = ei_local->word16 ? (0x48 | ENDCFG_WTS) : 0x48;
 604     
 605     /* Follow National Semi's recommendations for initing the DP83902. */
 606     outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base); /* 0x21 */
 607     outb_p(endcfg, e8390_base + EN0_DCFG);      /* 0x48 or 0x49 */
 608     /* Clear the remote byte count registers. */
 609     outb_p(0x00,  e8390_base + EN0_RCNTLO);
 610     outb_p(0x00,  e8390_base + EN0_RCNTHI);
 611     /* Set to monitor and loopback mode -- this is vital!. */
 612     outb_p(E8390_RXOFF, e8390_base + EN0_RXCR); /* 0x20 */
 613     outb_p(E8390_TXOFF, e8390_base + EN0_TXCR); /* 0x02 */
 614     /* Set the transmit page and receive ring. */
 615     outb_p(ei_local->tx_start_page,      e8390_base + EN0_TPSR);
 616     ei_local->tx1 = ei_local->tx2 = 0;
 617     outb_p(ei_local->rx_start_page,      e8390_base + EN0_STARTPG);
 618     outb_p(ei_local->stop_page-1, e8390_base + EN0_BOUNDARY); /* 3c503 says 0x3f,NS0x26*/
 619     ei_local->current_page = ei_local->rx_start_page;           /* assert boundary+1 */
 620     outb_p(ei_local->stop_page,   e8390_base + EN0_STOPPG);
 621     /* Clear the pending interrupts and mask. */
 622     outb_p(0xFF, e8390_base + EN0_ISR);
 623     outb_p(0x00,  e8390_base + EN0_IMR);
 624     
 625     /* Copy the station address into the DS8390 registers,
 626        and set the multicast hash bitmap to receive all multicasts. */
 627     cli();
 628     outb_p(E8390_NODMA + E8390_PAGE1 + E8390_STOP, e8390_base); /* 0x61 */
 629     for(i = 0; i < 6; i++) {
 630                 outb_p(dev->dev_addr[i], e8390_base + EN1_PHYS + i);
 631     }
 632     /* Initialize the multicast list to accept-all.  If we enable multicast
 633        the higher levels can do the filtering. */
 634     for(i = 0; i < 8; i++)
 635                 outb_p(0xff, e8390_base + EN1_MULT + i);
 636     
 637     outb_p(ei_local->rx_start_page,      e8390_base + EN1_CURPAG);
 638     outb_p(E8390_NODMA+E8390_PAGE0+E8390_STOP, e8390_base);
 639     sti();
 640     dev->tbusy = 0;
 641     dev->interrupt = 0;
 642     ei_local->tx1 = ei_local->tx2 = 0;
 643     ei_local->txing = 0;
 644     if (startp) {
 645                 outb_p(0xff,  e8390_base + EN0_ISR);
 646                 outb_p(ENISR_ALL,  e8390_base + EN0_IMR);
 647                 outb_p(E8390_NODMA+E8390_PAGE0+E8390_START, e8390_base);
 648                 outb_p(E8390_TXCONFIG, e8390_base + EN0_TXCR); /* xmit on. */
 649                 /* 3c503 TechMan says rxconfig only after the NIC is started. */
 650                 outb_p(E8390_RXCONFIG,  e8390_base + EN0_RXCR); /* rx on,  */
 651     }
 652     return;
 653 }
 654 
 655 /* Trigger a transmit start, assuming the length is valid. */
 656 static void NS8390_trigger_send(struct device *dev, unsigned int length,
     /*  */
 657                                                                 int start_page)
 658 {
 659     int e8390_base = dev->base_addr;
 660     
 661     ei_status.txing = 1;
 662     outb_p(E8390_NODMA+E8390_PAGE0, e8390_base);
 663     
 664     if (inb_p(e8390_base) & E8390_TRANS) {
 665                 printk("%s: trigger_send() called with the transmitter busy.\n",
 666                            dev->name);
 667                 return;
 668     }
 669     outb_p(length & 0xff, e8390_base + EN0_TCNTLO);
 670     outb_p(length >> 8, e8390_base + EN0_TCNTHI);
 671     outb_p(start_page, e8390_base + EN0_TPSR);
 672     outb_p(E8390_NODMA+E8390_TRANS+E8390_START, e8390_base);
 673     return;
 674 }
 675 
 676 #ifdef MODULE
 677 char kernel_version[] = UTS_RELEASE;
 678 
 679 int init_module(void)
     /*  */
 680 {
 681      return 0;
 682 }
 683 
 684 void
 685 cleanup_module(void)
     /*  */
 686 {
 687 }
 688 #endif /* MODULE */
 689 
 690 /*
 691  * Local variables:
 692  *  compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c 8390.c"
 693  *  version-control: t
 694  *  kept-new-versions: 5
 695  *  c-indent-level: 4
 696  *  tab-width: 4
 697  * End:
 698  */
/* */
root/drivers/net/8390.c

DEFINITIONS
