1 /* znet.c: An Zenith Z-Note ethernet driver for linux. */
4 Written by Donald Becker.
6 The author may be reached as becker@scyld.com.
7 This driver is based on the Linux skeleton driver. The copyright of the
8 skeleton driver is held by the United States Government, as represented
9 by DIRNSA, and it is released under the GPL.
11 Thanks to Mike Hollick for alpha testing and suggestions.
14 The Crynwr packet driver.
16 "82593 CSMA/CD Core LAN Controller" Intel datasheet, 1992
17 Intel Microcommunications Databook, Vol. 1, 1990.
18 As usual with Intel, the documentation is incomplete and inaccurate.
19 I had to read the Crynwr packet driver to figure out how to actually
20 use the i82593, and guess at what register bits matched the loosely
25 The i82593 used in the Zenith Z-Note series operates using two(!) slave
26 DMA channels, one interrupt, and one 8-bit I/O port.
28 While there several ways to configure '593 DMA system, I chose the one
29 that seemed commensurate with the highest system performance in the face
30 of moderate interrupt latency: Both DMA channels are configured as
31 recirculating ring buffers, with one channel (#0) dedicated to Rx and
32 the other channel (#1) to Tx and configuration. (Note that this is
33 different than the Crynwr driver, where the Tx DMA channel is initialized
34 before each operation. That approach simplifies operation and Tx error
35 recovery, but requires additional I/O in normal operation and precludes
36 transmit buffer chaining.)
38 Both rings are set to 8192 bytes using {TX,RX}_RING_SIZE. This provides
39 a reasonable ring size for Rx, while simplifying DMA buffer allocation --
40 DMA buffers must not cross a 128K boundary. (In truth the size selection
41 was influenced by my lack of '593 documentation. I thus was constrained
42 to use the Crynwr '593 initialization table, which sets the Rx ring size
45 Despite my usual low opinion about Intel-designed parts, I must admit
46 that the bulk data handling of the i82593 is a good design for
47 an integrated system, like a laptop, where using two slave DMA channels
48 doesn't pose a problem. I still take issue with using only a single I/O
49 port. In the same controlled environment there are essentially no
50 limitations on I/O space, and using multiple locations would eliminate
51 the need for multiple operations when looking at status registers,
52 setting the Rx ring boundary, or switching to promiscuous mode.
54 I also question Zenith's selection of the '593: one of the advertised
55 advantages of earlier Intel parts was that if you figured out the magic
56 initialization incantation you could use the same part on many different
57 network types. Zenith's use of the "FriendlyNet" (sic) connector rather
58 than an on-board transceiver leads me to believe that they were planning
59 to take advantage of this. But, uhmmm, the '593 omits all but ethernet
60 functionality from the serial subsystem.
65 o Resurected for Linux 2.5+ by Marc Zyngier <maz@wild-wind.fr.eu.org> :
67 - Removed strange DMA snooping in znet_sent_packet, which lead to
68 TX buffer corruption on my laptop.
69 - Use init_etherdev stuff.
70 - Use kmalloc-ed DMA buffers.
71 - Use as few global variables as possible.
72 - Use proper resources management.
73 - Use wireless/i82593.h as much as possible (structure, constants)
74 - Compiles as module or build-in.
75 - Now survives unplugging/replugging cable.
77 Some code was taken from wavelan_cs.
79 Tested on a vintage Zenith Z-Note 433Lnp+. Probably broken on
80 anything else. Testers (and detailed bug reports) are welcome :-).
84 - Properly handle multicast
85 - Understand why some traffic patterns add a 1s latency...
88 #include <linux/module.h>
89 #include <linux/kernel.h>
90 #include <linux/string.h>
91 #include <linux/errno.h>
92 #include <linux/interrupt.h>
93 #include <linux/ioport.h>
94 #include <linux/init.h>
95 #include <linux/delay.h>
96 #include <linux/netdevice.h>
97 #include <linux/etherdevice.h>
98 #include <linux/skbuff.h>
99 #include <linux/if_arp.h>
100 #include <linux/bitops.h>
102 #include <asm/system.h>
106 /* This include could be elsewhere, since it is not wireless specific */
107 #include "wireless/i82593.h"
109 static char version[] __initdata = "znet.c:v1.02 9/23/94 becker@scyld.com\n";
114 static unsigned int znet_debug = ZNET_DEBUG;
115 module_param (znet_debug, int, 0);
116 MODULE_PARM_DESC (znet_debug, "ZNet debug level");
117 MODULE_LICENSE("GPL");
119 /* The DMA modes we need aren't in <dma.h>. */
120 #define DMA_RX_MODE 0x14 /* Auto init, I/O to mem, ++, demand. */
121 #define DMA_TX_MODE 0x18 /* Auto init, Mem to I/O, ++, demand. */
122 #define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
123 #define RX_BUF_SIZE 8192
124 #define TX_BUF_SIZE 8192
125 #define DMA_BUF_SIZE (RX_BUF_SIZE + 16) /* 8k + 16 bytes for trailers */
127 #define TX_TIMEOUT 10
129 struct znet_private {
132 short sia_base, sia_size, io_size;
133 struct i82593_conf_block i593_init;
134 /* The starting, current, and end pointers for the packet buffers. */
135 ushort *rx_start, *rx_cur, *rx_end;
136 ushort *tx_start, *tx_cur, *tx_end;
137 ushort tx_buf_len; /* Tx buffer length, in words. */
140 /* Only one can be built-in;-> */
141 static struct net_device *znet_dev;
144 char magic[8]; /* The magic number (string) "NETIDBLK" */
145 unsigned char netid[8]; /* The physical station address */
146 char nettype, globalopt;
147 char vendor[8]; /* The machine vendor and product name. */
149 char irq1, irq2; /* Interrupts, only one is currently used. */
151 short dma_mem_misc[8]; /* DMA buffer locations (unused in Linux). */
152 short iobase1, iosize1;
153 short iobase2, iosize2; /* Second iobase unused. */
154 char driver_options; /* Misc. bits */
158 static int znet_open(struct net_device *dev);
159 static int znet_send_packet(struct sk_buff *skb, struct net_device *dev);
160 static irqreturn_t znet_interrupt(int irq, void *dev_id);
161 static void znet_rx(struct net_device *dev);
162 static int znet_close(struct net_device *dev);
163 static void hardware_init(struct net_device *dev);
164 static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset);
165 static void znet_tx_timeout (struct net_device *dev);
167 /* Request needed resources */
168 static int znet_request_resources (struct net_device *dev)
170 struct znet_private *znet = netdev_priv(dev);
173 if (request_irq (dev->irq, &znet_interrupt, 0, "ZNet", dev))
175 if (request_dma (znet->rx_dma, "ZNet rx"))
177 if (request_dma (znet->tx_dma, "ZNet tx"))
179 if (!request_region (znet->sia_base, znet->sia_size, "ZNet SIA"))
181 if (!request_region (dev->base_addr, znet->io_size, "ZNet I/O"))
184 return 0; /* Happy ! */
187 release_region (znet->sia_base, znet->sia_size);
189 flags = claim_dma_lock();
190 free_dma (znet->tx_dma);
191 release_dma_lock (flags);
193 flags = claim_dma_lock();
194 free_dma (znet->rx_dma);
195 release_dma_lock (flags);
197 free_irq (dev->irq, dev);
202 static void znet_release_resources (struct net_device *dev)
204 struct znet_private *znet = netdev_priv(dev);
207 release_region (znet->sia_base, znet->sia_size);
208 release_region (dev->base_addr, znet->io_size);
209 flags = claim_dma_lock();
210 free_dma (znet->tx_dma);
211 free_dma (znet->rx_dma);
212 release_dma_lock (flags);
213 free_irq (dev->irq, dev);
216 /* Keep the magical SIA stuff in a single function... */
217 static void znet_transceiver_power (struct net_device *dev, int on)
219 struct znet_private *znet = netdev_priv(dev);
222 /* Turn on/off the 82501 SIA, using zenith-specific magic. */
223 /* Select LAN control register */
224 outb(0x10, znet->sia_base);
227 v = inb(znet->sia_base + 1) | 0x84;
229 v = inb(znet->sia_base + 1) & ~0x84;
231 outb(v, znet->sia_base+1); /* Turn on/off LAN power (bit 2). */
234 /* Init the i82593, with current promisc/mcast configuration.
235 Also used from hardware_init. */
236 static void znet_set_multicast_list (struct net_device *dev)
238 struct znet_private *znet = netdev_priv(dev);
239 short ioaddr = dev->base_addr;
240 struct i82593_conf_block *cfblk = &znet->i593_init;
242 memset(cfblk, 0x00, sizeof(struct i82593_conf_block));
244 /* The configuration block. What an undocumented nightmare.
245 The first set of values are those suggested (without explanation)
246 for ethernet in the Intel 82586 databook. The rest appear to be
247 completely undocumented, except for cryptic notes in the Crynwr
248 packet driver. This driver uses the Crynwr values verbatim. */
250 /* maz : Rewritten to take advantage of the wanvelan includes.
251 At least we have names, not just blind values */
254 cfblk->fifo_limit = 10; /* = 16 B rx and 80 B tx fifo thresholds */
255 cfblk->forgnesi = 0; /* 0=82C501, 1=AMD7992B compatibility */
257 cfblk->d6mod = 0; /* Run in i82593 advanced mode */
258 cfblk->throttle_enb = 1;
261 cfblk->throttle = 8; /* Continuous w/interrupts, 128-clock DMA. */
262 cfblk->cntrxint = 0; /* enable continuous mode receive interrupts */
263 cfblk->contin = 1; /* enable continuous mode */
266 cfblk->addr_len = ETH_ALEN;
267 cfblk->acloc = 1; /* Disable source addr insertion by i82593 */
268 cfblk->preamb_len = 2; /* 8 bytes preamble */
269 cfblk->loopback = 0; /* Loopback off */
272 cfblk->lin_prio = 0; /* Default priorities & backoff methods. */
278 cfblk->ifrm_spc = 6; /* 96 bit times interframe spacing */
281 cfblk->slottim_low = 0; /* 512 bit times slot time (low) */
284 cfblk->slottim_hi = 2; /* 512 bit times slot time (high) */
285 cfblk->max_retr = 15; /* 15 collisions retries */
288 cfblk->prmisc = ((dev->flags & IFF_PROMISC) ? 1 : 0); /* Promiscuous mode */
289 cfblk->bc_dis = 0; /* Enable broadcast reception */
290 cfblk->crs_1 = 0; /* Don't transmit without carrier sense */
291 cfblk->nocrc_ins = 0; /* i82593 generates CRC */
292 cfblk->crc_1632 = 0; /* 32-bit Autodin-II CRC */
293 cfblk->crs_cdt = 0; /* CD not to be interpreted as CS */
296 cfblk->cs_filter = 0; /* CS is recognized immediately */
297 cfblk->crs_src = 0; /* External carrier sense */
298 cfblk->cd_filter = 0; /* CD is recognized immediately */
301 cfblk->min_fr_len = ETH_ZLEN >> 2; /* Minimum frame length */
304 cfblk->lng_typ = 1; /* Type/length checks OFF */
305 cfblk->lng_fld = 1; /* Disable 802.3 length field check */
306 cfblk->rxcrc_xf = 1; /* Don't transfer CRC to memory */
307 cfblk->artx = 1; /* Disable automatic retransmission */
308 cfblk->sarec = 1; /* Disable source addr trig of CD */
309 cfblk->tx_jabber = 0; /* Disable jabber jam sequence */
310 cfblk->hash_1 = 1; /* Use bits 0-5 in mc address hash */
311 cfblk->lbpkpol = 0; /* Loopback pin active high */
314 cfblk->fdx = 0; /* Disable full duplex operation */
317 cfblk->dummy_6 = 0x3f; /* all ones, Default multicast addresses & backoff. */
318 cfblk->mult_ia = 0; /* No multiple individual addresses */
319 cfblk->dis_bof = 0; /* Disable the backoff algorithm ?! */
322 cfblk->dummy_1 = 1; /* set to 1 */
323 cfblk->tx_ifs_retrig = 3; /* Hmm... Disabled */
324 cfblk->mc_all = (dev->mc_list || (dev->flags&IFF_ALLMULTI));/* multicast all mode */
325 cfblk->rcv_mon = 0; /* Monitor mode disabled */
326 cfblk->frag_acpt = 0; /* Do not accept fragments */
327 cfblk->tstrttrs = 0; /* No start transmission threshold */
330 cfblk->fretx = 1; /* FIFO automatic retransmission */
331 cfblk->runt_eop = 0; /* drop "runt" packets */
332 cfblk->hw_sw_pin = 0; /* ?? */
333 cfblk->big_endn = 0; /* Big Endian ? no... */
334 cfblk->syncrqs = 1; /* Synchronous DRQ deassertion... */
335 cfblk->sttlen = 1; /* 6 byte status registers */
336 cfblk->rx_eop = 0; /* Signal EOP on packet reception */
337 cfblk->tx_eop = 0; /* Signal EOP on packet transmission */
340 cfblk->rbuf_size = RX_BUF_SIZE >> 12; /* Set receive buffer size */
341 cfblk->rcvstop = 1; /* Enable Receive Stop Register */
343 if (znet_debug > 2) {
347 for (i = 0, c = (char *) cfblk; i < sizeof (*cfblk); i++)
348 printk ("%02X ", c[i]);
352 *znet->tx_cur++ = sizeof(struct i82593_conf_block);
353 memcpy(znet->tx_cur, cfblk, sizeof(struct i82593_conf_block));
354 znet->tx_cur += sizeof(struct i82593_conf_block)/2;
355 outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
357 /* XXX FIXME maz : Add multicast addresses here, so having a
358 * multicast address configured isn't equal to IFF_ALLMULTI */
361 static const struct net_device_ops znet_netdev_ops = {
362 .ndo_open = znet_open,
363 .ndo_stop = znet_close,
364 .ndo_start_xmit = znet_send_packet,
365 .ndo_set_multicast_list = znet_set_multicast_list,
366 .ndo_tx_timeout = znet_tx_timeout,
367 .ndo_change_mtu = eth_change_mtu,
368 .ndo_set_mac_address = eth_mac_addr,
369 .ndo_validate_addr = eth_validate_addr,
372 /* The Z-Note probe is pretty easy. The NETIDBLK exists in the safe-to-probe
373 BIOS area. We just scan for the signature, and pull the vital parameters
374 out of the structure. */
376 static int __init znet_probe (void)
379 struct netidblk *netinfo;
380 struct znet_private *znet;
381 struct net_device *dev;
385 /* This code scans the region 0xf0000 to 0xfffff for a "NETIDBLK". */
386 for(p = (char *)phys_to_virt(0xf0000); p < (char *)phys_to_virt(0x100000); p++)
387 if (*p == 'N' && strncmp(p, "NETIDBLK", 8) == 0)
390 if (p >= (char *)phys_to_virt(0x100000)) {
392 printk(KERN_INFO "No Z-Note ethernet adaptor found.\n");
396 dev = alloc_etherdev(sizeof(struct znet_private));
400 znet = netdev_priv(dev);
402 netinfo = (struct netidblk *)p;
403 dev->base_addr = netinfo->iobase1;
404 dev->irq = netinfo->irq1;
406 /* The station address is in the "netidblk" at 0x0f0000. */
407 for (i = 0; i < 6; i++)
408 dev->dev_addr[i] = netinfo->netid[i];
410 printk(KERN_INFO "%s: ZNET at %#3lx, %pM"
411 ", using IRQ %d DMA %d and %d.\n",
412 dev->name, dev->base_addr, dev->dev_addr,
413 dev->irq, netinfo->dma1, netinfo->dma2);
415 if (znet_debug > 1) {
416 printk(KERN_INFO "%s: vendor '%16.16s' IRQ1 %d IRQ2 %d DMA1 %d DMA2 %d.\n",
417 dev->name, netinfo->vendor,
418 netinfo->irq1, netinfo->irq2,
419 netinfo->dma1, netinfo->dma2);
420 printk(KERN_INFO "%s: iobase1 %#x size %d iobase2 %#x size %d net type %2.2x.\n",
421 dev->name, netinfo->iobase1, netinfo->iosize1,
422 netinfo->iobase2, netinfo->iosize2, netinfo->nettype);
426 printk(KERN_INFO "%s", version);
428 znet->rx_dma = netinfo->dma1;
429 znet->tx_dma = netinfo->dma2;
430 spin_lock_init(&znet->lock);
431 znet->sia_base = 0xe6; /* Magic address for the 82501 SIA */
433 /* maz: Despite the '593 being advertised above as using a
434 * single 8bits I/O port, this driver does many 16bits
435 * access. So set io_size accordingly */
438 if (!(znet->rx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
440 if (!(znet->tx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
443 if (!dma_page_eq (znet->rx_start, znet->rx_start + (RX_BUF_SIZE/2-1)) ||
444 !dma_page_eq (znet->tx_start, znet->tx_start + (TX_BUF_SIZE/2-1))) {
445 printk (KERN_WARNING "tx/rx crossing DMA frontiers, giving up\n");
449 znet->rx_end = znet->rx_start + RX_BUF_SIZE/2;
450 znet->tx_buf_len = TX_BUF_SIZE/2;
451 znet->tx_end = znet->tx_start + znet->tx_buf_len;
453 /* The ZNET-specific entries in the device structure. */
454 dev->netdev_ops = &znet_netdev_ops;
455 dev->watchdog_timeo = TX_TIMEOUT;
456 err = register_netdev(dev);
463 kfree(znet->tx_start);
465 kfree(znet->rx_start);
472 static int znet_open(struct net_device *dev)
474 int ioaddr = dev->base_addr;
477 printk(KERN_DEBUG "%s: znet_open() called.\n", dev->name);
479 /* These should never fail. You can't add devices to a sealed box! */
480 if (znet_request_resources (dev)) {
481 printk(KERN_WARNING "%s: Not opened -- resource busy?!?\n", dev->name);
485 znet_transceiver_power (dev, 1);
487 /* According to the Crynwr driver we should wait 50 msec. for the
488 LAN clock to stabilize. My experiments indicates that the '593 can
489 be initialized immediately. The delay is probably needed for the
490 DC-to-DC converter to come up to full voltage, and for the oscillator
491 to be spot-on at 20Mhz before transmitting.
492 Until this proves to be a problem we rely on the higher layers for the
493 delay and save allocating a timer entry. */
495 /* maz : Well, I'm getting every time the following message
496 * without the delay on a 486@33. This machine is much too
497 * fast... :-) So maybe the Crynwr driver wasn't wrong after
498 * all, even if the message is completly harmless on my
502 /* This follows the packet driver's lead, and checks for success. */
503 if (inb(ioaddr) != 0x10 && inb(ioaddr) != 0x00)
504 printk(KERN_WARNING "%s: Problem turning on the transceiver power.\n",
508 netif_start_queue (dev);
514 static void znet_tx_timeout (struct net_device *dev)
516 int ioaddr = dev->base_addr;
517 ushort event, tx_status, rx_offset, state;
519 outb (CR0_STATUS_0, ioaddr);
520 event = inb (ioaddr);
521 outb (CR0_STATUS_1, ioaddr);
522 tx_status = inw (ioaddr);
523 outb (CR0_STATUS_2, ioaddr);
524 rx_offset = inw (ioaddr);
525 outb (CR0_STATUS_3, ioaddr);
526 state = inb (ioaddr);
527 printk (KERN_WARNING "%s: transmit timed out, status %02x %04x %04x %02x,"
528 " resetting.\n", dev->name, event, tx_status, rx_offset, state);
529 if (tx_status == TX_LOST_CRS)
530 printk (KERN_WARNING "%s: Tx carrier error, check transceiver cable.\n",
532 outb (OP0_RESET, ioaddr);
534 netif_wake_queue (dev);
537 static int znet_send_packet(struct sk_buff *skb, struct net_device *dev)
539 int ioaddr = dev->base_addr;
540 struct znet_private *znet = netdev_priv(dev);
542 short length = skb->len;
545 printk(KERN_DEBUG "%s: ZNet_send_packet.\n", dev->name);
547 if (length < ETH_ZLEN) {
548 if (skb_padto(skb, ETH_ZLEN))
553 netif_stop_queue (dev);
555 /* Check that the part hasn't reset itself, probably from suspend. */
556 outb(CR0_STATUS_0, ioaddr);
557 if (inw(ioaddr) == 0x0010 &&
558 inw(ioaddr) == 0x0000 &&
559 inw(ioaddr) == 0x0010) {
561 printk (KERN_WARNING "%s : waking up\n", dev->name);
563 znet_transceiver_power (dev, 1);
567 unsigned char *buf = (void *)skb->data;
568 ushort *tx_link = znet->tx_cur - 1;
569 ushort rnd_len = (length + 1)>>1;
571 dev->stats.tx_bytes+=length;
573 if (znet->tx_cur >= znet->tx_end)
574 znet->tx_cur = znet->tx_start;
575 *znet->tx_cur++ = length;
576 if (znet->tx_cur + rnd_len + 1 > znet->tx_end) {
577 int semi_cnt = (znet->tx_end - znet->tx_cur)<<1; /* Cvrt to byte cnt. */
578 memcpy(znet->tx_cur, buf, semi_cnt);
579 rnd_len -= semi_cnt>>1;
580 memcpy(znet->tx_start, buf + semi_cnt, length - semi_cnt);
581 znet->tx_cur = znet->tx_start + rnd_len;
583 memcpy(znet->tx_cur, buf, skb->len);
584 znet->tx_cur += rnd_len;
588 spin_lock_irqsave(&znet->lock, flags);
590 *tx_link = OP0_TRANSMIT | CR0_CHNL;
591 /* Is this always safe to do? */
592 outb(OP0_TRANSMIT | CR0_CHNL, ioaddr);
594 spin_unlock_irqrestore (&znet->lock, flags);
596 dev->trans_start = jiffies;
597 netif_start_queue (dev);
600 printk(KERN_DEBUG "%s: Transmitter queued, length %d.\n", dev->name, length);
606 /* The ZNET interrupt handler. */
607 static irqreturn_t znet_interrupt(int irq, void *dev_id)
609 struct net_device *dev = dev_id;
610 struct znet_private *znet = netdev_priv(dev);
615 spin_lock (&znet->lock);
617 ioaddr = dev->base_addr;
619 outb(CR0_STATUS_0, ioaddr);
621 ushort status = inb(ioaddr);
622 if (znet_debug > 5) {
623 ushort result, rx_ptr, running;
624 outb(CR0_STATUS_1, ioaddr);
625 result = inw(ioaddr);
626 outb(CR0_STATUS_2, ioaddr);
627 rx_ptr = inw(ioaddr);
628 outb(CR0_STATUS_3, ioaddr);
629 running = inb(ioaddr);
630 printk(KERN_DEBUG "%s: interrupt, status %02x, %04x %04x %02x serial %d.\n",
631 dev->name, status, result, rx_ptr, running, boguscnt);
633 if ((status & SR0_INTERRUPT) == 0)
638 if ((status & SR0_EVENT_MASK) == SR0_TRANSMIT_DONE ||
639 (status & SR0_EVENT_MASK) == SR0_RETRANSMIT_DONE ||
640 (status & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE) {
642 outb(CR0_STATUS_1, ioaddr);
643 tx_status = inw(ioaddr);
644 /* It's undocumented, but tx_status seems to match the i82586. */
645 if (tx_status & TX_OK) {
646 dev->stats.tx_packets++;
647 dev->stats.collisions += tx_status & TX_NCOL_MASK;
649 if (tx_status & (TX_LOST_CTS | TX_LOST_CRS))
650 dev->stats.tx_carrier_errors++;
651 if (tx_status & TX_UND_RUN)
652 dev->stats.tx_fifo_errors++;
653 if (!(tx_status & TX_HRT_BEAT))
654 dev->stats.tx_heartbeat_errors++;
655 if (tx_status & TX_MAX_COL)
656 dev->stats.tx_aborted_errors++;
657 /* ...and the catch-all. */
658 if ((tx_status | (TX_LOST_CRS | TX_LOST_CTS | TX_UND_RUN | TX_HRT_BEAT | TX_MAX_COL)) != (TX_LOST_CRS | TX_LOST_CTS | TX_UND_RUN | TX_HRT_BEAT | TX_MAX_COL))
659 dev->stats.tx_errors++;
661 /* Transceiver may be stuck if cable
662 * was removed while emiting a
663 * packet. Flip it off, then on to
664 * reset it. This is very empirical,
665 * but it seems to work. */
667 znet_transceiver_power (dev, 0);
668 znet_transceiver_power (dev, 1);
670 netif_wake_queue (dev);
673 if ((status & SR0_RECEPTION) ||
674 (status & SR0_EVENT_MASK) == SR0_STOP_REG_HIT) {
677 /* Clear the interrupts we've handled. */
678 outb(CR0_INT_ACK, ioaddr);
679 } while (boguscnt--);
681 spin_unlock (&znet->lock);
683 return IRQ_RETVAL(handled);
686 static void znet_rx(struct net_device *dev)
688 struct znet_private *znet = netdev_priv(dev);
689 int ioaddr = dev->base_addr;
691 short next_frame_end_offset = 0; /* Offset of next frame start. */
692 short *cur_frame_end;
693 short cur_frame_end_offset;
695 outb(CR0_STATUS_2, ioaddr);
696 cur_frame_end_offset = inw(ioaddr);
698 if (cur_frame_end_offset == znet->rx_cur - znet->rx_start) {
699 printk(KERN_WARNING "%s: Interrupted, but nothing to receive, offset %03x.\n",
700 dev->name, cur_frame_end_offset);
704 /* Use same method as the Crynwr driver: construct a forward list in
705 the same area of the backwards links we now have. This allows us to
706 pass packets to the upper layers in the order they were received --
707 important for fast-path sequential operations. */
708 while (znet->rx_start + cur_frame_end_offset != znet->rx_cur
709 && ++boguscount < 5) {
710 unsigned short hi_cnt, lo_cnt, hi_status, lo_status;
713 if (cur_frame_end_offset < 4) {
714 /* Oh no, we have a special case: the frame trailer wraps around
715 the end of the ring buffer. We've saved space at the end of
716 the ring buffer for just this problem. */
717 memcpy(znet->rx_end, znet->rx_start, 8);
718 cur_frame_end_offset += (RX_BUF_SIZE/2);
720 cur_frame_end = znet->rx_start + cur_frame_end_offset - 4;
722 lo_status = *cur_frame_end++;
723 hi_status = *cur_frame_end++;
724 status = ((hi_status & 0xff) << 8) + (lo_status & 0xff);
725 lo_cnt = *cur_frame_end++;
726 hi_cnt = *cur_frame_end++;
727 count = ((hi_cnt & 0xff) << 8) + (lo_cnt & 0xff);
730 printk(KERN_DEBUG "Constructing trailer at location %03x, %04x %04x %04x %04x"
731 " count %#x status %04x.\n",
732 cur_frame_end_offset<<1, lo_status, hi_status, lo_cnt, hi_cnt,
734 cur_frame_end[-4] = status;
735 cur_frame_end[-3] = next_frame_end_offset;
736 cur_frame_end[-2] = count;
737 next_frame_end_offset = cur_frame_end_offset;
738 cur_frame_end_offset -= ((count + 1)>>1) + 3;
739 if (cur_frame_end_offset < 0)
740 cur_frame_end_offset += RX_BUF_SIZE/2;
743 /* Now step forward through the list. */
745 ushort *this_rfp_ptr = znet->rx_start + next_frame_end_offset;
746 int status = this_rfp_ptr[-4];
747 int pkt_len = this_rfp_ptr[-2];
750 printk(KERN_DEBUG "Looking at trailer ending at %04x status %04x length %03x"
751 " next %04x.\n", next_frame_end_offset<<1, status, pkt_len,
752 this_rfp_ptr[-3]<<1);
753 /* Once again we must assume that the i82586 docs apply. */
754 if ( ! (status & RX_RCV_OK)) { /* There was an error. */
755 dev->stats.rx_errors++;
756 if (status & RX_CRC_ERR) dev->stats.rx_crc_errors++;
757 if (status & RX_ALG_ERR) dev->stats.rx_frame_errors++;
759 if (status & 0x0200) dev->stats.rx_over_errors++; /* Wrong. */
760 if (status & 0x0100) dev->stats.rx_fifo_errors++;
762 /* maz : Wild guess... */
763 if (status & RX_OVRRUN) dev->stats.rx_over_errors++;
765 if (status & RX_SRT_FRM) dev->stats.rx_length_errors++;
766 } else if (pkt_len > 1536) {
767 dev->stats.rx_length_errors++;
769 /* Malloc up new buffer. */
772 skb = dev_alloc_skb(pkt_len);
775 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
776 dev->stats.rx_dropped++;
780 if (&znet->rx_cur[(pkt_len+1)>>1] > znet->rx_end) {
781 int semi_cnt = (znet->rx_end - znet->rx_cur)<<1;
782 memcpy(skb_put(skb,semi_cnt), znet->rx_cur, semi_cnt);
783 memcpy(skb_put(skb,pkt_len-semi_cnt), znet->rx_start,
786 memcpy(skb_put(skb,pkt_len), znet->rx_cur, pkt_len);
787 if (znet_debug > 6) {
788 unsigned int *packet = (unsigned int *) skb->data;
789 printk(KERN_DEBUG "Packet data is %08x %08x %08x %08x.\n", packet[0],
790 packet[1], packet[2], packet[3]);
793 skb->protocol=eth_type_trans(skb,dev);
795 dev->stats.rx_packets++;
796 dev->stats.rx_bytes += pkt_len;
798 znet->rx_cur = this_rfp_ptr;
799 if (znet->rx_cur >= znet->rx_end)
800 znet->rx_cur -= RX_BUF_SIZE/2;
801 update_stop_hit(ioaddr, (znet->rx_cur - znet->rx_start)<<1);
802 next_frame_end_offset = this_rfp_ptr[-3];
803 if (next_frame_end_offset == 0) /* Read all the frames? */
804 break; /* Done for now */
805 this_rfp_ptr = znet->rx_start + next_frame_end_offset;
806 } while (--boguscount);
808 /* If any worth-while packets have been received, dev_rint()
809 has done a mark_bh(INET_BH) for us and will work on them
810 when we get to the bottom-half routine. */
814 /* The inverse routine to znet_open(). */
815 static int znet_close(struct net_device *dev)
817 int ioaddr = dev->base_addr;
819 netif_stop_queue (dev);
821 outb(OP0_RESET, ioaddr); /* CMD0_RESET */
824 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
825 /* Turn off transceiver power. */
826 znet_transceiver_power (dev, 0);
828 znet_release_resources (dev);
833 static void show_dma(struct net_device *dev)
835 short ioaddr = dev->base_addr;
836 unsigned char stat = inb (ioaddr);
837 struct znet_private *znet = netdev_priv(dev);
839 short dma_port = ((znet->tx_dma&3)<<2) + IO_DMA2_BASE;
840 unsigned addr = inb(dma_port);
843 addr |= inb(dma_port) << 8;
844 residue = get_dma_residue(znet->tx_dma);
846 if (znet_debug > 1) {
847 flags=claim_dma_lock();
848 printk(KERN_DEBUG "Stat:%02x Addr: %04x cnt:%3x\n",
849 stat, addr<<1, residue);
850 release_dma_lock(flags);
854 /* Initialize the hardware. We have to do this when the board is open()ed
855 or when we come out of suspend mode. */
856 static void hardware_init(struct net_device *dev)
859 short ioaddr = dev->base_addr;
860 struct znet_private *znet = netdev_priv(dev);
862 znet->rx_cur = znet->rx_start;
863 znet->tx_cur = znet->tx_start;
865 /* Reset the chip, and start it up. */
866 outb(OP0_RESET, ioaddr);
868 flags=claim_dma_lock();
869 disable_dma(znet->rx_dma); /* reset by an interrupting task. */
870 clear_dma_ff(znet->rx_dma);
871 set_dma_mode(znet->rx_dma, DMA_RX_MODE);
872 set_dma_addr(znet->rx_dma, (unsigned int) znet->rx_start);
873 set_dma_count(znet->rx_dma, RX_BUF_SIZE);
874 enable_dma(znet->rx_dma);
875 /* Now set up the Tx channel. */
876 disable_dma(znet->tx_dma);
877 clear_dma_ff(znet->tx_dma);
878 set_dma_mode(znet->tx_dma, DMA_TX_MODE);
879 set_dma_addr(znet->tx_dma, (unsigned int) znet->tx_start);
880 set_dma_count(znet->tx_dma, znet->tx_buf_len<<1);
881 enable_dma(znet->tx_dma);
882 release_dma_lock(flags);
885 printk(KERN_DEBUG "%s: Initializing the i82593, rx buf %p tx buf %p\n",
886 dev->name, znet->rx_start,znet->tx_start);
887 /* Do an empty configure command, just like the Crynwr driver. This
888 resets to chip to its default values. */
892 outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
894 znet_set_multicast_list (dev);
897 memcpy(znet->tx_cur, dev->dev_addr, 6);
900 outb(OP0_IA_SETUP | CR0_CHNL, ioaddr);
903 update_stop_hit(ioaddr, 8192);
904 if (znet_debug > 1) printk(KERN_DEBUG "enabling Rx.\n");
905 outb(OP0_RCV_ENABLE, ioaddr);
906 netif_start_queue (dev);
909 static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset)
911 outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, ioaddr);
913 printk(KERN_DEBUG "Updating stop hit with value %02x.\n",
914 (rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE);
915 outb((rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE, ioaddr);
916 outb(OP1_SWIT_TO_PORT_0, ioaddr);
919 static __exit void znet_cleanup (void)
922 struct znet_private *znet = netdev_priv(znet_dev);
924 unregister_netdev (znet_dev);
925 kfree (znet->rx_start);
926 kfree (znet->tx_start);
927 free_netdev (znet_dev);
931 module_init (znet_probe);
932 module_exit (znet_cleanup);