drivers/net/eepro.c

/* */
This source file includes following definitions.
eepro_probe
eepro_probe1
eepro_grab_irq
eepro_open
eepro_send_packet
eepro_interrupt
eepro_close
eepro_get_stats
set_multicast_list
read_eeprom
hardware_send_packet
eepro_rx
eepro_transmit_interrupt
init_module
cleanup_module
   1 /* eepro.c: Intel EtherExpress Pro/10 device driver for Linux. */
   2 /*
   3         Written 1994, 1995 by Bao C. Ha.
   4 
   5         Copyright (C) 1994, 1995 by Bao C. Ha.
   6 
   7         This software may be used and distributed
   8         according to the terms of the GNU Public License,
   9         incorporated herein by reference.
  10 
  11         The author may be reached at bao@saigon.async.com 
  12         or 418 Hastings Place, Martinez, GA 30907.
  13 
  14         Things remaining to do:
  15         Better record keeping of errors.
  16         Eliminate transmit interrupt to reduce overhead.
  17         Implement "concurrent processing". I won't be doing it!
  18         Allow changes to the partition of the transmit and receive
  19         buffers, currently the ratio is 3:1 of receive to transmit
  20         buffer ratio.  
  21 
  22         Bugs:
  23 
  24         If you have a problem of not detecting the 82595 during a
  25         reboot (warm reset), disable the FLASH memory should fix it.
  26         This is a compatibility hardware problem.
  27         
  28         Versions:
  29 
  30         0.07a   Fix a stat report which counts every packet as a
  31                 heart-beat failure. (BCH, 6/3/95)
  32 
  33         0.07    Modified to support all other 82595-based lan cards.  
  34                 The IRQ vector of the EtherExpress Pro will be set
  35                 according to the value saved in the EEPROM.  For other
  36                 cards, I will do autoirq_request() to grab the next
  37                 available interrupt vector. (BCH, 3/17/95)
  38 
  39         0.06a,b Interim released.  Minor changes in the comments and
  40                 print out format. (BCH, 3/9/95 and 3/14/95)
  41 
  42         0.06    First stable release that I am comfortable with. (BCH,
  43                 3/2/95) 
  44 
  45         0.05    Complete testing of multicast. (BCH, 2/23/95)   
  46 
  47         0.04    Adding multicast support. (BCH, 2/14/95)        
  48 
  49         0.03    First widely alpha release for public testing. 
  50                 (BCH, 2/14/95)  
  51 
  52 */
  53 
  54 static const char *version =
  55         "eepro.c: v0.07a 6/5/95 Bao C. Ha (bao@saigon.async.com)\n";
  56 
  57 /* Always include 'config.h' first in case the user wants to turn on
  58    or override something. */
  59 #include <linux/config.h>
  60 
  61 #ifdef MODULE
  62 #include <linux/module.h>
  63 #include <linux/version.h>
  64 #endif
  65 
  66 /*
  67   Sources:
  68 
  69         This driver wouldn't have been written without the availability 
  70         of the Crynwr's Lan595 driver source code.  It helps me to 
  71         familiarize with the 82595 chipset while waiting for the Intel 
  72         documentation.  I also learned how to detect the 82595 using 
  73         the packet driver's technique.
  74 
  75         This driver is written by cutting and pasting the skeleton.c driver
  76         provided by Donald Becker.  I also borrowed the EEPROM routine from
  77         Donald Becker's 82586 driver.
  78 
  79         Datasheet for the Intel 82595. It provides just enough info that 
  80         the casual reader might think that it documents the i82595.
  81 
  82         The User Manual for the 82595.  It provides a lot of the missing
  83         information.
  84 
  85 */
  86 
  87 #include <linux/kernel.h>
  88 #include <linux/sched.h>
  89 #include <linux/types.h>
  90 #include <linux/fcntl.h>
  91 #include <linux/interrupt.h>
  92 #include <linux/ptrace.h>
  93 #include <linux/ioport.h>
  94 #include <linux/in.h>
  95 #include <linux/malloc.h>
  96 #include <linux/string.h>
  97 #include <asm/system.h>
  98 #include <asm/bitops.h>
  99 #include <asm/io.h>
 100 #include <asm/dma.h>
 101 #include <linux/errno.h>
 102 
 103 #include <linux/netdevice.h>
 104 #include <linux/etherdevice.h>
 105 #include <linux/skbuff.h>
 106 
 107 
 108 /* First, a few definitions that the brave might change. */
 109 /* A zero-terminated list of I/O addresses to be probed. */
 110 static unsigned int eepro_portlist[] =
 111    { 0x200, 0x240, 0x280, 0x2C0, 0x300, 0x320, 0x340, 0x360, 0};
 112 
 113 /* use 0 for production, 1 for verification, >2 for debug */
 114 #ifndef NET_DEBUG
 115 #define NET_DEBUG 2
 116 #endif
 117 static unsigned int net_debug = NET_DEBUG;
 118 
 119 /* The number of low I/O ports used by the ethercard. */
 120 #define EEPRO_IO_EXTENT 16
 121 
 122 /* Information that need to be kept for each board. */
 123 struct eepro_local {
 124         struct enet_statistics stats;
 125         unsigned rx_start;
 126         unsigned tx_start; /* start of the transmit chain */
 127         int tx_last;  /* pointer to last packet in the transmit chain */
 128         unsigned tx_end;   /* end of the transmit chain (plus 1) */
 129         int eepro;      /* a flag, TRUE=1 for the EtherExpress Pro/10,
 130                            FALSE = 0 for other 82595-based lan cards. */
 131 };
 132 
 133 /* The station (ethernet) address prefix, used for IDing the board. */
 134 #define SA_ADDR0 0x00
 135 #define SA_ADDR1 0xaa
 136 #define SA_ADDR2 0x00
 137 
 138 /* Index to functions, as function prototypes. */
 139 
 140 extern int eepro_probe(struct device *dev);     
 141 
 142 static int      eepro_probe1(struct device *dev, short ioaddr);
 143 static int      eepro_open(struct device *dev);
 144 static int      eepro_send_packet(struct sk_buff *skb, struct device *dev);
 145 static void     eepro_interrupt(int irq, struct pt_regs *regs);
 146 static void     eepro_rx(struct device *dev);
 147 static void     eepro_transmit_interrupt(struct device *dev);
 148 static int      eepro_close(struct device *dev);
 149 static struct enet_statistics *eepro_get_stats(struct device *dev);
 150 static void set_multicast_list(struct device *dev, int num_addrs, void *addrs);
 151 
 152 static int read_eeprom(int ioaddr, int location);
 153 static void hardware_send_packet(struct device *dev, void *buf, short length);
 154 static int      eepro_grab_irq(struct device *dev);
 155 
 156 /*
 157                         Details of the i82595.
 158 
 159 You will need either the datasheet or the user manual to understand what
 160 is going on here.  The 82595 is very different from the 82586, 82593.
 161 
 162 The receive algorithm in eepro_rx() is just an implementation of the
 163 RCV ring structure that the Intel 82595 imposes at the hardware level.
 164 The receive buffer is set at 24K, and the transmit buffer is 8K.  I
 165 am assuming that the total buffer memory is 32K, which is true for the
 166 Intel EtherExpress Pro/10.  If it is less than that on a generic card,
 167 the driver will be broken.
 168 
 169 The transmit algorithm in the hardware_send_packet() is similar to the
 170 one in the eepro_rx().  The transmit buffer is a ring linked list.
 171 I just queue the next available packet to the end of the list.  In my
 172 system, the 82595 is so fast that the list seems to always contain a
 173 single packet.  In other systems with faster computers and more congested
 174 network traffics, the ring linked list should improve performance by
 175 allowing up to 8K worth of packets to be queued.
 176 
 177 */
 178 #define RAM_SIZE        0x8000
 179 #define RCV_HEADER      8
 180 #define RCV_RAM         0x6000  /* 24KB for RCV buffer */
 181 #define RCV_LOWER_LIMIT 0x00    /* 0x0000 */
 182 #define RCV_UPPER_LIMIT ((RCV_RAM - 2) >> 8)    /* 0x5ffe */
 183 #define XMT_RAM         (RAM_SIZE - RCV_RAM)    /* 8KB for XMT buffer */
 184 #define XMT_LOWER_LIMIT (RCV_RAM >> 8)  /* 0x6000 */
 185 #define XMT_UPPER_LIMIT ((RAM_SIZE - 2) >> 8)   /* 0x7ffe */
 186 #define XMT_HEADER      8
 187 
 188 #define RCV_DONE        0x0008
 189 #define RX_OK           0x2000
 190 #define RX_ERROR        0x0d81
 191 
 192 #define TX_DONE_BIT     0x0080
 193 #define CHAIN_BIT       0x8000
 194 #define XMT_STATUS      0x02
 195 #define XMT_CHAIN       0x04
 196 #define XMT_COUNT       0x06
 197 
 198 #define BANK0_SELECT    0x00            
 199 #define BANK1_SELECT    0x40            
 200 #define BANK2_SELECT    0x80            
 201 
 202 /* Bank 0 registers */
 203 #define COMMAND_REG     0x00    /* Register 0 */
 204 #define MC_SETUP        0x03
 205 #define XMT_CMD         0x04
 206 #define DIAGNOSE_CMD    0x07
 207 #define RCV_ENABLE_CMD  0x08
 208 #define RCV_DISABLE_CMD 0x0a
 209 #define STOP_RCV_CMD    0x0b
 210 #define RESET_CMD       0x0e
 211 #define POWER_DOWN_CMD  0x18
 212 #define RESUME_XMT_CMD  0x1c
 213 #define SEL_RESET_CMD   0x1e
 214 #define STATUS_REG      0x01    /* Register 1 */
 215 #define RX_INT          0x02
 216 #define TX_INT          0x04
 217 #define EXEC_STATUS     0x30
 218 #define ID_REG          0x02    /* Register 2   */
 219 #define R_ROBIN_BITS    0xc0    /* round robin counter */
 220 #define ID_REG_MASK     0x2c
 221 #define ID_REG_SIG      0x24
 222 #define AUTO_ENABLE     0x10
 223 #define INT_MASK_REG    0x03    /* Register 3   */
 224 #define RX_STOP_MASK    0x01
 225 #define RX_MASK         0x02
 226 #define TX_MASK         0x04
 227 #define EXEC_MASK       0x08
 228 #define ALL_MASK        0x0f
 229 #define RCV_BAR         0x04    /* The following are word (16-bit) registers */
 230 #define RCV_STOP        0x06
 231 #define XMT_BAR         0x0a
 232 #define HOST_ADDRESS_REG        0x0c
 233 #define IO_PORT         0x0e
 234 
 235 /* Bank 1 registers */
 236 #define REG1    0x01
 237 #define WORD_WIDTH      0x02
 238 #define INT_ENABLE      0x80
 239 #define INT_NO_REG      0x02
 240 #define RCV_LOWER_LIMIT_REG     0x08
 241 #define RCV_UPPER_LIMIT_REG     0x09
 242 #define XMT_LOWER_LIMIT_REG     0x0a
 243 #define XMT_UPPER_LIMIT_REG     0x0b
 244 
 245 /* Bank 2 registers */
 246 #define XMT_Chain_Int   0x20    /* Interrupt at the end of the transmit chain */
 247 #define XMT_Chain_ErrStop       0x40 /* Interrupt at the end of the chain even if there are errors */
 248 #define RCV_Discard_BadFrame    0x80 /* Throw bad frames away, and continue to receive others */
 249 #define REG2            0x02
 250 #define PRMSC_Mode      0x01
 251 #define Multi_IA        0x20
 252 #define REG3            0x03
 253 #define TPE_BIT         0x04
 254 #define BNC_BIT         0x20
 255         
 256 #define I_ADD_REG0      0x04
 257 #define I_ADD_REG1      0x05
 258 #define I_ADD_REG2      0x06
 259 #define I_ADD_REG3      0x07
 260 #define I_ADD_REG4      0x08
 261 #define I_ADD_REG5      0x09
 262 
 263 #define EEPROM_REG 0x0a
 264 #define EESK 0x01
 265 #define EECS 0x02
 266 #define EEDI 0x04
 267 #define EEDO 0x08
 268 
 269 
 270 /* Check for a network adaptor of this type, and return '0' iff one exists.
 271    If dev->base_addr == 0, probe all likely locations.
 272    If dev->base_addr == 1, always return failure.
 273    If dev->base_addr == 2, allocate space for the device and return success
 274    (detachable devices only).
 275    */
 276 #ifdef HAVE_DEVLIST
 277 /* Support for a alternate probe manager, which will eliminate the
 278    boilerplate below. */
 279 struct netdev_entry netcard_drv =
 280 {"eepro", eepro_probe1, EEPRO_IO_EXTENT, eepro_portlist};
 281 #else
 282 int
 283 eepro_probe(struct device *dev)
     /*  */
 284 {
 285         int i;
 286         int base_addr = dev ? dev->base_addr : 0;
 287 
 288         if (base_addr > 0x1ff)          /* Check a single specified location. */
 289                 return eepro_probe1(dev, base_addr);
 290         else if (base_addr != 0)        /* Don't probe at all. */
 291                 return ENXIO;
 292 
 293         for (i = 0; eepro_portlist[i]; i++) {
 294                 int ioaddr = eepro_portlist[i];
 295                 if (check_region(ioaddr, EEPRO_IO_EXTENT))
 296                         continue;
 297                 if (eepro_probe1(dev, ioaddr) == 0)
 298                         return 0;
 299         }
 300 
 301         return ENODEV;
 302 }
 303 #endif
 304 
 305 /* This is the real probe routine.  Linux has a history of friendly device
 306    probes on the ISA bus.  A good device probes avoids doing writes, and
 307    verifies that the correct device exists and functions.  */
 308 
 309 int eepro_probe1(struct device *dev, short ioaddr)
     /*  */
 310 {
 311         unsigned short station_addr[6], id, counter;
 312         int i;
 313         int eepro;      /* a flag, TRUE=1 for the EtherExpress Pro/10,
 314                            FALSE = 0 for other 82595-based lan cards. */
 315         const char *ifmap[] = {"AUI", "10Base2", "10BaseT"};
 316         enum iftype { AUI=0, BNC=1, TPE=2 };
 317 
 318         /* Now, we are going to check for the signature of the
 319            ID_REG (register 2 of bank 0) */
 320 
 321         if (((id=inb(ioaddr + ID_REG)) & ID_REG_MASK) == ID_REG_SIG) {
 322 
 323                 /* We seem to have the 82595 signature, let's
 324                    play with its counter (last 2 bits of
 325                    register 2 of bank 0) to be sure. */
 326         
 327                 counter = (id & R_ROBIN_BITS);  
 328                 if (((id=inb(ioaddr+ID_REG)) & R_ROBIN_BITS) == 
 329                         (counter + 0x40)) {
 330 
 331                         /* Yes, the 82595 has been found */
 332 
 333                         /* Now, get the ethernet hardware address from
 334                            the EEPROM */
 335 
 336                         station_addr[0] = read_eeprom(ioaddr, 2);
 337                         station_addr[1] = read_eeprom(ioaddr, 3);
 338                         station_addr[2] = read_eeprom(ioaddr, 4);
 339 
 340                         /* Check the station address for the manufacturer's code */
 341 
 342                         if (station_addr[2] != 0x00aa || (station_addr[1] & 0xff00) != 0x0000) {
 343                                 eepro = 0;
 344                                 printk("%s: Intel 82595-based lan card at %#x,", 
 345                                         dev->name, ioaddr);
 346                         }
 347                         else {
 348                                 eepro = 1;
 349                                 printk("%s: Intel EtherExpress Pro/10 at %#x,", 
 350                                         dev->name, ioaddr);
 351                         }
 352 
 353                         /* Fill in the 'dev' fields. */
 354                         dev->base_addr = ioaddr;
 355                         
 356                         for (i=0; i < 6; i++) {
 357                                 dev->dev_addr[i] = ((unsigned char *) station_addr)[5-i];
 358                                 printk("%c%02x", i ? ':' : ' ', dev->dev_addr[i]);
 359                         }
 360                                 
 361                         outb(BANK2_SELECT, ioaddr); /* be CAREFULL, BANK 2 now */
 362                         id = inb(ioaddr + REG3);
 363                         if (id & TPE_BIT)
 364                                 dev->if_port = TPE;
 365                         else dev->if_port = BNC;
 366 
 367                         if (dev->irq < 2 && eepro) {
 368                                 i = read_eeprom(ioaddr, 1);
 369                                 switch (i & 0x07) {
 370                                         case 0: dev->irq = 9; break;
 371                                         case 1: dev->irq = 3; break;
 372                                         case 2: dev->irq = 5; break;
 373                                         case 3: dev->irq = 10; break;
 374                                         case 4: dev->irq = 11; break;
 375                                         default: /* should never get here !!!!! */
 376                                                 printk(" illegal interrupt vector stored in EEPROM.\n");
 377                                                 return ENODEV;
 378                                         }
 379                                 }
 380                         else if (dev->irq == 2)
 381                                 dev->irq = 9;
 382 
 383                         if (dev->irq > 2) {
 384                                 printk(", IRQ %d, %s.\n", dev->irq,
 385                                                 ifmap[dev->if_port]);
 386                                 if (request_irq(dev->irq, &eepro_interrupt, 0, "eepro")) {
 387                                         printk("%s: unable to get IRQ %d.\n", dev->name, dev->irq);
 388                                         return -EAGAIN;
 389                                 }
 390                         }
 391                         else printk(", %s.\n", ifmap[dev->if_port]);
 392                         
 393                         if ((dev->mem_start & 0xf) > 0)
 394                                 net_debug = dev->mem_start & 7;
 395 
 396                         if (net_debug > 3) {
 397                                 i = read_eeprom(ioaddr, 5);
 398                                 if (i & 0x2000) /* bit 13 of EEPROM word 5 */
 399                                         printk("%s: Concurrent Processing is enabled but not used!\n",
 400                                                 dev->name);
 401                         }
 402 
 403                         if (net_debug) 
 404                                 printk(version);
 405 
 406                         /* Grab the region so we can find another board if autoIRQ fails. */
 407                         request_region(ioaddr, EEPRO_IO_EXTENT,"eepro");
 408 
 409                         /* Initialize the device structure */
 410                         if (dev->priv == NULL)
 411                                 dev->priv = kmalloc(sizeof(struct eepro_local), GFP_KERNEL);
 412                         memset(dev->priv, 0, sizeof(struct eepro_local));
 413 
 414                         dev->open = eepro_open;
 415                         dev->stop = eepro_close;
 416                         dev->hard_start_xmit = eepro_send_packet;
 417                         dev->get_stats = eepro_get_stats;
 418                         dev->set_multicast_list = &set_multicast_list;
 419 
 420                         /* Fill in the fields of the device structure with
 421                            ethernet generic values */
 422 
 423                         ether_setup(dev);
 424 
 425                         outb(RESET_CMD, ioaddr); /* RESET the 82595 */
 426 
 427                         return 0;
 428                         }
 429                 else return ENODEV;
 430                 }
 431         else if (net_debug > 3)
 432                 printk ("EtherExpress Pro probed failed!\n");
 433         return ENODEV;
 434 }
 435 
 436 /* Open/initialize the board.  This is called (in the current kernel)
 437    sometime after booting when the 'ifconfig' program is run.
 438 
 439    This routine should set everything up anew at each open, even
 440    registers that "should" only need to be set once at boot, so that
 441    there is non-reboot way to recover if something goes wrong.
 442    */
 443 
 444 static char irqrmap[] = {-1,-1,0,1,-1,2,-1,-1,-1,0,3,4,-1,-1,-1,-1};
 445 static int      eepro_grab_irq(struct device *dev)
     /*  */
 446 {
 447         int irqlist[] = { 5, 9, 10, 11, 4, 3, 0};       
 448         int *irqp = irqlist, temp_reg, ioaddr = dev->base_addr;
 449 
 450         outb(BANK1_SELECT, ioaddr); /* be CAREFULL, BANK 1 now */
 451 
 452         /* Enable the interrupt line. */
 453         temp_reg = inb(ioaddr + REG1);
 454         outb(temp_reg | INT_ENABLE, ioaddr + REG1); 
 455         
 456         outb(BANK0_SELECT, ioaddr); /* be CAREFULL, BANK 0 now */
 457 
 458         /* clear all interrupts */
 459         outb(ALL_MASK, ioaddr + STATUS_REG); 
 460         /* Let EXEC event to interrupt */
 461         outb(ALL_MASK & ~(EXEC_MASK), ioaddr + INT_MASK_REG); 
 462 
 463         do {
 464                 outb(BANK1_SELECT, ioaddr); /* be CAREFULL, BANK 1 now */
 465 
 466                 temp_reg = inb(ioaddr + INT_NO_REG);
 467                 outb((temp_reg & 0xf8) | irqrmap[*irqp], ioaddr + INT_NO_REG); 
 468 
 469                 outb(BANK0_SELECT, ioaddr); /* Switch back to Bank 0 */
 470 
 471                 if (request_irq (*irqp, NULL, 0, "bogus") != EBUSY) {
 472                         /* Twinkle the interrupt, and check if it's seen */
 473                         autoirq_setup(0);
 474 
 475                         outb(DIAGNOSE_CMD, ioaddr); /* RESET the 82595 */
 476                                 
 477                         if (*irqp == autoirq_report(2) &&  /* It's a good IRQ line */
 478                                 (request_irq(dev->irq = *irqp, &eepro_interrupt, 0, "eepro") == 0)) 
 479                                         break;
 480 
 481                         /* clear all interrupts */
 482                         outb(ALL_MASK, ioaddr + STATUS_REG); 
 483                 }
 484         } while (*++irqp);
 485 
 486         outb(BANK1_SELECT, ioaddr); /* Switch back to Bank 1 */
 487 
 488         /* Disable the physical interrupt line. */
 489         temp_reg = inb(ioaddr + REG1);
 490         outb(temp_reg & 0x7f, ioaddr + REG1); 
 491 
 492         outb(BANK0_SELECT, ioaddr); /* Switch back to Bank 0 */
 493 
 494         /* Mask all the interrupts. */
 495         outb(ALL_MASK, ioaddr + INT_MASK_REG); 
 496 
 497         /* clear all interrupts */
 498         outb(ALL_MASK, ioaddr + STATUS_REG); 
 499 
 500         return dev->irq;
 501 }
 502 
 503 static int
 504 eepro_open(struct device *dev)
     /*  */
 505 {
 506         unsigned short temp_reg;
 507         int i, ioaddr = dev->base_addr;
 508         struct eepro_local *lp = (struct eepro_local *)dev->priv;
 509 
 510         if (net_debug > 3)
 511                 printk("eepro: entering eepro_open routine.\n");
 512 
 513         if (dev->dev_addr[0] == SA_ADDR0 &&
 514                         dev->dev_addr[1] == SA_ADDR1 &&
 515                         dev->dev_addr[2] == SA_ADDR2)
 516                 lp->eepro = 1; /* Yes, an Intel EtherExpress Pro/10 */
 517         else lp->eepro = 0; /* No, it is a generic 82585 lan card */
 518 
 519         /* Get the interrupt vector for the 82595 */    
 520         if (dev->irq < 2 && eepro_grab_irq(dev) == 0) {
 521                 printk("%s: unable to get IRQ %d.\n", dev->name, dev->irq);
 522                 return -EAGAIN;
 523         }
 524                                 
 525         if (irq2dev_map[dev->irq] != 0
 526                 || (irq2dev_map[dev->irq] = dev) == 0)
 527                 return -EAGAIN;
 528 
 529         /* Initialize the 82595. */
 530 
 531         outb(BANK2_SELECT, ioaddr); /* be CAREFULL, BANK 2 now */
 532         temp_reg = inb(ioaddr + EEPROM_REG);
 533         if (temp_reg & 0x10) /* Check the TurnOff Enable bit */
 534                 outb(temp_reg & 0xef, ioaddr + EEPROM_REG);
 535         for (i=0; i < 6; i++) 
 536                 outb(dev->dev_addr[i] , ioaddr + I_ADD_REG0 + i); 
 537                         
 538         temp_reg = inb(ioaddr + REG1);    /* Setup Transmit Chaining */
 539         outb(temp_reg | XMT_Chain_Int | XMT_Chain_ErrStop /* and discard bad RCV frames */
 540                 | RCV_Discard_BadFrame, ioaddr + REG1);  
 541 
 542         temp_reg = inb(ioaddr + REG2); /* Match broadcast */
 543         outb(temp_reg | 0x14, ioaddr + REG2);
 544 
 545         temp_reg = inb(ioaddr + REG3);
 546         outb(temp_reg & 0x3f, ioaddr + REG3); /* clear test mode */
 547 
 548         /* Set the receiving mode */
 549         outb(BANK1_SELECT, ioaddr); /* be CAREFULL, BANK 1 now */
 550         
 551         temp_reg = inb(ioaddr + INT_NO_REG);
 552         outb((temp_reg & 0xf8) | irqrmap[dev->irq], ioaddr + INT_NO_REG); 
 553 
 554         /* Initialize the RCV and XMT upper and lower limits */
 555         outb(RCV_LOWER_LIMIT, ioaddr + RCV_LOWER_LIMIT_REG); 
 556         outb(RCV_UPPER_LIMIT, ioaddr + RCV_UPPER_LIMIT_REG); 
 557         outb(XMT_LOWER_LIMIT, ioaddr + XMT_LOWER_LIMIT_REG); 
 558         outb(XMT_UPPER_LIMIT, ioaddr + XMT_UPPER_LIMIT_REG); 
 559 
 560         /* Enable the interrupt line. */
 561         temp_reg = inb(ioaddr + REG1);
 562         outb(temp_reg | INT_ENABLE, ioaddr + REG1); 
 563 
 564         outb(BANK0_SELECT, ioaddr); /* Switch back to Bank 0 */
 565 
 566         /* Let RX and TX events to interrupt */
 567         outb(ALL_MASK & ~(RX_MASK | TX_MASK), ioaddr + INT_MASK_REG); 
 568         /* clear all interrupts */
 569         outb(ALL_MASK, ioaddr + STATUS_REG); 
 570 
 571         /* Initialize RCV */
 572         outw(RCV_LOWER_LIMIT << 8, ioaddr + RCV_BAR); 
 573         lp->rx_start = (RCV_LOWER_LIMIT << 8) ;
 574         outw((RCV_UPPER_LIMIT << 8) | 0xfe, ioaddr + RCV_STOP); 
 575 
 576         /* Initialize XMT */
 577         outw(XMT_LOWER_LIMIT << 8, ioaddr + XMT_BAR); 
 578         
 579         outb(SEL_RESET_CMD, ioaddr);
 580         /* We are supposed to wait for 2 us after a SEL_RESET */
 581         SLOW_DOWN_IO;
 582         SLOW_DOWN_IO;   
 583 
 584         lp->tx_start = lp->tx_end = XMT_LOWER_LIMIT << 8; /* or = RCV_RAM */
 585         lp->tx_last = 0;  
 586         
 587         dev->tbusy = 0;
 588         dev->interrupt = 0;
 589         dev->start = 1;
 590 
 591         if (net_debug > 3)
 592                 printk("eepro: exiting eepro_open routine.\n");
 593 
 594         outb(RCV_ENABLE_CMD, ioaddr);
 595 
 596 #ifdef MODULE
 597         MOD_INC_USE_COUNT;
 598 #endif
 599         return 0;
 600 }
 601 
 602 static int
 603 eepro_send_packet(struct sk_buff *skb, struct device *dev)
     /*  */
 604 {
 605         struct eepro_local *lp = (struct eepro_local *)dev->priv;
 606         int ioaddr = dev->base_addr;
 607 
 608         if (net_debug > 5)
 609                 printk("eepro: entering eepro_send_packet routine.\n");
 610         
 611         if (dev->tbusy) {
 612                 /* If we get here, some higher level has decided we are broken.
 613                    There should really be a "kick me" function call instead. */
 614                 int tickssofar = jiffies - dev->trans_start;
 615                 if (tickssofar < 5)
 616                         return 1;
 617                 if (net_debug > 1)
 618                         printk("%s: transmit timed out, %s?\n", dev->name,
 619                                    "network cable problem");
 620                 lp->stats.tx_errors++;
 621                 /* Try to restart the adaptor. */
 622                 outb(SEL_RESET_CMD, ioaddr); 
 623                 /* We are supposed to wait for 2 us after a SEL_RESET */
 624                 SLOW_DOWN_IO;
 625                 SLOW_DOWN_IO;
 626 
 627                 /* Do I also need to flush the transmit buffers here? YES? */
 628                 lp->tx_start = lp->tx_end = RCV_RAM; 
 629                 lp->tx_last = 0;
 630         
 631                 dev->tbusy=0;
 632                 dev->trans_start = jiffies;
 633 
 634                 outb(RCV_ENABLE_CMD, ioaddr);
 635 
 636         }
 637 
 638         /* If some higher layer thinks we've missed an tx-done interrupt
 639            we are passed NULL. Caution: dev_tint() handles the cli()/sti()
 640            itself. */
 641         if (skb == NULL) {
 642                 dev_tint(dev);
 643                 return 0;
 644         }
 645 
 646         /* Block a timer-based transmit from overlapping. */
 647         if (set_bit(0, (void*)&dev->tbusy) != 0)
 648                 printk("%s: Transmitter access conflict.\n", dev->name);
 649         else {
 650                 short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN;
 651                 unsigned char *buf = skb->data;
 652 
 653                 hardware_send_packet(dev, buf, length);
 654                 dev->trans_start = jiffies;
 655         }
 656 
 657         dev_kfree_skb (skb, FREE_WRITE);
 658 
 659         /* You might need to clean up and record Tx statistics here. */
 660         /* lp->stats.tx_aborted_errors++; */
 661 
 662         if (net_debug > 5)
 663                 printk("eepro: exiting eepro_send_packet routine.\n");
 664         
 665         return 0;
 666 }
 667 
 668 
 669 /*      The typical workload of the driver:
 670         Handle the network interface interrupts. */
 671 static void
 672 eepro_interrupt(int irq, struct pt_regs * regs)
     /*  */
 673 {
 674         struct device *dev = (struct device *)(irq2dev_map[irq]);
 675         int ioaddr, status, boguscount = 0;
 676 
 677         if (net_debug > 5)
 678                 printk("eepro: entering eepro_interrupt routine.\n");
 679         
 680         if (dev == NULL) {
 681                 printk ("eepro_interrupt(): irq %d for unknown device.\n", irq);
 682                 return;
 683         }
 684         dev->interrupt = 1;
 685         
 686         ioaddr = dev->base_addr;
 687 
 688         do { 
 689                 status = inb(ioaddr + STATUS_REG);
 690 
 691                 if (status & RX_INT) {
 692                         if (net_debug > 4)
 693                                 printk("eepro: packet received interrupt.\n");
 694 
 695                         /* Acknowledge the RX_INT */
 696                         outb(RX_INT, ioaddr + STATUS_REG); 
 697 
 698                         /* Get the received packets */
 699                         eepro_rx(dev);
 700                 }
 701                 else if (status & TX_INT) {
 702                         if (net_debug > 4)
 703                                 printk("eepro: packet transmit interrupt.\n");
 704 
 705                         /* Acknowledge the TX_INT */
 706                         outb(TX_INT, ioaddr + STATUS_REG); 
 707 
 708                         /* Process the status of transmitted packets */
 709                         eepro_transmit_interrupt(dev);
 710                         dev->tbusy = 0;
 711                         mark_bh(NET_BH);
 712                 }               
 713         } while ((++boguscount < 10) && (status & 0x06));
 714 
 715         dev->interrupt = 0;
 716         if (net_debug > 5)
 717                 printk("eepro: exiting eepro_interrupt routine.\n");
 718         
 719         return;
 720 }
 721 
 722 static int
 723 eepro_close(struct device *dev)
     /*  */
 724 {
 725         struct eepro_local *lp = (struct eepro_local *)dev->priv;
 726         int ioaddr = dev->base_addr;
 727         short temp_reg;
 728 
 729         dev->tbusy = 1;
 730         dev->start = 0;
 731 
 732         outb(BANK1_SELECT, ioaddr); /* Switch back to Bank 1 */
 733 
 734         /* Disable the physical interrupt line. */
 735         temp_reg = inb(ioaddr + REG1);
 736         outb(temp_reg & 0x7f, ioaddr + REG1); 
 737 
 738         outb(BANK0_SELECT, ioaddr); /* Switch back to Bank 0 */
 739 
 740         /* Flush the Tx and disable Rx. */
 741         outb(STOP_RCV_CMD, ioaddr); 
 742         lp->tx_start = lp->tx_end = RCV_RAM ;
 743         lp->tx_last = 0;  
 744 
 745         /* Mask all the interrupts. */
 746         outb(ALL_MASK, ioaddr + INT_MASK_REG); 
 747 
 748         /* clear all interrupts */
 749         outb(ALL_MASK, ioaddr + STATUS_REG); 
 750 
 751         /* Reset the 82595 */
 752         outb(RESET_CMD, ioaddr); 
 753 
 754         /* release the interrupt */
 755         free_irq(dev->irq);
 756 
 757         irq2dev_map[dev->irq] = 0;
 758 
 759         /* release the ioport-region */
 760         release_region(ioaddr, 16);
 761 
 762         /* Update the statistics here. What statistics? */
 763 
 764         /* We are supposed to wait for 200 us after a RESET */
 765         SLOW_DOWN_IO;
 766         SLOW_DOWN_IO; /* May not be enough? */
 767 
 768 #ifdef MODULE
 769         MOD_DEC_USE_COUNT;
 770 #endif
 771         return 0;
 772 }
 773 
 774 /* Get the current statistics.  This may be called with the card open or
 775    closed. */
 776 static struct enet_statistics *
 777 eepro_get_stats(struct device *dev)
     /*  */
 778 {
 779         struct eepro_local *lp = (struct eepro_local *)dev->priv;
 780 
 781         return &lp->stats;
 782 }
 783 
 784 /* Set or clear the multicast filter for this adaptor.
 785    num_addrs == -1      Promiscuous mode, receive all packets
 786    num_addrs == 0       Normal mode, clear multicast list
 787    num_addrs > 0        Multicast mode, receive normal and MC packets, and do
 788                         best-effort filtering.
 789  */
 790 static void
 791 set_multicast_list(struct device *dev, int num_addrs, void *addrs)
     /*  */
 792 {
 793         struct eepro_local *lp = (struct eepro_local *)dev->priv;
 794         short ioaddr = dev->base_addr;
 795         unsigned short mode;
 796 
 797         if (num_addrs < -1 || num_addrs > 63) {
 798                 outb(BANK2_SELECT, ioaddr); /* be CAREFULL, BANK 2 now */
 799                 mode = inb(ioaddr + REG2);
 800                 outb(mode | PRMSC_Mode, ioaddr + REG2); 
 801                 mode = inb(ioaddr + REG3);
 802                 outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
 803                 outb(BANK0_SELECT, ioaddr); /* Return to BANK 0 now */
 804                 printk("%s: promiscuous mode enabled.\n", dev->name);
 805         } 
 806         else if (num_addrs == 0) {
 807                 outb(BANK2_SELECT, ioaddr); /* be CAREFULL, BANK 2 now */
 808                 mode = inb(ioaddr + REG2);
 809                 outb(mode & 0xd6, ioaddr + REG2); /* Turn off Multi-IA and PRMSC_Mode bits */
 810                 mode = inb(ioaddr + REG3);
 811                 outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
 812                 outb(BANK0_SELECT, ioaddr); /* Return to BANK 0 now */
 813         }
 814         else {
 815                 unsigned short status, *eaddrs = addrs;
 816                 int i, boguscount = 0;
 817                 
 818                 /* Disable RX and TX interrupts.  Neccessary to avoid
 819                    corruption of the HOST_ADDRESS_REG by interrupt
 820                    service routines. */
 821                 outb(ALL_MASK, ioaddr + INT_MASK_REG);
 822 
 823                 outb(BANK2_SELECT, ioaddr); /* be CAREFULL, BANK 2 now */
 824                 mode = inb(ioaddr + REG2);
 825                 outb(mode | Multi_IA, ioaddr + REG2);   
 826                 mode = inb(ioaddr + REG3);
 827                 outb(mode, ioaddr + REG3); /* writing reg. 3 to complete the update */
 828                 outb(BANK0_SELECT, ioaddr); /* Return to BANK 0 now */
 829                 outw(lp->tx_end, ioaddr + HOST_ADDRESS_REG);
 830                 outw(MC_SETUP, ioaddr + IO_PORT);
 831                 outw(0, ioaddr + IO_PORT);
 832                 outw(0, ioaddr + IO_PORT);
 833                 outw(6*(num_addrs + 1), ioaddr + IO_PORT);
 834                 for (i = 0; i < num_addrs; i++) {
 835                         outw(*eaddrs++, ioaddr + IO_PORT);
 836                         outw(*eaddrs++, ioaddr + IO_PORT);
 837                         outw(*eaddrs++, ioaddr + IO_PORT);
 838                 }
 839                 eaddrs = (unsigned short *) dev->dev_addr;
 840                 outw(eaddrs[0], ioaddr + IO_PORT);
 841                 outw(eaddrs[1], ioaddr + IO_PORT);
 842                 outw(eaddrs[2], ioaddr + IO_PORT);
 843                 outw(lp->tx_end, ioaddr + XMT_BAR);
 844                 outb(MC_SETUP, ioaddr);
 845 
 846                 /* Update the transmit queue */
 847                 i = lp->tx_end + XMT_HEADER + 6*(num_addrs + 1);
 848                 if (lp->tx_start != lp->tx_end) { 
 849                         /* update the next address and the chain bit in the 
 850                            last packet */
 851                         outw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
 852                         outw(i, ioaddr + IO_PORT);
 853                         outw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
 854                         status = inw(ioaddr + IO_PORT);
 855                         outw(status | CHAIN_BIT, ioaddr + IO_PORT);
 856                         lp->tx_end = i ;
 857                 } else lp->tx_start = lp->tx_end = i ;
 858 
 859                 /* Acknowledge that the MC setup is done */
 860                 do { /* We should be doing this in the eepro_interrupt()! */
 861                         SLOW_DOWN_IO;
 862                         SLOW_DOWN_IO;
 863                         if (inb(ioaddr + STATUS_REG) & 0x08) {
 864                                 i = inb(ioaddr);
 865                                 outb(0x08, ioaddr + STATUS_REG);
 866                                 if (i & 0x20) { /* command ABORTed */
 867                                         printk("%s: multicast setup failed.\n", 
 868                                                 dev->name);
 869                                         break;
 870                                 } else if ((i & 0x0f) == 0x03)  { /* MC-Done */
 871                                         printk("%s: set Rx mode to %d addresses.\n", 
 872                                                 dev->name, num_addrs);
 873                                         break;
 874                                 }
 875                         }
 876                 } while (++boguscount < 100);
 877 
 878                 /* Re-enable RX and TX interrupts */
 879                 outb(ALL_MASK & ~(RX_MASK | TX_MASK), ioaddr + INT_MASK_REG); 
 880         
 881         }
 882         outb(RCV_ENABLE_CMD, ioaddr);
 883 }
 884 
 885 /* The horrible routine to read a word from the serial EEPROM. */
 886 /* IMPORTANT - the 82595 will be set to Bank 0 after the eeprom is read */
 887 
 888 /* The delay between EEPROM clock transitions. */
 889 #define eeprom_delay()  { int _i = 40; while (--_i > 0) { __SLOW_DOWN_IO; }}
 890 #define EE_READ_CMD (6 << 6)
 891 
 892 int
 893 read_eeprom(int ioaddr, int location)
     /*  */
 894 {
 895         int i;
 896         unsigned short retval = 0;
 897         short ee_addr = ioaddr + EEPROM_REG;
 898         int read_cmd = location | EE_READ_CMD;
 899         short ctrl_val = EECS ;
 900         
 901         outb(BANK2_SELECT, ioaddr);
 902         outb(ctrl_val, ee_addr);
 903         
 904         /* Shift the read command bits out. */
 905         for (i = 8; i >= 0; i--) {
 906                 short outval = (read_cmd & (1 << i)) ? ctrl_val | EEDI
 907                         : ctrl_val;
 908                 outb(outval, ee_addr);
 909                 outb(outval | EESK, ee_addr);   /* EEPROM clock tick. */
 910                 eeprom_delay();
 911                 outb(outval, ee_addr);  /* Finish EEPROM a clock tick. */
 912                 eeprom_delay();
 913         }
 914         outb(ctrl_val, ee_addr);
 915         
 916         for (i = 16; i > 0; i--) {
 917                 outb(ctrl_val | EESK, ee_addr);  eeprom_delay();
 918                 retval = (retval << 1) | ((inb(ee_addr) & EEDO) ? 1 : 0);
 919                 outb(ctrl_val, ee_addr);  eeprom_delay();
 920         }
 921 
 922         /* Terminate the EEPROM access. */
 923         ctrl_val &= ~EECS;
 924         outb(ctrl_val | EESK, ee_addr);
 925         eeprom_delay();
 926         outb(ctrl_val, ee_addr);
 927         eeprom_delay();
 928         outb(BANK0_SELECT, ioaddr);
 929         return retval;
 930 }
 931 
 932 static void
 933 hardware_send_packet(struct device *dev, void *buf, short length)
     /*  */
 934 {
 935         struct eepro_local *lp = (struct eepro_local *)dev->priv;
 936         short ioaddr = dev->base_addr;
 937         unsigned status, tx_available, last, end, boguscount = 10;
 938 
 939         if (net_debug > 5)
 940                 printk("eepro: entering hardware_send_packet routine.\n");
 941 
 942         while (boguscount-- > 0) {
 943 
 944                 /* determine how much of the transmit buffer space is available */
 945                 if (lp->tx_end > lp->tx_start)
 946                         tx_available = XMT_RAM - (lp->tx_end - lp->tx_start);
 947                 else if (lp->tx_end < lp->tx_start)
 948                         tx_available = lp->tx_start - lp->tx_end;
 949                 else tx_available = XMT_RAM;
 950 
 951                 /* Disable RX and TX interrupts.  Neccessary to avoid
 952                    corruption of the HOST_ADDRESS_REG by interrupt
 953                    service routines. */
 954                 outb(ALL_MASK, ioaddr + INT_MASK_REG);
 955 
 956                 if (((((length + 1) >> 1) << 1) + 2*XMT_HEADER) 
 957                         >= tx_available)   /* No space available ??? */
 958                         continue;
 959 
 960                 last = lp->tx_end;
 961                 end = last + (((length + 1) >> 1) << 1) + XMT_HEADER;
 962 
 963                 if (end >= RAM_SIZE) { /* the transmit buffer is wrapped around */
 964                         if ((RAM_SIZE - last) <= XMT_HEADER) {  
 965                         /* Arrrr!!!, must keep the xmt header together,
 966                           several days were lost to chase this one down. */
 967                                 last = RCV_RAM;
 968                                 end = last + (((length + 1) >> 1) << 1) + XMT_HEADER;
 969                         }       
 970                         else end = RCV_RAM + (end - RAM_SIZE);
 971                 }
 972 
 973                 outw(last, ioaddr + HOST_ADDRESS_REG);
 974                 outw(XMT_CMD, ioaddr + IO_PORT);
 975                 outw(0, ioaddr + IO_PORT);
 976                 outw(end, ioaddr + IO_PORT);
 977                 outw(length, ioaddr + IO_PORT);
 978                 outsw(ioaddr + IO_PORT, buf, (length + 1) >> 1);
 979 
 980                 if (lp->tx_start != lp->tx_end) { 
 981                         /* update the next address and the chain bit in the 
 982                            last packet */
 983                         if (lp->tx_end != last) {
 984                                 outw(lp->tx_last + XMT_CHAIN, ioaddr + HOST_ADDRESS_REG);
 985                                 outw(last, ioaddr + IO_PORT);
 986                         }
 987                         outw(lp->tx_last + XMT_COUNT, ioaddr + HOST_ADDRESS_REG);
 988                         status = inw(ioaddr + IO_PORT);
 989                         outw(status | CHAIN_BIT, ioaddr + IO_PORT);
 990                 }
 991 
 992                 /* A dummy read to flush the DRAM write pipeline */
 993                 status = inw(ioaddr + IO_PORT); 
 994 
 995                 /* Enable RX and TX interrupts */
 996                 outb(ALL_MASK & ~(RX_MASK | TX_MASK), ioaddr + INT_MASK_REG); 
 997         
 998                 if (lp->tx_start == lp->tx_end) {
 999                         outw(last, ioaddr + XMT_BAR);
1000                         outb(XMT_CMD, ioaddr);
1001                         lp->tx_start = last;   /* I don't like to change tx_start here */
1002                 }
1003                 else    outb(RESUME_XMT_CMD, ioaddr);
1004 
1005                 lp->tx_last = last;
1006                 lp->tx_end = end;
1007 
1008                 if (dev->tbusy) {
1009                         dev->tbusy = 0;
1010                         mark_bh(NET_BH);
1011                 }
1012 
1013                 if (net_debug > 5)
1014                         printk("eepro: exiting hardware_send_packet routine.\n");
1015                 return;
1016         }
1017         dev->tbusy = 1;
1018         if (net_debug > 5)
1019                 printk("eepro: exiting hardware_send_packet routine.\n");
1020 }
1021 
1022 static void
1023 eepro_rx(struct device *dev)
     /*  */
