![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to eepro.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net|
Return to eepro.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net |
1.1 ! root 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 [email protected] ! 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 ([email protected])\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, 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")) { ! 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") != 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") == 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, 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); ! 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 */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.