![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to znet.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net|
Return to znet.c CVS log | Up to [GnuMach] / Gnu-Mach / linux / src / drivers / net |
1.1 ! root 1: /* znet.c: An Zenith Z-Note ethernet driver for linux. */ ! 2: ! 3: static const char *version = "znet.c:v1.02 9/23/94 [email protected]\n"; ! 4: ! 5: /* ! 6: Written by Donald Becker. ! 7: ! 8: The author may be reached as [email protected]. ! 9: This driver is based on the Linux skeleton driver. The copyright of the ! 10: skeleton driver is held by the United States Government, as represented ! 11: by DIRNSA, and it is released under the GPL. ! 12: ! 13: Thanks to Mike Hollick for alpha testing and suggestions. ! 14: ! 15: References: ! 16: The Crynwr packet driver. ! 17: ! 18: "82593 CSMA/CD Core LAN Controller" Intel datasheet, 1992 ! 19: Intel Microcommunications Databook, Vol. 1, 1990. ! 20: As usual with Intel, the documentation is incomplete and inaccurate. ! 21: I had to read the Crynwr packet driver to figure out how to actually ! 22: use the i82593, and guess at what register bits matched the loosely ! 23: related i82586. ! 24: ! 25: Theory of Operation ! 26: ! 27: The i82593 used in the Zenith Z-Note series operates using two(!) slave ! 28: DMA channels, one interrupt, and one 8-bit I/O port. ! 29: ! 30: While there several ways to configure '593 DMA system, I chose the one ! 31: that seemed commensurate with the highest system performance in the face ! 32: of moderate interrupt latency: Both DMA channels are configured as ! 33: recirculating ring buffers, with one channel (#0) dedicated to Rx and ! 34: the other channel (#1) to Tx and configuration. (Note that this is ! 35: different than the Crynwr driver, where the Tx DMA channel is initialized ! 36: before each operation. That approach simplifies operation and Tx error ! 37: recovery, but requires additional I/O in normal operation and precludes ! 38: transmit buffer chaining.) ! 39: ! 40: Both rings are set to 8192 bytes using {TX,RX}_RING_SIZE. This provides ! 41: a reasonable ring size for Rx, while simplifying DMA buffer allocation -- ! 42: DMA buffers must not cross a 128K boundary. (In truth the size selection ! 43: was influenced by my lack of '593 documentation. I thus was constrained ! 44: to use the Crynwr '593 initialization table, which sets the Rx ring size ! 45: to 8K.) ! 46: ! 47: Despite my usual low opinion about Intel-designed parts, I must admit ! 48: that the bulk data handling of the i82593 is a good design for ! 49: an integrated system, like a laptop, where using two slave DMA channels ! 50: doesn't pose a problem. I still take issue with using only a single I/O ! 51: port. In the same controlled environment there are essentially no ! 52: limitations on I/O space, and using multiple locations would eliminate ! 53: the need for multiple operations when looking at status registers, ! 54: setting the Rx ring boundary, or switching to promiscuous mode. ! 55: ! 56: I also question Zenith's selection of the '593: one of the advertised ! 57: advantages of earlier Intel parts was that if you figured out the magic ! 58: initialization incantation you could use the same part on many different ! 59: network types. Zenith's use of the "FriendlyNet" (sic) connector rather ! 60: than an on-board transceiver leads me to believe that they were planning ! 61: to take advantage of this. But, uhmmm, the '593 omits all but ethernet ! 62: functionality from the serial subsystem. ! 63: */ ! 64: ! 65: #include <linux/kernel.h> ! 66: #include <linux/sched.h> ! 67: #include <linux/string.h> ! 68: #include <linux/ptrace.h> ! 69: #include <linux/errno.h> ! 70: #include <linux/interrupt.h> ! 71: #include <linux/ioport.h> ! 72: #include <asm/system.h> ! 73: #include <asm/bitops.h> ! 74: #include <asm/io.h> ! 75: #include <asm/dma.h> ! 76: ! 77: #include <linux/netdevice.h> ! 78: #include <linux/etherdevice.h> ! 79: #include <linux/skbuff.h> ! 80: #include <linux/if_arp.h> ! 81: ! 82: #ifndef ZNET_DEBUG ! 83: #define ZNET_DEBUG 1 ! 84: #endif ! 85: static unsigned int znet_debug = ZNET_DEBUG; ! 86: ! 87: /* The DMA modes we need aren't in <dma.h>. */ ! 88: #define DMA_RX_MODE 0x14 /* Auto init, I/O to mem, ++, demand. */ ! 89: #define DMA_TX_MODE 0x18 /* Auto init, Mem to I/O, ++, demand. */ ! 90: #define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17) ! 91: #define DMA_BUF_SIZE 8192 ! 92: #define RX_BUF_SIZE 8192 ! 93: #define TX_BUF_SIZE 8192 ! 94: ! 95: /* Commands to the i82593 channel 0. */ ! 96: #define CMD0_CHNL_0 0x00 ! 97: #define CMD0_CHNL_1 0x10 /* Switch to channel 1. */ ! 98: #define CMD0_NOP (CMD0_CHNL_0) ! 99: #define CMD0_PORT_1 CMD0_CHNL_1 ! 100: #define CMD1_PORT_0 1 ! 101: #define CMD0_IA_SETUP 1 ! 102: #define CMD0_CONFIGURE 2 ! 103: #define CMD0_MULTICAST_LIST 3 ! 104: #define CMD0_TRANSMIT 4 ! 105: #define CMD0_DUMP 6 ! 106: #define CMD0_DIAGNOSE 7 ! 107: #define CMD0_Rx_ENABLE 8 ! 108: #define CMD0_Rx_DISABLE 10 ! 109: #define CMD0_Rx_STOP 11 ! 110: #define CMD0_RETRANSMIT 12 ! 111: #define CMD0_ABORT 13 ! 112: #define CMD0_RESET 14 ! 113: ! 114: #define CMD0_ACK 0x80 ! 115: ! 116: #define CMD0_STAT0 (0 << 5) ! 117: #define CMD0_STAT1 (1 << 5) ! 118: #define CMD0_STAT2 (2 << 5) ! 119: #define CMD0_STAT3 (3 << 5) ! 120: ! 121: #define net_local znet_private ! 122: struct znet_private { ! 123: int rx_dma, tx_dma; ! 124: struct enet_statistics stats; ! 125: /* The starting, current, and end pointers for the packet buffers. */ ! 126: ushort *rx_start, *rx_cur, *rx_end; ! 127: ushort *tx_start, *tx_cur, *tx_end; ! 128: ushort tx_buf_len; /* Tx buffer length, in words. */ ! 129: }; ! 130: ! 131: /* Only one can be built-in;-> */ ! 132: static struct znet_private zn; ! 133: static ushort dma_buffer1[DMA_BUF_SIZE/2]; ! 134: static ushort dma_buffer2[DMA_BUF_SIZE/2]; ! 135: static ushort dma_buffer3[DMA_BUF_SIZE/2 + 8]; ! 136: ! 137: /* The configuration block. What an undocumented nightmare. The first ! 138: set of values are those suggested (without explanation) for ethernet ! 139: in the Intel 82586 databook. The rest appear to be completely undocumented, ! 140: except for cryptic notes in the Crynwr packet driver. This driver uses ! 141: the Crynwr values verbatim. */ ! 142: ! 143: static unsigned char i593_init[] = { ! 144: 0xAA, /* 0: 16-byte input & 80-byte output FIFO. */ ! 145: /* threshold, 96-byte FIFO, 82593 mode. */ ! 146: 0x88, /* 1: Continuous w/interrupts, 128-clock DMA.*/ ! 147: 0x2E, /* 2: 8-byte preamble, NO address insertion, */ ! 148: /* 6-byte Ethernet address, loopback off.*/ ! 149: 0x00, /* 3: Default priorities & backoff methods. */ ! 150: 0x60, /* 4: 96-bit interframe spacing. */ ! 151: 0x00, /* 5: 512-bit slot time (low-order). */ ! 152: 0xF2, /* 6: Slot time (high-order), 15 COLL retries. */ ! 153: 0x00, /* 7: Promisc-off, broadcast-on, default CRC. */ ! 154: 0x00, /* 8: Default carrier-sense, collision-detect. */ ! 155: 0x40, /* 9: 64-byte minimum frame length. */ ! 156: 0x5F, /* A: Type/length checks OFF, no CRC input, ! 157: "jabber" termination, etc. */ ! 158: 0x00, /* B: Full-duplex disabled. */ ! 159: 0x3F, /* C: Default multicast addresses & backoff. */ ! 160: 0x07, /* D: Default IFS retriggering. */ ! 161: 0x31, /* E: Internal retransmit, drop "runt" packets, ! 162: synchr. DRQ deassertion, 6 status bytes. */ ! 163: 0x22, /* F: Receive ring-buffer size (8K), ! 164: receive-stop register enable. */ ! 165: }; ! 166: ! 167: struct netidblk { ! 168: char magic[8]; /* The magic number (string) "NETIDBLK" */ ! 169: unsigned char netid[8]; /* The physical station address */ ! 170: char nettype, globalopt; ! 171: char vendor[8]; /* The machine vendor and product name. */ ! 172: char product[8]; ! 173: char irq1, irq2; /* Interrupts, only one is currently used. */ ! 174: char dma1, dma2; ! 175: short dma_mem_misc[8]; /* DMA buffer locations (unused in Linux). */ ! 176: short iobase1, iosize1; ! 177: short iobase2, iosize2; /* Second iobase unused. */ ! 178: char driver_options; /* Misc. bits */ ! 179: char pad; ! 180: }; ! 181: ! 182: int znet_probe(struct device *dev); ! 183: static int znet_open(struct device *dev); ! 184: static int znet_send_packet(struct sk_buff *skb, struct device *dev); ! 185: static void znet_interrupt(int irq, void *dev_id, struct pt_regs *regs); ! 186: static void znet_rx(struct device *dev); ! 187: static int znet_close(struct device *dev); ! 188: static struct enet_statistics *net_get_stats(struct device *dev); ! 189: static void set_multicast_list(struct device *dev); ! 190: static void hardware_init(struct device *dev); ! 191: static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset); ! 192: ! 193: #ifdef notdef ! 194: static struct sigaction znet_sigaction = { &znet_interrupt, 0, 0, NULL, }; ! 195: #endif ! 196: ! 197: ! 198: /* The Z-Note probe is pretty easy. The NETIDBLK exists in the safe-to-probe ! 199: BIOS area. We just scan for the signature, and pull the vital parameters ! 200: out of the structure. */ ! 201: ! 202: int znet_probe(struct device *dev) ! 203: { ! 204: int i; ! 205: struct netidblk *netinfo; ! 206: char *p; ! 207: ! 208: /* This code scans the region 0xf0000 to 0xfffff for a "NETIDBLK". */ ! 209: for(p = (char *)0xf0000; p < (char *)0x100000; p++) ! 210: if (*p == 'N' && strncmp(p, "NETIDBLK", 8) == 0) ! 211: break; ! 212: ! 213: if (p >= (char *)0x100000) { ! 214: if (znet_debug > 1) ! 215: printk(KERN_INFO "No Z-Note ethernet adaptor found.\n"); ! 216: return ENODEV; ! 217: } ! 218: netinfo = (struct netidblk *)p; ! 219: dev->base_addr = netinfo->iobase1; ! 220: dev->irq = netinfo->irq1; ! 221: ! 222: printk(KERN_INFO "%s: ZNET at %#3lx,", dev->name, dev->base_addr); ! 223: ! 224: /* The station address is in the "netidblk" at 0x0f0000. */ ! 225: for (i = 0; i < 6; i++) ! 226: printk(" %2.2x", dev->dev_addr[i] = netinfo->netid[i]); ! 227: ! 228: printk(", using IRQ %d DMA %d and %d.\n", dev->irq, netinfo->dma1, ! 229: netinfo->dma2); ! 230: ! 231: if (znet_debug > 1) { ! 232: printk(KERN_INFO "%s: vendor '%16.16s' IRQ1 %d IRQ2 %d DMA1 %d DMA2 %d.\n", ! 233: dev->name, netinfo->vendor, ! 234: netinfo->irq1, netinfo->irq2, ! 235: netinfo->dma1, netinfo->dma2); ! 236: printk(KERN_INFO "%s: iobase1 %#x size %d iobase2 %#x size %d net type %2.2x.\n", ! 237: dev->name, netinfo->iobase1, netinfo->iosize1, ! 238: netinfo->iobase2, netinfo->iosize2, netinfo->nettype); ! 239: } ! 240: ! 241: if (znet_debug > 0) ! 242: printk("%s%s", KERN_INFO, version); ! 243: ! 244: dev->priv = (void *) &zn; ! 245: zn.rx_dma = netinfo->dma1; ! 246: zn.tx_dma = netinfo->dma2; ! 247: ! 248: /* These should never fail. You can't add devices to a sealed box! */ ! 249: if (request_irq(dev->irq, &znet_interrupt, 0, "ZNet", NULL) ! 250: || request_dma(zn.rx_dma,"ZNet rx") ! 251: || request_dma(zn.tx_dma,"ZNet tx")) { ! 252: printk(KERN_WARNING "%s: Not opened -- resource busy?!?\n", dev->name); ! 253: return EBUSY; ! 254: } ! 255: irq2dev_map[dev->irq] = dev; ! 256: ! 257: /* Allocate buffer memory. We can cross a 128K boundary, so we ! 258: must be careful about the allocation. It's easiest to waste 8K. */ ! 259: if (dma_page_eq(dma_buffer1, &dma_buffer1[RX_BUF_SIZE/2-1])) ! 260: zn.rx_start = dma_buffer1; ! 261: else ! 262: zn.rx_start = dma_buffer2; ! 263: ! 264: if (dma_page_eq(dma_buffer3, &dma_buffer3[RX_BUF_SIZE/2-1])) ! 265: zn.tx_start = dma_buffer3; ! 266: else ! 267: zn.tx_start = dma_buffer2; ! 268: zn.rx_end = zn.rx_start + RX_BUF_SIZE/2; ! 269: zn.tx_buf_len = TX_BUF_SIZE/2; ! 270: zn.tx_end = zn.tx_start + zn.tx_buf_len; ! 271: ! 272: /* The ZNET-specific entries in the device structure. */ ! 273: dev->open = &znet_open; ! 274: dev->hard_start_xmit = &znet_send_packet; ! 275: dev->stop = &znet_close; ! 276: dev->get_stats = net_get_stats; ! 277: dev->set_multicast_list = &set_multicast_list; ! 278: ! 279: /* Fill in the 'dev' with ethernet-generic values. */ ! 280: ether_setup(dev); ! 281: ! 282: return 0; ! 283: } ! 284: ! 285: ! 286: static int znet_open(struct device *dev) ! 287: { ! 288: int ioaddr = dev->base_addr; ! 289: ! 290: if (znet_debug > 2) ! 291: printk(KERN_DEBUG "%s: znet_open() called.\n", dev->name); ! 292: ! 293: /* Turn on the 82501 SIA, using zenith-specific magic. */ ! 294: outb(0x10, 0xe6); /* Select LAN control register */ ! 295: outb(inb(0xe7) | 0x84, 0xe7); /* Turn on LAN power (bit 2). */ ! 296: /* According to the Crynwr driver we should wait 50 msec. for the ! 297: LAN clock to stabilize. My experiments indicates that the '593 can ! 298: be initialized immediately. The delay is probably needed for the ! 299: DC-to-DC converter to come up to full voltage, and for the oscillator ! 300: to be spot-on at 20Mhz before transmitting. ! 301: Until this proves to be a problem we rely on the higher layers for the ! 302: delay and save allocating a timer entry. */ ! 303: ! 304: /* This follows the packet driver's lead, and checks for success. */ ! 305: if (inb(ioaddr) != 0x10 && inb(ioaddr) != 0x00) ! 306: printk(KERN_WARNING "%s: Problem turning on the transceiver power.\n", ! 307: dev->name); ! 308: ! 309: dev->tbusy = 0; ! 310: dev->interrupt = 0; ! 311: hardware_init(dev); ! 312: dev->start = 1; ! 313: ! 314: return 0; ! 315: } ! 316: ! 317: static int znet_send_packet(struct sk_buff *skb, struct device *dev) ! 318: { ! 319: int ioaddr = dev->base_addr; ! 320: ! 321: if (znet_debug > 4) ! 322: printk(KERN_DEBUG "%s: ZNet_send_packet(%ld).\n", dev->name, dev->tbusy); ! 323: ! 324: /* Transmitter timeout, likely just recovery after suspending the machine. */ ! 325: if (dev->tbusy) { ! 326: ushort event, tx_status, rx_offset, state; ! 327: int tickssofar = jiffies - dev->trans_start; ! 328: if (tickssofar < 10) ! 329: return 1; ! 330: outb(CMD0_STAT0, ioaddr); event = inb(ioaddr); ! 331: outb(CMD0_STAT1, ioaddr); tx_status = inw(ioaddr); ! 332: outb(CMD0_STAT2, ioaddr); rx_offset = inw(ioaddr); ! 333: outb(CMD0_STAT3, ioaddr); state = inb(ioaddr); ! 334: printk(KERN_WARNING "%s: transmit timed out, status %02x %04x %04x %02x," ! 335: " resetting.\n", dev->name, event, tx_status, rx_offset, state); ! 336: if (tx_status == 0x0400) ! 337: printk(KERN_WARNING "%s: Tx carrier error, check transceiver cable.\n", ! 338: dev->name); ! 339: outb(CMD0_RESET, ioaddr); ! 340: hardware_init(dev); ! 341: } ! 342: ! 343: if (skb == NULL) { ! 344: dev_tint(dev); ! 345: return 0; ! 346: } ! 347: ! 348: /* Check that the part hasn't reset itself, probably from suspend. */ ! 349: outb(CMD0_STAT0, ioaddr); ! 350: if (inw(ioaddr) == 0x0010 ! 351: && inw(ioaddr) == 0x0000 ! 352: && inw(ioaddr) == 0x0010) ! 353: hardware_init(dev); ! 354: ! 355: /* Block a timer-based transmit from overlapping. This could better be ! 356: done with atomic_swap(1, dev->tbusy), but set_bit() works as well. */ ! 357: if (set_bit(0, (void*)&dev->tbusy) != 0) ! 358: printk(KERN_WARNING "%s: Transmitter access conflict.\n", dev->name); ! 359: else { ! 360: short length = ETH_ZLEN < skb->len ? skb->len : ETH_ZLEN; ! 361: unsigned char *buf = (void *)skb->data; ! 362: ushort *tx_link = zn.tx_cur - 1; ! 363: ushort rnd_len = (length + 1)>>1; ! 364: ! 365: { ! 366: short dma_port = ((zn.tx_dma&3)<<2) + IO_DMA2_BASE; ! 367: unsigned addr = inb(dma_port); ! 368: addr |= inb(dma_port) << 8; ! 369: addr <<= 1; ! 370: if (((int)zn.tx_cur & 0x1ffff) != addr) ! 371: printk(KERN_WARNING "Address mismatch at Tx: %#x vs %#x.\n", ! 372: (int)zn.tx_cur & 0xffff, addr); ! 373: zn.tx_cur = (ushort *)(((int)zn.tx_cur & 0xfe0000) | addr); ! 374: } ! 375: ! 376: if (zn.tx_cur >= zn.tx_end) ! 377: zn.tx_cur = zn.tx_start; ! 378: *zn.tx_cur++ = length; ! 379: if (zn.tx_cur + rnd_len + 1 > zn.tx_end) { ! 380: int semi_cnt = (zn.tx_end - zn.tx_cur)<<1; /* Cvrt to byte cnt. */ ! 381: memcpy(zn.tx_cur, buf, semi_cnt); ! 382: rnd_len -= semi_cnt>>1; ! 383: memcpy(zn.tx_start, buf + semi_cnt, length - semi_cnt); ! 384: zn.tx_cur = zn.tx_start + rnd_len; ! 385: } else { ! 386: memcpy(zn.tx_cur, buf, skb->len); ! 387: zn.tx_cur += rnd_len; ! 388: } ! 389: *zn.tx_cur++ = 0; ! 390: cli(); { ! 391: *tx_link = CMD0_TRANSMIT + CMD0_CHNL_1; ! 392: /* Is this always safe to do? */ ! 393: outb(CMD0_TRANSMIT + CMD0_CHNL_1,ioaddr); ! 394: } sti(); ! 395: ! 396: dev->trans_start = jiffies; ! 397: if (znet_debug > 4) ! 398: printk(KERN_DEBUG "%s: Transmitter queued, length %d.\n", dev->name, length); ! 399: } ! 400: dev_kfree_skb(skb, FREE_WRITE); ! 401: return 0; ! 402: } ! 403: ! 404: /* The ZNET interrupt handler. */ ! 405: static void znet_interrupt(int irq, void *dev_id, struct pt_regs * regs) ! 406: { ! 407: struct device *dev = irq2dev_map[irq]; ! 408: int ioaddr; ! 409: int boguscnt = 20; ! 410: ! 411: if (dev == NULL) { ! 412: printk(KERN_WARNING "znet_interrupt(): IRQ %d for unknown device.\n", irq); ! 413: return; ! 414: } ! 415: ! 416: dev->interrupt = 1; ! 417: ioaddr = dev->base_addr; ! 418: ! 419: outb(CMD0_STAT0, ioaddr); ! 420: do { ! 421: ushort status = inb(ioaddr); ! 422: if (znet_debug > 5) { ! 423: ushort result, rx_ptr, running; ! 424: outb(CMD0_STAT1, ioaddr); ! 425: result = inw(ioaddr); ! 426: outb(CMD0_STAT2, ioaddr); ! 427: rx_ptr = inw(ioaddr); ! 428: outb(CMD0_STAT3, ioaddr); ! 429: running = inb(ioaddr); ! 430: printk(KERN_DEBUG "%s: interrupt, status %02x, %04x %04x %02x serial %d.\n", ! 431: dev->name, status, result, rx_ptr, running, boguscnt); ! 432: } ! 433: if ((status & 0x80) == 0) ! 434: break; ! 435: ! 436: if ((status & 0x0F) == 4) { /* Transmit done. */ ! 437: struct net_local *lp = (struct net_local *)dev->priv; ! 438: int tx_status; ! 439: outb(CMD0_STAT1, ioaddr); ! 440: tx_status = inw(ioaddr); ! 441: /* It's undocumented, but tx_status seems to match the i82586. */ ! 442: if (tx_status & 0x2000) { ! 443: lp->stats.tx_packets++; ! 444: lp->stats.collisions += tx_status & 0xf; ! 445: } else { ! 446: if (tx_status & 0x0600) lp->stats.tx_carrier_errors++; ! 447: if (tx_status & 0x0100) lp->stats.tx_fifo_errors++; ! 448: if (!(tx_status & 0x0040)) lp->stats.tx_heartbeat_errors++; ! 449: if (tx_status & 0x0020) lp->stats.tx_aborted_errors++; ! 450: /* ...and the catch-all. */ ! 451: if ((tx_status | 0x0760) != 0x0760) ! 452: lp->stats.tx_errors++; ! 453: } ! 454: dev->tbusy = 0; ! 455: mark_bh(NET_BH); /* Inform upper layers. */ ! 456: } ! 457: ! 458: if ((status & 0x40) ! 459: || (status & 0x0f) == 11) { ! 460: znet_rx(dev); ! 461: } ! 462: /* Clear the interrupts we've handled. */ ! 463: outb(CMD0_ACK,ioaddr); ! 464: } while (boguscnt--); ! 465: ! 466: dev->interrupt = 0; ! 467: return; ! 468: } ! 469: ! 470: static void znet_rx(struct device *dev) ! 471: { ! 472: struct net_local *lp = (struct net_local *)dev->priv; ! 473: int ioaddr = dev->base_addr; ! 474: int boguscount = 1; ! 475: short next_frame_end_offset = 0; /* Offset of next frame start. */ ! 476: short *cur_frame_end; ! 477: short cur_frame_end_offset; ! 478: ! 479: outb(CMD0_STAT2, ioaddr); ! 480: cur_frame_end_offset = inw(ioaddr); ! 481: ! 482: if (cur_frame_end_offset == zn.rx_cur - zn.rx_start) { ! 483: printk(KERN_WARNING "%s: Interrupted, but nothing to receive, offset %03x.\n", ! 484: dev->name, cur_frame_end_offset); ! 485: return; ! 486: } ! 487: ! 488: /* Use same method as the Crynwr driver: construct a forward list in ! 489: the same area of the backwards links we now have. This allows us to ! 490: pass packets to the upper layers in the order they were received -- ! 491: important for fast-path sequential operations. */ ! 492: while (zn.rx_start + cur_frame_end_offset != zn.rx_cur ! 493: && ++boguscount < 5) { ! 494: unsigned short hi_cnt, lo_cnt, hi_status, lo_status; ! 495: int count, status; ! 496: ! 497: if (cur_frame_end_offset < 4) { ! 498: /* Oh no, we have a special case: the frame trailer wraps around ! 499: the end of the ring buffer. We've saved space at the end of ! 500: the ring buffer for just this problem. */ ! 501: memcpy(zn.rx_end, zn.rx_start, 8); ! 502: cur_frame_end_offset += (RX_BUF_SIZE/2); ! 503: } ! 504: cur_frame_end = zn.rx_start + cur_frame_end_offset - 4; ! 505: ! 506: lo_status = *cur_frame_end++; ! 507: hi_status = *cur_frame_end++; ! 508: status = ((hi_status & 0xff) << 8) + (lo_status & 0xff); ! 509: lo_cnt = *cur_frame_end++; ! 510: hi_cnt = *cur_frame_end++; ! 511: count = ((hi_cnt & 0xff) << 8) + (lo_cnt & 0xff); ! 512: ! 513: if (znet_debug > 5) ! 514: printk(KERN_DEBUG "Constructing trailer at location %03x, %04x %04x %04x %04x" ! 515: " count %#x status %04x.\n", ! 516: cur_frame_end_offset<<1, lo_status, hi_status, lo_cnt, hi_cnt, ! 517: count, status); ! 518: cur_frame_end[-4] = status; ! 519: cur_frame_end[-3] = next_frame_end_offset; ! 520: cur_frame_end[-2] = count; ! 521: next_frame_end_offset = cur_frame_end_offset; ! 522: cur_frame_end_offset -= ((count + 1)>>1) + 3; ! 523: if (cur_frame_end_offset < 0) ! 524: cur_frame_end_offset += RX_BUF_SIZE/2; ! 525: }; ! 526: ! 527: /* Now step forward through the list. */ ! 528: do { ! 529: ushort *this_rfp_ptr = zn.rx_start + next_frame_end_offset; ! 530: int status = this_rfp_ptr[-4]; ! 531: int pkt_len = this_rfp_ptr[-2]; ! 532: ! 533: if (znet_debug > 5) ! 534: printk(KERN_DEBUG "Looking at trailer ending at %04x status %04x length %03x" ! 535: " next %04x.\n", next_frame_end_offset<<1, status, pkt_len, ! 536: this_rfp_ptr[-3]<<1); ! 537: /* Once again we must assume that the i82586 docs apply. */ ! 538: if ( ! (status & 0x2000)) { /* There was an error. */ ! 539: lp->stats.rx_errors++; ! 540: if (status & 0x0800) lp->stats.rx_crc_errors++; ! 541: if (status & 0x0400) lp->stats.rx_frame_errors++; ! 542: if (status & 0x0200) lp->stats.rx_over_errors++; /* Wrong. */ ! 543: if (status & 0x0100) lp->stats.rx_fifo_errors++; ! 544: if (status & 0x0080) lp->stats.rx_length_errors++; ! 545: } else if (pkt_len > 1536) { ! 546: lp->stats.rx_length_errors++; ! 547: } else { ! 548: /* Malloc up new buffer. */ ! 549: struct sk_buff *skb; ! 550: ! 551: skb = dev_alloc_skb(pkt_len); ! 552: if (skb == NULL) { ! 553: if (znet_debug) ! 554: printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name); ! 555: lp->stats.rx_dropped++; ! 556: break; ! 557: } ! 558: skb->dev = dev; ! 559: ! 560: if (&zn.rx_cur[(pkt_len+1)>>1] > zn.rx_end) { ! 561: int semi_cnt = (zn.rx_end - zn.rx_cur)<<1; ! 562: memcpy(skb_put(skb,semi_cnt), zn.rx_cur, semi_cnt); ! 563: memcpy(skb_put(skb,pkt_len-semi_cnt), zn.rx_start, ! 564: pkt_len - semi_cnt); ! 565: } else { ! 566: memcpy(skb_put(skb,pkt_len), zn.rx_cur, pkt_len); ! 567: if (znet_debug > 6) { ! 568: unsigned int *packet = (unsigned int *) skb->data; ! 569: printk(KERN_DEBUG "Packet data is %08x %08x %08x %08x.\n", packet[0], ! 570: packet[1], packet[2], packet[3]); ! 571: } ! 572: } ! 573: skb->protocol=eth_type_trans(skb,dev); ! 574: netif_rx(skb); ! 575: lp->stats.rx_packets++; ! 576: } ! 577: zn.rx_cur = this_rfp_ptr; ! 578: if (zn.rx_cur >= zn.rx_end) ! 579: zn.rx_cur -= RX_BUF_SIZE/2; ! 580: update_stop_hit(ioaddr, (zn.rx_cur - zn.rx_start)<<1); ! 581: next_frame_end_offset = this_rfp_ptr[-3]; ! 582: if (next_frame_end_offset == 0) /* Read all the frames? */ ! 583: break; /* Done for now */ ! 584: this_rfp_ptr = zn.rx_start + next_frame_end_offset; ! 585: } while (--boguscount); ! 586: ! 587: /* If any worth-while packets have been received, dev_rint() ! 588: has done a mark_bh(INET_BH) for us and will work on them ! 589: when we get to the bottom-half routine. */ ! 590: return; ! 591: } ! 592: ! 593: /* The inverse routine to znet_open(). */ ! 594: static int znet_close(struct device *dev) ! 595: { ! 596: int ioaddr = dev->base_addr; ! 597: ! 598: dev->tbusy = 1; ! 599: dev->start = 0; ! 600: ! 601: outb(CMD0_RESET, ioaddr); /* CMD0_RESET */ ! 602: ! 603: disable_dma(zn.rx_dma); ! 604: disable_dma(zn.tx_dma); ! 605: ! 606: free_irq(dev->irq, NULL); ! 607: ! 608: if (znet_debug > 1) ! 609: printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name); ! 610: /* Turn off transceiver power. */ ! 611: outb(0x10, 0xe6); /* Select LAN control register */ ! 612: outb(inb(0xe7) & ~0x84, 0xe7); /* Turn on LAN power (bit 2). */ ! 613: ! 614: return 0; ! 615: } ! 616: ! 617: /* Get the current statistics. This may be called with the card open or ! 618: closed. */ ! 619: static struct enet_statistics *net_get_stats(struct device *dev) ! 620: { ! 621: struct net_local *lp = (struct net_local *)dev->priv; ! 622: ! 623: return &lp->stats; ! 624: } ! 625: ! 626: /* Set or clear the multicast filter for this adaptor. ! 627: As a side effect this routine must also initialize the device parameters. ! 628: This is taken advantage of in open(). ! 629: ! 630: N.B. that we change i593_init[] in place. This (properly) makes the ! 631: mode change persistent, but must be changed if this code is moved to ! 632: a multiple adaptor environment. ! 633: */ ! 634: static void set_multicast_list(struct device *dev) ! 635: { ! 636: short ioaddr = dev->base_addr; ! 637: ! 638: if (dev->flags&IFF_PROMISC) { ! 639: /* Enable promiscuous mode */ ! 640: i593_init[7] &= ~3; i593_init[7] |= 1; ! 641: i593_init[13] &= ~8; i593_init[13] |= 8; ! 642: } else if (dev->mc_list || (dev->flags&IFF_ALLMULTI)) { ! 643: /* Enable accept-all-multicast mode */ ! 644: i593_init[7] &= ~3; i593_init[7] |= 0; ! 645: i593_init[13] &= ~8; i593_init[13] |= 8; ! 646: } else { /* Enable normal mode. */ ! 647: i593_init[7] &= ~3; i593_init[7] |= 0; ! 648: i593_init[13] &= ~8; i593_init[13] |= 0; ! 649: } ! 650: *zn.tx_cur++ = sizeof(i593_init); ! 651: memcpy(zn.tx_cur, i593_init, sizeof(i593_init)); ! 652: zn.tx_cur += sizeof(i593_init)/2; ! 653: outb(CMD0_CONFIGURE+CMD0_CHNL_1, ioaddr); ! 654: #ifdef not_tested ! 655: if (num_addrs > 0) { ! 656: int addrs_len = 6*num_addrs; ! 657: *zn.tx_cur++ = addrs_len; ! 658: memcpy(zn.tx_cur, addrs, addrs_len); ! 659: outb(CMD0_MULTICAST_LIST+CMD0_CHNL_1, ioaddr); ! 660: zn.tx_cur += addrs_len>>1; ! 661: } ! 662: #endif ! 663: } ! 664: ! 665: void show_dma(void) ! 666: { ! 667: short dma_port = ((zn.tx_dma&3)<<2) + IO_DMA2_BASE; ! 668: unsigned addr = inb(dma_port); ! 669: addr |= inb(dma_port) << 8; ! 670: printk("Addr: %04x cnt:%3x...", addr<<1, get_dma_residue(zn.tx_dma)); ! 671: } ! 672: ! 673: /* Initialize the hardware. We have to do this when the board is open()ed ! 674: or when we come out of suspend mode. */ ! 675: static void hardware_init(struct device *dev) ! 676: { ! 677: short ioaddr = dev->base_addr; ! 678: ! 679: zn.rx_cur = zn.rx_start; ! 680: zn.tx_cur = zn.tx_start; ! 681: ! 682: /* Reset the chip, and start it up. */ ! 683: outb(CMD0_RESET, ioaddr); ! 684: ! 685: cli(); { /* Protect against a DMA flip-flop */ ! 686: disable_dma(zn.rx_dma); /* reset by an interrupting task. */ ! 687: clear_dma_ff(zn.rx_dma); ! 688: set_dma_mode(zn.rx_dma, DMA_RX_MODE); ! 689: set_dma_addr(zn.rx_dma, (unsigned int) zn.rx_start); ! 690: set_dma_count(zn.rx_dma, RX_BUF_SIZE); ! 691: enable_dma(zn.rx_dma); ! 692: /* Now set up the Tx channel. */ ! 693: disable_dma(zn.tx_dma); ! 694: clear_dma_ff(zn.tx_dma); ! 695: set_dma_mode(zn.tx_dma, DMA_TX_MODE); ! 696: set_dma_addr(zn.tx_dma, (unsigned int) zn.tx_start); ! 697: set_dma_count(zn.tx_dma, zn.tx_buf_len<<1); ! 698: enable_dma(zn.tx_dma); ! 699: } sti(); ! 700: ! 701: if (znet_debug > 1) ! 702: printk(KERN_DEBUG "%s: Initializing the i82593, tx buf %p... ", dev->name, ! 703: zn.tx_start); ! 704: /* Do an empty configure command, just like the Crynwr driver. This ! 705: resets to chip to its default values. */ ! 706: *zn.tx_cur++ = 0; ! 707: *zn.tx_cur++ = 0; ! 708: printk("stat:%02x ", inb(ioaddr)); show_dma(); ! 709: outb(CMD0_CONFIGURE+CMD0_CHNL_1, ioaddr); ! 710: *zn.tx_cur++ = sizeof(i593_init); ! 711: memcpy(zn.tx_cur, i593_init, sizeof(i593_init)); ! 712: zn.tx_cur += sizeof(i593_init)/2; ! 713: printk("stat:%02x ", inb(ioaddr)); show_dma(); ! 714: outb(CMD0_CONFIGURE+CMD0_CHNL_1, ioaddr); ! 715: *zn.tx_cur++ = 6; ! 716: memcpy(zn.tx_cur, dev->dev_addr, 6); ! 717: zn.tx_cur += 3; ! 718: printk("stat:%02x ", inb(ioaddr)); show_dma(); ! 719: outb(CMD0_IA_SETUP + CMD0_CHNL_1, ioaddr); ! 720: printk("stat:%02x ", inb(ioaddr)); show_dma(); ! 721: ! 722: update_stop_hit(ioaddr, 8192); ! 723: if (znet_debug > 1) printk("enabling Rx.\n"); ! 724: outb(CMD0_Rx_ENABLE+CMD0_CHNL_0, ioaddr); ! 725: dev->tbusy = 0; ! 726: } ! 727: ! 728: static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset) ! 729: { ! 730: outb(CMD0_PORT_1, ioaddr); ! 731: if (znet_debug > 5) ! 732: printk(KERN_DEBUG "Updating stop hit with value %02x.\n", ! 733: (rx_stop_offset >> 6) | 0x80); ! 734: outb((rx_stop_offset >> 6) | 0x80, ioaddr); ! 735: outb(CMD1_PORT_0, ioaddr); ! 736: } ! 737: ! 738: /* ! 739: * Local variables: ! 740: * compile-command: "gcc -D__KERNEL__ -I/usr/src/linux/net/inet -Wall -Wstrict-prototypes -O6 -m486 -c znet.c" ! 741: * version-control: t ! 742: * kept-new-versions: 5 ! 743: * c-indent-level: 4 ! 744: * tab-width: 4 ! 745: * End: ! 746: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.