1024 {
1025         struct eepro_local *lp = (struct eepro_local *)dev->priv;
1026         short ioaddr = dev->base_addr;
1027         short boguscount = 20;
1028         short rcv_car = lp->rx_start;
1029         unsigned rcv_event, rcv_status, rcv_next_frame, rcv_size;
1030 
1031         if (net_debug > 5)
1032                 printk("eepro: entering eepro_rx routine.\n");
1033         
1034         /* Set the read pointer to the start of the RCV */
1035         outw(rcv_car, ioaddr + HOST_ADDRESS_REG);
1036         rcv_event = inw(ioaddr + IO_PORT);
1037 
1038         while (rcv_event == RCV_DONE) {
1039                 rcv_status = inw(ioaddr + IO_PORT);
1040                 rcv_next_frame = inw(ioaddr + IO_PORT);
1041                 rcv_size = inw(ioaddr + IO_PORT);
1042 
1043                 if ((rcv_status & (RX_OK | RX_ERROR)) == RX_OK) {
1044                         /* Malloc up new buffer. */
1045                         struct sk_buff *skb;
1046 
1047                         rcv_size &= 0x3fff;
1048                         skb = dev_alloc_skb(rcv_size+2);
1049                         if (skb == NULL) {
1050                                 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
1051                                 lp->stats.rx_dropped++;
1052                                 break;
1053                         }
1054                         skb->dev = dev;
1055                         skb_reserve(skb,2);
1056 
1057                         insw(ioaddr+IO_PORT, skb_put(skb,rcv_size), (rcv_size + 1) >> 1);
1058         
1059                         skb->protocol = eth_type_trans(skb,dev);        
1060                         netif_rx(skb);
1061                         lp->stats.rx_packets++;
1062                 }
1063                 else { /* Not sure will ever reach here, 
1064                           I set the 595 to discard bad received frames */
1065                         lp->stats.rx_errors++;
1066                         if (rcv_status & 0x0100)
1067                                 lp->stats.rx_over_errors++;
1068                         else if (rcv_status & 0x0400)
1069                                 lp->stats.rx_frame_errors++;
1070                         else if (rcv_status & 0x0800)
1071                                 lp->stats.rx_crc_errors++;
1072                         printk("%s: event = %#x, status = %#x, next = %#x, size = %#x\n", 
1073                                 dev->name, rcv_event, rcv_status, rcv_next_frame, rcv_size);
1074                 }
1075                 if (rcv_status & 0x1000)
1076                         lp->stats.rx_length_errors++;
1077                 if (--boguscount == 0)
1078                         break;
1079 
1080                 rcv_car = lp->rx_start + RCV_HEADER + rcv_size;
1081                 lp->rx_start = rcv_next_frame;
1082                 outw(rcv_next_frame, ioaddr + HOST_ADDRESS_REG);
1083                 rcv_event = inw(ioaddr + IO_PORT);
1084 
1085         } 
1086         if (rcv_car == 0)
1087                 rcv_car = (RCV_UPPER_LIMIT << 8) | 0xff;
1088         outw(rcv_car - 1, ioaddr + RCV_STOP);
1089 
1090         if (net_debug > 5)
1091                 printk("eepro: exiting eepro_rx routine.\n");
1092 }
1093 
1094 static void
1095 eepro_transmit_interrupt(struct device *dev)
     /*  */
