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

DEFINITIONS
