![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to tulip.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 tulip.c CVS log | Up to [GnuMach] / Gnu-Mach / i386 / i386at / gpl / linux / net |
1.1 ! root 1: /* tulip.c: A DEC 21040 ethernet driver for linux. */ ! 2: /* ! 3: NOTICE: this version works with kernels 1.1.82 and later only! ! 4: Written 1994,1995 by Donald Becker. ! 5: ! 6: This software may be used and distributed according to the terms ! 7: of the GNU Public License, incorporated herein by reference. ! 8: ! 9: This driver is for the SMC EtherPower PCI ethernet adapter. ! 10: It should work with most other DEC 21*40-based ethercards. ! 11: ! 12: The author may be reached as [email protected], or C/O ! 13: Center of Excellence in Space Data and Information Sciences ! 14: Code 930.5, Goddard Space Flight Center, Greenbelt MD 20771 ! 15: */ ! 16: ! 17: static const char *version = "tulip.c:v0.05 1/20/95 [email protected]\n"; ! 18: ! 19: #include <linux/module.h> ! 20: ! 21: #include <linux/kernel.h> ! 22: #include <linux/sched.h> ! 23: #include <linux/string.h> ! 24: #include <linux/ptrace.h> ! 25: #include <linux/errno.h> ! 26: #include <linux/ioport.h> ! 27: #include <linux/malloc.h> ! 28: #include <linux/interrupt.h> ! 29: #include <linux/pci.h> ! 30: #include <linux/bios32.h> ! 31: #include <asm/bitops.h> ! 32: #include <asm/io.h> ! 33: #include <asm/dma.h> ! 34: ! 35: #include <linux/netdevice.h> ! 36: #include <linux/etherdevice.h> ! 37: #include <linux/skbuff.h> ! 38: ! 39: /* The total size is unusually large: The 21040 aligns each of its 16 ! 40: longword-wide registers on a quadword boundary. */ ! 41: #define TULIP_TOTAL_SIZE 0x80 ! 42: ! 43: #ifdef HAVE_DEVLIST ! 44: struct netdev_entry tulip_drv = ! 45: {"Tulip", tulip_pci_probe, TULIP_TOTAL_SIZE, NULL}; ! 46: #endif ! 47: ! 48: #define TULIP_DEBUG 1 ! 49: #ifdef TULIP_DEBUG ! 50: int tulip_debug = TULIP_DEBUG; ! 51: #else ! 52: int tulip_debug = 1; ! 53: #endif ! 54: ! 55: /* ! 56: Theory of Operation ! 57: ! 58: I. Board Compatibility ! 59: ! 60: This device driver is designed for the DECchip 21040 "Tulip", Digital's ! 61: single-chip ethernet controller for PCI, as used on the SMC EtherPower ! 62: ethernet adapter. ! 63: ! 64: II. Board-specific settings ! 65: ! 66: PCI bus devices are configured by the system at boot time, so no jumpers ! 67: need to be set on the board. The system BIOS should be set to assign the ! 68: PCI INTA signal to an otherwise unused system IRQ line. While it's ! 69: physically possible to shared PCI interrupt lines, the kernel doesn't ! 70: support it. ! 71: ! 72: III. Driver operation ! 73: ! 74: IIIa. Ring buffers ! 75: The Tulip can use either ring buffers or lists of Tx and Rx descriptors. ! 76: The current driver uses a statically allocated Rx ring of descriptors and ! 77: buffers, and a list of the Tx buffers. ! 78: ! 79: IIIC. Synchronization ! 80: The driver runs as two independent, single-threaded flows of control. One ! 81: is the send-packet routine, which enforces single-threaded use by the ! 82: dev->tbusy flag. The other thread is the interrupt handler, which is single ! 83: threaded by the hardware and other software. ! 84: ! 85: The send packet thread has partial control over the Tx ring and 'dev->tbusy' ! 86: flag. It sets the tbusy flag whenever it's queuing a Tx packet. If the next ! 87: queue slot is empty, it clears the tbusy flag when finished otherwise it sets ! 88: the 'tp->tx_full' flag. ! 89: ! 90: The interrupt handler has exclusive control over the Rx ring and records stats ! 91: from the Tx ring. (The Tx-done interrupt can't be selectively turned off, so ! 92: we can't avoid the interrupt overhead by having the Tx routine reap the Tx ! 93: stats.) After reaping the stats, it marks the queue entry as empty by setting ! 94: the 'base' to zero. Iff the 'tp->tx_full' flag is set, it clears both the ! 95: tx_full and tbusy flags. ! 96: ! 97: IV. Notes ! 98: ! 99: Thanks to Duke Kamstra of SMC for providing an EtherPower board. ! 100: ! 101: The DEC databook doesn't document which Rx filter settings accept broadcast ! 102: packets. Nor does it document how to configure the part to configure the ! 103: serial subsystem for normal (vs. loopback) operation or how to have it ! 104: autoswitch between internal 10baseT, SIA and AUI transceivers. ! 105: ! 106: The databook claims that CSR13, CSR14, and CSR15 should each be the last ! 107: register of the set CSR12-15 written. Hmmm, now how is that possible? ! 108: */ ! 109: ! 110: #define DEC_VENDOR_ID 0x1011 /* Hex 'D' :-> */ ! 111: #define DEC_21040_ID 0x0002 /* Change for 21140. */ ! 112: ! 113: /* Keep the ring sizes a power of two for efficiency. */ ! 114: #define TX_RING_SIZE 4 ! 115: #define RX_RING_SIZE 4 ! 116: #define PKT_BUF_SZ 1536 /* Size of each temporary Rx buffer.*/ ! 117: ! 118: /* Offsets to the Command and Status Registers, "CSRs". All accesses ! 119: must be longword instructions and quadword aligned. */ ! 120: enum tulip_offsets { ! 121: CSR0=0, CSR1=0x08, CSR2=0x10, CSR3=0x18, CSR4=0x20, CSR5=0x28, ! 122: CSR6=0x30, CSR7=0x38, CSR8=0x40, CSR9=0x48, CSR10=0x50, CSR11=0x58, ! 123: CSR12=0x60, CSR13=0x68, CSR14=0x70, CSR15=0x78 }; ! 124: ! 125: /* The Tulip Rx and Tx buffer descriptors. */ ! 126: struct tulip_rx_desc { ! 127: int status; ! 128: int length; ! 129: char *buffer1, *buffer2; /* We use only buffer 1. */ ! 130: }; ! 131: ! 132: struct tulip_tx_desc { ! 133: int status; ! 134: int length; ! 135: char *buffer1, *buffer2; /* We use only buffer 1. */ ! 136: }; ! 137: ! 138: struct tulip_private { ! 139: char devname[8]; /* Used only for kernel debugging. */ ! 140: struct tulip_rx_desc rx_ring[RX_RING_SIZE]; ! 141: struct tulip_tx_desc tx_ring[TX_RING_SIZE]; ! 142: /* The saved address of a sent-in-place packet/buffer, for skfree(). */ ! 143: struct sk_buff* tx_skbuff[TX_RING_SIZE]; ! 144: long rx_buffs; /* Address of temporary Rx buffers. */ ! 145: struct enet_statistics stats; ! 146: int setup_frame[48]; /* Pseudo-Tx frame to init address table. */ ! 147: unsigned int cur_rx, cur_tx; /* The next free ring entry */ ! 148: unsigned int dirty_rx, dirty_tx; /* The ring entries to be free()ed. */ ! 149: unsigned int tx_full:1; ! 150: int pad0, pad1; /* Used for 8-byte alignment */ ! 151: }; ! 152: ! 153: static void tulip_probe1(int ioaddr, int irq); ! 154: static int tulip_open(struct device *dev); ! 155: static void tulip_init_ring(struct device *dev); ! 156: static int tulip_start_xmit(struct sk_buff *skb, struct device *dev); ! 157: static int tulip_rx(struct device *dev); ! 158: static void tulip_interrupt(int irq, struct pt_regs *regs); ! 159: static int tulip_close(struct device *dev); ! 160: static struct enet_statistics *tulip_get_stats(struct device *dev); ! 161: static void set_multicast_list(struct device *dev); ! 162: static int set_mac_address(struct device *dev, void *addr); ! 163: ! 164: ! 165: ! 166: #ifndef MODULE ! 167: /* This 21040 probe is unlike most other board probes. We can use memory ! 168: efficiently by allocating a large contiguous region and dividing it ! 169: ourselves. This is done by having the initialization occur before ! 170: the 'kmalloc()' memory management system is started. */ ! 171: ! 172: int dec21040_init(void) ! 173: { ! 174: ! 175: if (pcibios_present()) { ! 176: int pci_index; ! 177: for (pci_index = 0; pci_index < 8; pci_index++) { ! 178: unsigned char pci_bus, pci_device_fn, pci_irq_line; ! 179: unsigned long pci_ioaddr; ! 180: ! 181: if (pcibios_find_device (DEC_VENDOR_ID, DEC_21040_ID, pci_index, ! 182: &pci_bus, &pci_device_fn) != 0) ! 183: break; ! 184: pcibios_read_config_byte(pci_bus, pci_device_fn, ! 185: PCI_INTERRUPT_LINE, &pci_irq_line); ! 186: pcibios_read_config_dword(pci_bus, pci_device_fn, ! 187: PCI_BASE_ADDRESS_0, &pci_ioaddr); ! 188: /* Remove I/O space marker in bit 0. */ ! 189: pci_ioaddr &= ~3; ! 190: if (tulip_debug > 2) ! 191: printk("Found DEC PCI Tulip at I/O %#lx, IRQ %d.\n", ! 192: pci_ioaddr, pci_irq_line); ! 193: tulip_probe1(pci_ioaddr, pci_irq_line); ! 194: } ! 195: } ! 196: ! 197: return 0; ! 198: } ! 199: #endif ! 200: #ifdef MODULE ! 201: static int tulip_probe(struct device *dev) ! 202: { ! 203: printk("tulip: This driver does not yet install properly from module!\n"); ! 204: return -1; ! 205: } ! 206: #endif ! 207: ! 208: static void tulip_probe1(int ioaddr, int irq) ! 209: { ! 210: static int did_version = 0; /* Already printed version info. */ ! 211: struct device *dev; ! 212: struct tulip_private *tp; ! 213: int i; ! 214: ! 215: if (tulip_debug > 0 && did_version++ == 0) ! 216: printk(version); ! 217: ! 218: dev = init_etherdev(0, 0); ! 219: ! 220: printk("%s: DEC 21040 Tulip at %#3x,", dev->name, ioaddr); ! 221: ! 222: /* Stop the chip's Tx and Rx processes. */ ! 223: outl(inl(ioaddr + CSR6) & ~0x2002, ioaddr + CSR6); ! 224: /* Clear the missed-packet counter. */ ! 225: inl(ioaddr + CSR8) & 0xffff; ! 226: ! 227: /* The station address ROM is read byte serially. The register must ! 228: be polled, waiting for the value to be read bit serially from the ! 229: EEPROM. ! 230: */ ! 231: outl(0, ioaddr + CSR9); /* Reset the pointer with a dummy write. */ ! 232: for (i = 0; i < 6; i++) { ! 233: int value, boguscnt = 100000; ! 234: do ! 235: value = inl(ioaddr + CSR9); ! 236: while (value < 0 && --boguscnt > 0); ! 237: printk(" %2.2x", dev->dev_addr[i] = value); ! 238: } ! 239: printk(", IRQ %d\n", irq); ! 240: ! 241: /* We do a request_region() only to register /proc/ioports info. */ ! 242: request_region(ioaddr, TULIP_TOTAL_SIZE, "DEC Tulip Ethernet"); ! 243: ! 244: dev->base_addr = ioaddr; ! 245: dev->irq = irq; ! 246: ! 247: /* Make certain the data structures are quadword aligned. */ ! 248: tp = kmalloc(sizeof(*tp), GFP_KERNEL | GFP_DMA); ! 249: dev->priv = tp; ! 250: tp->rx_buffs = kmalloc(PKT_BUF_SZ*RX_RING_SIZE, GFP_KERNEL | GFP_DMA); ! 251: ! 252: /* The Tulip-specific entries in the device structure. */ ! 253: dev->open = &tulip_open; ! 254: dev->hard_start_xmit = &tulip_start_xmit; ! 255: dev->stop = &tulip_close; ! 256: dev->get_stats = &tulip_get_stats; ! 257: dev->set_multicast_list = &set_multicast_list; ! 258: dev->set_mac_address = &set_mac_address; ! 259: ! 260: return; ! 261: } ! 262: ! 263: ! 264: static int ! 265: tulip_open(struct device *dev) ! 266: { ! 267: struct tulip_private *tp = (struct tulip_private *)dev->priv; ! 268: int ioaddr = dev->base_addr; ! 269: ! 270: /* Reset the chip, holding bit 0 set at least 10 PCI cycles. */ ! 271: outl(0xfff80001, ioaddr + CSR0); ! 272: SLOW_DOWN_IO; ! 273: /* Deassert reset. Set 8 longword cache alignment, 8 longword burst. ! 274: Cache alignment bits 15:14 Burst length 13:8 ! 275: 0000 No alignment 0x00000000 unlimited 0800 8 longwords ! 276: 4000 8 longwords 0100 1 longword 1000 16 longwords ! 277: 8000 16 longwords 0200 2 longwords 2000 32 longwords ! 278: C000 32 longwords 0400 4 longwords ! 279: Wait the specified 50 PCI cycles after a reset by initializing ! 280: Tx and Rx queues and the address filter list. */ ! 281: outl(0xfff84800, ioaddr + CSR0); ! 282: ! 283: if (irq2dev_map[dev->irq] != NULL ! 284: || (irq2dev_map[dev->irq] = dev) == NULL ! 285: || dev->irq == 0 ! 286: || request_irq(dev->irq, &tulip_interrupt, 0, "DEC 21040 Tulip")) { ! 287: return -EAGAIN; ! 288: } ! 289: ! 290: if (tulip_debug > 1) ! 291: printk("%s: tulip_open() irq %d.\n", dev->name, dev->irq); ! 292: ! 293: tulip_init_ring(dev); ! 294: ! 295: /* Fill the whole address filter table with our physical address. */ ! 296: { ! 297: unsigned short *eaddrs = (unsigned short *)dev->dev_addr; ! 298: int *setup_frm = tp->setup_frame, i; ! 299: ! 300: /* You must add the broadcast address when doing perfect filtering! */ ! 301: *setup_frm++ = 0xffff; ! 302: *setup_frm++ = 0xffff; ! 303: *setup_frm++ = 0xffff; ! 304: /* Fill the rest of the accept table with our physical address. */ ! 305: for (i = 1; i < 16; i++) { ! 306: *setup_frm++ = eaddrs[0]; ! 307: *setup_frm++ = eaddrs[1]; ! 308: *setup_frm++ = eaddrs[2]; ! 309: } ! 310: /* Put the setup frame on the Tx list. */ ! 311: tp->tx_ring[0].length = 0x08000000 | 192; ! 312: tp->tx_ring[0].buffer1 = (char *)tp->setup_frame; ! 313: tp->tx_ring[0].buffer2 = 0; ! 314: tp->tx_ring[0].status = 0x80000000; ! 315: ! 316: tp->cur_tx++, tp->dirty_tx++; ! 317: } ! 318: ! 319: outl((int)tp->rx_ring, ioaddr + CSR3); ! 320: outl((int)tp->tx_ring, ioaddr + CSR4); ! 321: ! 322: /* Turn on the xcvr interface. */ ! 323: outl(0x00000000, ioaddr + CSR13); ! 324: outl(0x00000004, ioaddr + CSR13); ! 325: ! 326: /* Start the chip's Tx and Rx processes. */ ! 327: outl(0xfffe2002, ioaddr + CSR6); ! 328: ! 329: /* Trigger an immediate transmit demand to process the setup frame. */ ! 330: outl(0, ioaddr + CSR1); ! 331: ! 332: dev->tbusy = 0; ! 333: dev->interrupt = 0; ! 334: dev->start = 1; ! 335: ! 336: /* Enable interrupts by setting the interrupt mask. */ ! 337: outl(0xFFFFFFFF, ioaddr + CSR7); ! 338: ! 339: if (tulip_debug > 2) { ! 340: printk("%s: Done tulip_open(), CSR0 %8.8x, CSR13 %8.8x.\n", ! 341: dev->name, inl(ioaddr + CSR0), inl(ioaddr + CSR13)); ! 342: } ! 343: MOD_INC_USE_COUNT; ! 344: return 0; ! 345: } ! 346: ! 347: /* Initialize the Rx and Tx rings, along with various 'dev' bits. */ ! 348: static void ! 349: tulip_init_ring(struct device *dev) ! 350: { ! 351: struct tulip_private *tp = (struct tulip_private *)dev->priv; ! 352: int i; ! 353: ! 354: tp->tx_full = 0; ! 355: tp->cur_rx = tp->cur_tx = 0; ! 356: tp->dirty_rx = tp->dirty_tx = 0; ! 357: ! 358: for (i = 0; i < RX_RING_SIZE; i++) { ! 359: tp->rx_ring[i].status = 0x80000000; /* Owned by Tulip chip */ ! 360: tp->rx_ring[i].length = PKT_BUF_SZ; ! 361: tp->rx_ring[i].buffer1 = (char *)(tp->rx_buffs + i*PKT_BUF_SZ); ! 362: tp->rx_ring[i].buffer2 = (char *)&tp->rx_ring[i+1]; ! 363: } ! 364: /* Mark the last entry as wrapping the ring. */ ! 365: tp->rx_ring[i-1].length = PKT_BUF_SZ | 0x02000000; ! 366: tp->rx_ring[i-1].buffer2 = (char *)&tp->rx_ring[0]; ! 367: ! 368: /* The Tx buffer descriptor is filled in as needed, but we ! 369: do need to clear the ownership bit. */ ! 370: for (i = 0; i < TX_RING_SIZE; i++) { ! 371: tp->tx_ring[i].status = 0x00000000; ! 372: } ! 373: } ! 374: ! 375: static int ! 376: tulip_start_xmit(struct sk_buff *skb, struct device *dev) ! 377: { ! 378: struct tulip_private *tp = (struct tulip_private *)dev->priv; ! 379: int ioaddr = dev->base_addr; ! 380: int entry; ! 381: ! 382: /* Transmitter timeout, serious problems. */ ! 383: if (dev->tbusy) { ! 384: int tickssofar = jiffies - dev->trans_start; ! 385: int i; ! 386: if (tickssofar < 20) ! 387: return 1; ! 388: printk("%s: transmit timed out, status %8.8x, SIA %8.8x %8.8x %8.8x %8.8x, resetting...\n", ! 389: dev->name, inl(ioaddr + CSR5), inl(ioaddr + CSR12), ! 390: inl(ioaddr + CSR13), inl(ioaddr + CSR14), inl(ioaddr + CSR15)); ! 391: printk(" Rx ring %8.8x: ", (int)tp->rx_ring); ! 392: for (i = 0; i < RX_RING_SIZE; i++) ! 393: printk(" %8.8x", (unsigned int)tp->rx_ring[i].status); ! 394: printk("\n Tx ring %8.8x: ", (int)tp->tx_ring); ! 395: for (i = 0; i < TX_RING_SIZE; i++) ! 396: printk(" %8.8x", (unsigned int)tp->tx_ring[i].status); ! 397: printk("\n"); ! 398: ! 399: tp->stats.tx_errors++; ! 400: /* We should reinitialize the hardware here. */ ! 401: dev->tbusy=0; ! 402: dev->trans_start = jiffies; ! 403: return 0; ! 404: } ! 405: ! 406: if (skb == NULL || skb->len <= 0) { ! 407: printk("%s: Obsolete driver layer request made: skbuff==NULL.\n", ! 408: dev->name); ! 409: dev_tint(dev); ! 410: return 0; ! 411: } ! 412: ! 413: /* Block a timer-based transmit from overlapping. This could better be ! 414: done with atomic_swap(1, dev->tbusy), but set_bit() works as well. ! 415: If this ever occurs the queue layer is doing something evil! */ ! 416: if (set_bit(0, (void*)&dev->tbusy) != 0) { ! 417: printk("%s: Transmitter access conflict.\n", dev->name); ! 418: return 1; ! 419: } ! 420: ! 421: /* Caution: the write order is important here, set the base address ! 422: with the "ownership" bits last. */ ! 423: ! 424: /* Calculate the next Tx descriptor entry. */ ! 425: entry = tp->cur_tx % TX_RING_SIZE; ! 426: ! 427: tp->tx_full = 1; ! 428: tp->tx_skbuff[entry] = skb; ! 429: tp->tx_ring[entry].length = skb->len | ! 430: (entry == TX_RING_SIZE-1 ? 0xe2000000 : 0xe0000000); ! 431: tp->tx_ring[entry].buffer1 = skb->data; ! 432: tp->tx_ring[entry].buffer2 = 0; ! 433: tp->tx_ring[entry].status = 0x80000000; /* Pass ownership to the chip. */ ! 434: ! 435: tp->cur_tx++; ! 436: ! 437: /* Trigger an immediate transmit demand. */ ! 438: outl(0, ioaddr + CSR1); ! 439: ! 440: dev->trans_start = jiffies; ! 441: ! 442: return 0; ! 443: } ! 444: ! 445: /* The interrupt handler does all of the Rx thread work and cleans up ! 446: after the Tx thread. */ ! 447: static void tulip_interrupt(int irq, struct pt_regs *regs) ! 448: { ! 449: struct device *dev = (struct device *)(irq2dev_map[irq]); ! 450: struct tulip_private *lp; ! 451: int csr5, ioaddr, boguscnt=10; ! 452: ! 453: if (dev == NULL) { ! 454: printk ("tulip_interrupt(): irq %d for unknown device.\n", irq); ! 455: return; ! 456: } ! 457: ! 458: ioaddr = dev->base_addr; ! 459: lp = (struct tulip_private *)dev->priv; ! 460: if (dev->interrupt) ! 461: printk("%s: Re-entering the interrupt handler.\n", dev->name); ! 462: ! 463: dev->interrupt = 1; ! 464: ! 465: do { ! 466: csr5 = inl(ioaddr + CSR5); ! 467: /* Acknowledge all of the current interrupt sources ASAP. */ ! 468: outl(csr5 & 0x0001ffff, ioaddr + CSR5); ! 469: ! 470: if (tulip_debug > 4) ! 471: printk("%s: interrupt csr5=%#8.8x new csr5=%#8.8x.\n", ! 472: dev->name, csr5, inl(dev->base_addr + CSR5)); ! 473: ! 474: if ((csr5 & 0x00018000) == 0) ! 475: break; ! 476: ! 477: if (csr5 & 0x0040) /* Rx interrupt */ ! 478: tulip_rx(dev); ! 479: ! 480: if (csr5 & 0x0001) { /* Tx-done interrupt */ ! 481: int dirty_tx = lp->dirty_tx; ! 482: ! 483: while (dirty_tx < lp->cur_tx) { ! 484: int entry = dirty_tx % TX_RING_SIZE; ! 485: int status = lp->tx_ring[entry].status; ! 486: ! 487: if (status < 0) ! 488: break; /* It still hasn't been Txed */ ! 489: ! 490: if (status & 0x8000) { ! 491: /* There was an major error, log it. */ ! 492: lp->stats.tx_errors++; ! 493: if (status & 0x4104) lp->stats.tx_aborted_errors++; ! 494: if (status & 0x0C00) lp->stats.tx_carrier_errors++; ! 495: if (status & 0x0200) lp->stats.tx_window_errors++; ! 496: if (status & 0x0002) lp->stats.tx_fifo_errors++; ! 497: if (status & 0x0080) lp->stats.tx_heartbeat_errors++; ! 498: #ifdef ETHER_STATS ! 499: if (status & 0x0100) lp->stats.collisions16++; ! 500: #endif ! 501: } else { ! 502: #ifdef ETHER_STATS ! 503: if (status & 0x0001) lp->stats.tx_deferred++; ! 504: #endif ! 505: lp->stats.collisions += (status >> 3) & 15; ! 506: lp->stats.tx_packets++; ! 507: } ! 508: ! 509: /* Free the original skb. */ ! 510: dev_kfree_skb(lp->tx_skbuff[entry], FREE_WRITE); ! 511: dirty_tx++; ! 512: } ! 513: ! 514: #ifndef final_version ! 515: if (lp->cur_tx - dirty_tx >= TX_RING_SIZE) { ! 516: printk("out-of-sync dirty pointer, %d vs. %d, full=%d.\n", ! 517: dirty_tx, lp->cur_tx, lp->tx_full); ! 518: dirty_tx += TX_RING_SIZE; ! 519: } ! 520: #endif ! 521: ! 522: if (lp->tx_full && dev->tbusy ! 523: && dirty_tx > lp->cur_tx - TX_RING_SIZE + 2) { ! 524: /* The ring is no longer full, clear tbusy. */ ! 525: lp->tx_full = 0; ! 526: dev->tbusy = 0; ! 527: mark_bh(NET_BH); ! 528: } ! 529: ! 530: lp->dirty_tx = dirty_tx; ! 531: } ! 532: ! 533: /* Log errors. */ ! 534: if (csr5 & 0x8000) { /* Abnormal error summary bit. */ ! 535: if (csr5 & 0x0008) lp->stats.tx_errors++; /* Tx babble. */ ! 536: if (csr5 & 0x0100) { /* Missed a Rx frame. */ ! 537: lp->stats.rx_errors++; ! 538: lp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff; ! 539: } ! 540: if (csr5 & 0x0800) { ! 541: printk("%s: Something Wicked happened! %8.8x.\n", ! 542: dev->name, csr5); ! 543: /* Hmmmmm, it's not clear what to do here. */ ! 544: } ! 545: } ! 546: if (--boguscnt < 0) { ! 547: printk("%s: Too much work at interrupt, csr5=0x%8.8x.\n", ! 548: dev->name, csr5); ! 549: /* Clear all interrupt sources. */ ! 550: outl(0x0001ffff, ioaddr + CSR5); ! 551: break; ! 552: } ! 553: } while (1); ! 554: ! 555: if (tulip_debug > 3) ! 556: printk("%s: exiting interrupt, csr5=%#4.4x.\n", ! 557: dev->name, inl(ioaddr + CSR5)); ! 558: ! 559: /* Special code for testing *only*. */ ! 560: { ! 561: static int stopit = 10; ! 562: if (dev->start == 0 && --stopit < 0) { ! 563: printk("%s: Emergency stop, looping startup interrupt.\n", ! 564: dev->name); ! 565: free_irq(irq); ! 566: } ! 567: } ! 568: ! 569: dev->interrupt = 0; ! 570: return; ! 571: } ! 572: ! 573: static int ! 574: tulip_rx(struct device *dev) ! 575: { ! 576: struct tulip_private *lp = (struct tulip_private *)dev->priv; ! 577: int entry = lp->cur_rx % RX_RING_SIZE; ! 578: int i; ! 579: ! 580: if (tulip_debug > 4) ! 581: printk(" In tulip_rx().\n"); ! 582: /* If we own the next entry, it's a new packet. Send it up. */ ! 583: while (lp->rx_ring[entry].status >= 0) { ! 584: int status = lp->rx_ring[entry].status; ! 585: ! 586: if (tulip_debug > 4) ! 587: printk(" tulip_rx() status was %8.8x.\n", status); ! 588: if ((status & 0x0300) != 0x0300) { ! 589: printk("%s: Ethernet frame spanned multiple buffers, status %8.8x!\n", ! 590: dev->name, status); ! 591: } else if (status & 0x8000) { ! 592: /* There was a fatal error. */ ! 593: lp->stats.rx_errors++; /* end of a packet.*/ ! 594: if (status & 0x0890) lp->stats.rx_length_errors++; ! 595: if (status & 0x0004) lp->stats.rx_frame_errors++; ! 596: if (status & 0x0002) lp->stats.rx_crc_errors++; ! 597: if (status & 0x0001) lp->stats.rx_fifo_errors++; ! 598: } else { ! 599: /* Malloc up new buffer, compatible with net-2e. */ ! 600: short pkt_len = lp->rx_ring[entry].status >> 16; ! 601: struct sk_buff *skb; ! 602: ! 603: skb = dev_alloc_skb(pkt_len+2); ! 604: if (skb == NULL) { ! 605: printk("%s: Memory squeeze, deferring packet.\n", dev->name); ! 606: /* Check that at least two ring entries are free. ! 607: If not, free one and mark stats->rx_dropped++. */ ! 608: for (i=0; i < RX_RING_SIZE; i++) ! 609: if (lp->rx_ring[(entry+i) % RX_RING_SIZE].status < 0) ! 610: break; ! 611: ! 612: if (i > RX_RING_SIZE -2) { ! 613: lp->stats.rx_dropped++; ! 614: lp->rx_ring[entry].status = 0x80000000; ! 615: lp->cur_rx++; ! 616: } ! 617: break; ! 618: } ! 619: skb->dev = dev; ! 620: skb_reserve(skb,2); /* 16 byte align the data fields */ ! 621: memcpy(skb_put(skb,pkt_len), lp->rx_ring[entry].buffer1, pkt_len); ! 622: skb->protocol=eth_type_trans(skb,dev); ! 623: netif_rx(skb); ! 624: lp->stats.rx_packets++; ! 625: } ! 626: ! 627: lp->rx_ring[entry].status = 0x80000000; ! 628: entry = (++lp->cur_rx) % RX_RING_SIZE; ! 629: } ! 630: ! 631: return 0; ! 632: } ! 633: ! 634: static int ! 635: tulip_close(struct device *dev) ! 636: { ! 637: int ioaddr = dev->base_addr; ! 638: struct tulip_private *tp = (struct tulip_private *)dev->priv; ! 639: ! 640: dev->start = 0; ! 641: dev->tbusy = 1; ! 642: ! 643: if (tulip_debug > 1) ! 644: printk("%s: Shutting down ethercard, status was %2.2x.\n", ! 645: dev->name, inl(ioaddr + CSR5)); ! 646: ! 647: /* Disable interrupts by clearing the interrupt mask. */ ! 648: outl(0x00000000, ioaddr + CSR7); ! 649: /* Stop the chip's Tx and Rx processes. */ ! 650: outl(inl(ioaddr + CSR6) & ~0x2002, ioaddr + CSR6); ! 651: ! 652: tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff; ! 653: ! 654: free_irq(dev->irq); ! 655: irq2dev_map[dev->irq] = 0; ! 656: ! 657: MOD_DEC_USE_COUNT; ! 658: return 0; ! 659: } ! 660: ! 661: static struct enet_statistics * ! 662: tulip_get_stats(struct device *dev) ! 663: { ! 664: struct tulip_private *tp = (struct tulip_private *)dev->priv; ! 665: short ioaddr = dev->base_addr; ! 666: ! 667: tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff; ! 668: ! 669: return &tp->stats; ! 670: } ! 671: ! 672: /* ! 673: * Set or clear the multicast filter for this adaptor. ! 674: */ ! 675: ! 676: static void set_multicast_list(struct device *dev) ! 677: { ! 678: short ioaddr = dev->base_addr; ! 679: int csr6 = inl(ioaddr + CSR6) & ~0x00D5; ! 680: ! 681: if (dev->flags&IFF_PROMISC) ! 682: { /* Set promiscuous. */ ! 683: outl(csr6 | 0x00C0, ioaddr + CSR6); ! 684: /* Log any net taps. */ ! 685: printk("%s: Promiscuous mode enabled.\n", dev->name); ! 686: } ! 687: else if (dev->mc_count > 15 || (dev->flags&IFF_ALLMULTI)) ! 688: { ! 689: /* Too many to filter perfectly -- accept all multicasts. */ ! 690: outl(csr6 | 0x0080, ioaddr + CSR6); ! 691: } ! 692: else ! 693: { ! 694: struct tulip_private *tp = (struct tulip_private *)dev->priv; ! 695: struct dev_mc_list *dmi=dev->mc_list; ! 696: int *setup_frm = tp->setup_frame; ! 697: unsigned short *eaddrs; ! 698: int i; ! 699: ! 700: /* We have <= 15 addresses that we can use the wonderful ! 701: 16 address perfect filtering of the Tulip. Note that only ! 702: the low shortword of setup_frame[] is valid. */ ! 703: outl(csr6 | 0x0000, ioaddr + CSR6); ! 704: i=0; ! 705: while(dmi) ! 706: { ! 707: eaddrs=(unsigned short *)dmi->dmi_addr; ! 708: dmi=dmi->next; ! 709: i++; ! 710: *setup_frm++ = *eaddrs++; ! 711: *setup_frm++ = *eaddrs++; ! 712: *setup_frm++ = *eaddrs++; ! 713: } ! 714: /* Fill the rest of the table with our physical address. */ ! 715: eaddrs = (unsigned short *)dev->dev_addr; ! 716: do { ! 717: *setup_frm++ = eaddrs[0]; ! 718: *setup_frm++ = eaddrs[1]; ! 719: *setup_frm++ = eaddrs[2]; ! 720: } while (++i < 16); ! 721: ! 722: /* Now add this frame to the Tx list. */ ! 723: } ! 724: } ! 725: ! 726: static int ! 727: set_mac_address(struct device *dev, void *addr) ! 728: { ! 729: int i; ! 730: struct sockaddr *sa=(struct sockaddr *)addr; ! 731: if (dev->start) ! 732: return -EBUSY; ! 733: printk("%s: Setting MAC address to ", dev->name); ! 734: for (i = 0; i < 6; i++) ! 735: printk(" %2.2x", dev->dev_addr[i] = sa->sa_data[i]); ! 736: printk(".\n"); ! 737: return 0; ! 738: } ! 739: ! 740: #ifdef MODULE ! 741: static char devicename[9] = { 0, }; ! 742: static struct device dev_tulip = { ! 743: devicename, /* device name is inserted by linux/drivers/net/net_init.c */ ! 744: 0, 0, 0, 0, ! 745: 0, 0, ! 746: 0, 0, 0, NULL, tulip_probe ! 747: }; ! 748: ! 749: static int io = 0; ! 750: static int irq = 0; ! 751: ! 752: int init_module(void) ! 753: { ! 754: printk("tulip: Sorry, modularization is not completed\n"); ! 755: return -EIO; ! 756: #if 0 ! 757: if (io == 0) ! 758: printk("tulip: You should not use auto-probing with insmod!\n"); ! 759: dev_tulip.base_addr = io; ! 760: dev_tulip.irq = irq; ! 761: if (register_netdev(&dev_tulip) != 0) { ! 762: printk("tulip: register_netdev() returned non-zero.\n"); ! 763: return -EIO; ! 764: } ! 765: return 0; ! 766: #endif ! 767: } ! 768: ! 769: void ! 770: cleanup_module(void) ! 771: { ! 772: unregister_netdev(&dev_tulip); ! 773: } ! 774: #endif /* MODULE */ ! 775: ! 776: /* ! 777: * Local variables: ! 778: * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c tulip.c" ! 779: * c-indent-level: 4 ! 780: * tab-width: 4 ! 781: * End: ! 782: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.