1096 {
1097         struct eepro_local *lp = (struct eepro_local *)dev->priv;
1098         short ioaddr = dev->base_addr;
1099         short boguscount = 10; 
1100         short xmt_status;
1101 
1102         while (lp->tx_start != lp->tx_end) { 
1103 
1104                 outw(lp->tx_start, ioaddr + HOST_ADDRESS_REG);
1105                 xmt_status = inw(ioaddr+IO_PORT);
1106                 if ((xmt_status & TX_DONE_BIT) == 0) break;
1107                 xmt_status = inw(ioaddr+IO_PORT);
1108                 lp->tx_start = inw(ioaddr+IO_PORT);
1109         
1110                 if (dev->tbusy) {
1111                         dev->tbusy = 0;
1112                         mark_bh(NET_BH);
1113                 }
1114 
1115                 if (xmt_status & 0x2000)
1116                         lp->stats.tx_packets++;
1117                 else {
1118                         lp->stats.tx_errors++;
1119                         if (xmt_status & 0x0400)
1120                                 lp->stats.tx_carrier_errors++;
1121                         printk("%s: XMT status = %#x\n",
1122                                 dev->name, xmt_status);
1123                 }
1124                 if (xmt_status & 0x000f)
1125                         lp->stats.collisions += (xmt_status & 0x000f);
1126                 if ((xmt_status & 0x0040) == 0x0)
1127                         lp->stats.tx_heartbeat_errors++;
1128 
1129                 if (--boguscount == 0)
1130                         break;  
1131         }
1132 }
1133 
1134 #ifdef MODULE
1135 char kernel_version[] = UTS_RELEASE;
1136 static struct device dev_eepro = {
1137         "        " /*"eepro"*/, 0, 0, 0, 0, 0, 0, 0, 0, 0, NULL, eepro_probe };
1138 
1139 int io = 0x200;
1140 int irq = 0;
1141 
1142 int
1143 init_module(void)
     /*  */
1144 {
1145         if (io == 0)
1146           printk("eepro: You should not use auto-probing with insmod!\n");
1147         dev_eepro.base_addr = io;
1148         dev_eepro.irq       = irq;
1149 
1150         if (register_netdev(&dev_eepro) != 0)
1151                 return -EIO;
1152         return 0;
1153 }
1154 
1155 void
1156 cleanup_module(void)
     /*  */
1157 {
1158         if (MOD_IN_USE)
1159                 printk("eepro: device busy, remove delayed\n");
1160         else
1161         {
1162                 unregister_netdev(&dev_eepro);
1163                 kfree_s(dev_eepro.priv,sizeof(struct eepro_local));
1164                 dev_eepro.priv=NULL;
1165         }
1166 }
1167 #endif /* MODULE */
/* */
root/drivers/net/eepro.c

DEFINITIONS
