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 {
131 struct net_device_stats stats;
133 short sia_base, sia_size, io_size;
134 struct i82593_conf_block i593_init;
135 /* The starting, current, and end pointers for the packet buffers. */
136 ushort *rx_start, *rx_cur, *rx_end;
137 ushort *tx_start, *tx_cur, *tx_end;
138 ushort tx_buf_len; /* Tx buffer length, in words. */
141 /* Only one can be built-in;-> */
142 static struct net_device *znet_dev;
145 char magic[8]; /* The magic number (string) "NETIDBLK" */
146 unsigned char netid[8]; /* The physical station address */
147 char nettype, globalopt;
148 char vendor[8]; /* The machine vendor and product name. */
150 char irq1, irq2; /* Interrupts, only one is currently used. */
152 short dma_mem_misc[8]; /* DMA buffer locations (unused in Linux). */
153 short iobase1, iosize1;
154 short iobase2, iosize2; /* Second iobase unused. */
155 char driver_options; /* Misc. bits */
159 static int znet_open(struct net_device *dev);
160 static int znet_send_packet(struct sk_buff *skb, struct net_device *dev);
161 static irqreturn_t znet_interrupt(int irq, void *dev_id);
162 static void znet_rx(struct net_device *dev);
163 static int znet_close(struct net_device *dev);
164 static struct net_device_stats *net_get_stats(struct net_device *dev);
165 static void hardware_init(struct net_device *dev);
166 static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset);
167 static void znet_tx_timeout (struct net_device *dev);
169 /* Request needed resources */
170 static int znet_request_resources (struct net_device *dev)
172 struct znet_private *znet = dev->priv;
175 if (request_irq (dev->irq, &znet_interrupt, 0, "ZNet", dev))
177 if (request_dma (znet->rx_dma, "ZNet rx"))
179 if (request_dma (znet->tx_dma, "ZNet tx"))
181 if (!request_region (znet->sia_base, znet->sia_size, "ZNet SIA"))
183 if (!request_region (dev->base_addr, znet->io_size, "ZNet I/O"))
186 return 0; /* Happy ! */
189 release_region (znet->sia_base, znet->sia_size);
191 flags = claim_dma_lock();
192 free_dma (znet->tx_dma);
193 release_dma_lock (flags);
195 flags = claim_dma_lock();
196 free_dma (znet->rx_dma);
197 release_dma_lock (flags);
199 free_irq (dev->irq, dev);
204 static void znet_release_resources (struct net_device *dev)
206 struct znet_private *znet = dev->priv;
209 release_region (znet->sia_base, znet->sia_size);
210 release_region (dev->base_addr, znet->io_size);
211 flags = claim_dma_lock();
212 free_dma (znet->tx_dma);
213 free_dma (znet->rx_dma);
214 release_dma_lock (flags);
215 free_irq (dev->irq, dev);
218 /* Keep the magical SIA stuff in a single function... */
219 static void znet_transceiver_power (struct net_device *dev, int on)
221 struct znet_private *znet = dev->priv;
224 /* Turn on/off the 82501 SIA, using zenith-specific magic. */
225 /* Select LAN control register */
226 outb(0x10, znet->sia_base);
229 v = inb(znet->sia_base + 1) | 0x84;
231 v = inb(znet->sia_base + 1) & ~0x84;
233 outb(v, znet->sia_base+1); /* Turn on/off LAN power (bit 2). */
236 /* Init the i82593, with current promisc/mcast configuration.
237 Also used from hardware_init. */
238 static void znet_set_multicast_list (struct net_device *dev)
240 struct znet_private *znet = dev->priv;
241 short ioaddr = dev->base_addr;
242 struct i82593_conf_block *cfblk = &znet->i593_init;
244 memset(cfblk, 0x00, sizeof(struct i82593_conf_block));
246 /* The configuration block. What an undocumented nightmare.
247 The first set of values are those suggested (without explanation)
248 for ethernet in the Intel 82586 databook. The rest appear to be
249 completely undocumented, except for cryptic notes in the Crynwr
250 packet driver. This driver uses the Crynwr values verbatim. */
252 /* maz : Rewritten to take advantage of the wanvelan includes.
253 At least we have names, not just blind values */
256 cfblk->fifo_limit = 10; /* = 16 B rx and 80 B tx fifo thresholds */
257 cfblk->forgnesi = 0; /* 0=82C501, 1=AMD7992B compatibility */
259 cfblk->d6mod = 0; /* Run in i82593 advanced mode */
260 cfblk->throttle_enb = 1;
263 cfblk->throttle = 8; /* Continuous w/interrupts, 128-clock DMA. */
264 cfblk->cntrxint = 0; /* enable continuous mode receive interrupts */
265 cfblk->contin = 1; /* enable continuous mode */
268 cfblk->addr_len = ETH_ALEN;
269 cfblk->acloc = 1; /* Disable source addr insertion by i82593 */
270 cfblk->preamb_len = 2; /* 8 bytes preamble */
271 cfblk->loopback = 0; /* Loopback off */
274 cfblk->lin_prio = 0; /* Default priorities & backoff methods. */
280 cfblk->ifrm_spc = 6; /* 96 bit times interframe spacing */
283 cfblk->slottim_low = 0; /* 512 bit times slot time (low) */
286 cfblk->slottim_hi = 2; /* 512 bit times slot time (high) */
287 cfblk->max_retr = 15; /* 15 collisions retries */
290 cfblk->prmisc = ((dev->flags & IFF_PROMISC) ? 1 : 0); /* Promiscuous mode */
291 cfblk->bc_dis = 0; /* Enable broadcast reception */
292 cfblk->crs_1 = 0; /* Don't transmit without carrier sense */
293 cfblk->nocrc_ins = 0; /* i82593 generates CRC */
294 cfblk->crc_1632 = 0; /* 32-bit Autodin-II CRC */
295 cfblk->crs_cdt = 0; /* CD not to be interpreted as CS */
298 cfblk->cs_filter = 0; /* CS is recognized immediately */
299 cfblk->crs_src = 0; /* External carrier sense */
300 cfblk->cd_filter = 0; /* CD is recognized immediately */
303 cfblk->min_fr_len = ETH_ZLEN >> 2; /* Minimum frame length */
306 cfblk->lng_typ = 1; /* Type/length checks OFF */
307 cfblk->lng_fld = 1; /* Disable 802.3 length field check */
308 cfblk->rxcrc_xf = 1; /* Don't transfer CRC to memory */
309 cfblk->artx = 1; /* Disable automatic retransmission */
310 cfblk->sarec = 1; /* Disable source addr trig of CD */
311 cfblk->tx_jabber = 0; /* Disable jabber jam sequence */
312 cfblk->hash_1 = 1; /* Use bits 0-5 in mc address hash */
313 cfblk->lbpkpol = 0; /* Loopback pin active high */
316 cfblk->fdx = 0; /* Disable full duplex operation */
319 cfblk->dummy_6 = 0x3f; /* all ones, Default multicast addresses & backoff. */
320 cfblk->mult_ia = 0; /* No multiple individual addresses */
321 cfblk->dis_bof = 0; /* Disable the backoff algorithm ?! */
324 cfblk->dummy_1 = 1; /* set to 1 */
325 cfblk->tx_ifs_retrig = 3; /* Hmm... Disabled */
326 cfblk->mc_all = (dev->mc_list || (dev->flags&IFF_ALLMULTI));/* multicast all mode */
327 cfblk->rcv_mon = 0; /* Monitor mode disabled */
328 cfblk->frag_acpt = 0; /* Do not accept fragments */
329 cfblk->tstrttrs = 0; /* No start transmission threshold */
332 cfblk->fretx = 1; /* FIFO automatic retransmission */
333 cfblk->runt_eop = 0; /* drop "runt" packets */
334 cfblk->hw_sw_pin = 0; /* ?? */
335 cfblk->big_endn = 0; /* Big Endian ? no... */
336 cfblk->syncrqs = 1; /* Synchronous DRQ deassertion... */
337 cfblk->sttlen = 1; /* 6 byte status registers */
338 cfblk->rx_eop = 0; /* Signal EOP on packet reception */
339 cfblk->tx_eop = 0; /* Signal EOP on packet transmission */
342 cfblk->rbuf_size = RX_BUF_SIZE >> 12; /* Set receive buffer size */
343 cfblk->rcvstop = 1; /* Enable Receive Stop Register */
345 if (znet_debug > 2) {
349 for (i = 0, c = (char *) cfblk; i < sizeof (*cfblk); i++)
350 printk ("%02X ", c[i]);
354 *znet->tx_cur++ = sizeof(struct i82593_conf_block);
355 memcpy(znet->tx_cur, cfblk, sizeof(struct i82593_conf_block));
356 znet->tx_cur += sizeof(struct i82593_conf_block)/2;
357 outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
359 /* XXX FIXME maz : Add multicast addresses here, so having a
360 * multicast address configured isn't equal to IFF_ALLMULTI */
363 /* The Z-Note probe is pretty easy. The NETIDBLK exists in the safe-to-probe
364 BIOS area. We just scan for the signature, and pull the vital parameters
365 out of the structure. */
367 static int __init znet_probe (void)
370 struct netidblk *netinfo;
371 struct znet_private *znet;
372 struct net_device *dev;
376 /* This code scans the region 0xf0000 to 0xfffff for a "NETIDBLK". */
377 for(p = (char *)phys_to_virt(0xf0000); p < (char *)phys_to_virt(0x100000); p++)
378 if (*p == 'N' && strncmp(p, "NETIDBLK", 8) == 0)
381 if (p >= (char *)phys_to_virt(0x100000)) {
383 printk(KERN_INFO "No Z-Note ethernet adaptor found.\n");
387 dev = alloc_etherdev(sizeof(struct znet_private));
393 netinfo = (struct netidblk *)p;
394 dev->base_addr = netinfo->iobase1;
395 dev->irq = netinfo->irq1;
397 printk(KERN_INFO "%s: ZNET at %#3lx,", dev->name, dev->base_addr);
399 /* The station address is in the "netidblk" at 0x0f0000. */
400 for (i = 0; i < 6; i++)
401 printk(" %2.2x", dev->dev_addr[i] = netinfo->netid[i]);
403 printk(", using IRQ %d DMA %d and %d.\n", dev->irq, netinfo->dma1,
406 if (znet_debug > 1) {
407 printk(KERN_INFO "%s: vendor '%16.16s' IRQ1 %d IRQ2 %d DMA1 %d DMA2 %d.\n",
408 dev->name, netinfo->vendor,
409 netinfo->irq1, netinfo->irq2,
410 netinfo->dma1, netinfo->dma2);
411 printk(KERN_INFO "%s: iobase1 %#x size %d iobase2 %#x size %d net type %2.2x.\n",
412 dev->name, netinfo->iobase1, netinfo->iosize1,
413 netinfo->iobase2, netinfo->iosize2, netinfo->nettype);
417 printk(KERN_INFO "%s", version);
419 znet->rx_dma = netinfo->dma1;
420 znet->tx_dma = netinfo->dma2;
421 spin_lock_init(&znet->lock);
422 znet->sia_base = 0xe6; /* Magic address for the 82501 SIA */
424 /* maz: Despite the '593 being advertised above as using a
425 * single 8bits I/O port, this driver does many 16bits
426 * access. So set io_size accordingly */
429 if (!(znet->rx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
431 if (!(znet->tx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
434 if (!dma_page_eq (znet->rx_start, znet->rx_start + (RX_BUF_SIZE/2-1)) ||
435 !dma_page_eq (znet->tx_start, znet->tx_start + (TX_BUF_SIZE/2-1))) {
436 printk (KERN_WARNING "tx/rx crossing DMA frontiers, giving up\n");
440 znet->rx_end = znet->rx_start + RX_BUF_SIZE/2;
441 znet->tx_buf_len = TX_BUF_SIZE/2;
442 znet->tx_end = znet->tx_start + znet->tx_buf_len;
444 /* The ZNET-specific entries in the device structure. */
445 dev->open = &znet_open;
446 dev->hard_start_xmit = &znet_send_packet;
447 dev->stop = &znet_close;
448 dev->get_stats = net_get_stats;
449 dev->set_multicast_list = &znet_set_multicast_list;
450 dev->tx_timeout = znet_tx_timeout;
451 dev->watchdog_timeo = TX_TIMEOUT;
452 err = register_netdev(dev);
459 kfree(znet->tx_start);
461 kfree(znet->rx_start);
468 static int znet_open(struct net_device *dev)
470 int ioaddr = dev->base_addr;
473 printk(KERN_DEBUG "%s: znet_open() called.\n", dev->name);
475 /* These should never fail. You can't add devices to a sealed box! */
476 if (znet_request_resources (dev)) {
477 printk(KERN_WARNING "%s: Not opened -- resource busy?!?\n", dev->name);
481 znet_transceiver_power (dev, 1);
483 /* According to the Crynwr driver we should wait 50 msec. for the
484 LAN clock to stabilize. My experiments indicates that the '593 can
485 be initialized immediately. The delay is probably needed for the
486 DC-to-DC converter to come up to full voltage, and for the oscillator
487 to be spot-on at 20Mhz before transmitting.
488 Until this proves to be a problem we rely on the higher layers for the
489 delay and save allocating a timer entry. */
491 /* maz : Well, I'm getting every time the following message
492 * without the delay on a 486@33. This machine is much too
493 * fast... :-) So maybe the Crynwr driver wasn't wrong after
494 * all, even if the message is completly harmless on my
498 /* This follows the packet driver's lead, and checks for success. */
499 if (inb(ioaddr) != 0x10 && inb(ioaddr) != 0x00)
500 printk(KERN_WARNING "%s: Problem turning on the transceiver power.\n",
504 netif_start_queue (dev);
510 static void znet_tx_timeout (struct net_device *dev)
512 int ioaddr = dev->base_addr;
513 ushort event, tx_status, rx_offset, state;
515 outb (CR0_STATUS_0, ioaddr);
516 event = inb (ioaddr);
517 outb (CR0_STATUS_1, ioaddr);
518 tx_status = inw (ioaddr);
519 outb (CR0_STATUS_2, ioaddr);
520 rx_offset = inw (ioaddr);
521 outb (CR0_STATUS_3, ioaddr);
522 state = inb (ioaddr);
523 printk (KERN_WARNING "%s: transmit timed out, status %02x %04x %04x %02x,"
524 " resetting.\n", dev->name, event, tx_status, rx_offset, state);
525 if (tx_status == TX_LOST_CRS)
526 printk (KERN_WARNING "%s: Tx carrier error, check transceiver cable.\n",
528 outb (OP0_RESET, ioaddr);
530 netif_wake_queue (dev);
533 static int znet_send_packet(struct sk_buff *skb, struct net_device *dev)
535 int ioaddr = dev->base_addr;
536 struct znet_private *znet = dev->priv;
538 short length = skb->len;
541 printk(KERN_DEBUG "%s: ZNet_send_packet.\n", dev->name);
543 if (length < ETH_ZLEN) {
544 if (skb_padto(skb, ETH_ZLEN))
549 netif_stop_queue (dev);
551 /* Check that the part hasn't reset itself, probably from suspend. */
552 outb(CR0_STATUS_0, ioaddr);
553 if (inw(ioaddr) == 0x0010 &&
554 inw(ioaddr) == 0x0000 &&
555 inw(ioaddr) == 0x0010) {
557 printk (KERN_WARNING "%s : waking up\n", dev->name);
559 znet_transceiver_power (dev, 1);
563 unsigned char *buf = (void *)skb->data;
564 ushort *tx_link = znet->tx_cur - 1;
565 ushort rnd_len = (length + 1)>>1;
567 znet->stats.tx_bytes+=length;
569 if (znet->tx_cur >= znet->tx_end)
570 znet->tx_cur = znet->tx_start;
571 *znet->tx_cur++ = length;
572 if (znet->tx_cur + rnd_len + 1 > znet->tx_end) {
573 int semi_cnt = (znet->tx_end - znet->tx_cur)<<1; /* Cvrt to byte cnt. */
574 memcpy(znet->tx_cur, buf, semi_cnt);
575 rnd_len -= semi_cnt>>1;
576 memcpy(znet->tx_start, buf + semi_cnt, length - semi_cnt);
577 znet->tx_cur = znet->tx_start + rnd_len;
579 memcpy(znet->tx_cur, buf, skb->len);
580 znet->tx_cur += rnd_len;
584 spin_lock_irqsave(&znet->lock, flags);
586 *tx_link = OP0_TRANSMIT | CR0_CHNL;
587 /* Is this always safe to do? */
588 outb(OP0_TRANSMIT | CR0_CHNL, ioaddr);
590 spin_unlock_irqrestore (&znet->lock, flags);
592 dev->trans_start = jiffies;
593 netif_start_queue (dev);
596 printk(KERN_DEBUG "%s: Transmitter queued, length %d.\n", dev->name, length);
602 /* The ZNET interrupt handler. */
603 static irqreturn_t znet_interrupt(int irq, void *dev_id)
605 struct net_device *dev = dev_id;
606 struct znet_private *znet = dev->priv;
611 spin_lock (&znet->lock);
613 ioaddr = dev->base_addr;
615 outb(CR0_STATUS_0, ioaddr);
617 ushort status = inb(ioaddr);
618 if (znet_debug > 5) {
619 ushort result, rx_ptr, running;
620 outb(CR0_STATUS_1, ioaddr);
621 result = inw(ioaddr);
622 outb(CR0_STATUS_2, ioaddr);
623 rx_ptr = inw(ioaddr);
624 outb(CR0_STATUS_3, ioaddr);
625 running = inb(ioaddr);
626 printk(KERN_DEBUG "%s: interrupt, status %02x, %04x %04x %02x serial %d.\n",
627 dev->name, status, result, rx_ptr, running, boguscnt);
629 if ((status & SR0_INTERRUPT) == 0)
634 if ((status & SR0_EVENT_MASK) == SR0_TRANSMIT_DONE ||
635 (status & SR0_EVENT_MASK) == SR0_RETRANSMIT_DONE ||
636 (status & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE) {
638 outb(CR0_STATUS_1, ioaddr);
639 tx_status = inw(ioaddr);
640 /* It's undocumented, but tx_status seems to match the i82586. */
641 if (tx_status & TX_OK) {
642 znet->stats.tx_packets++;
643 znet->stats.collisions += tx_status & TX_NCOL_MASK;
645 if (tx_status & (TX_LOST_CTS | TX_LOST_CRS))
646 znet->stats.tx_carrier_errors++;
647 if (tx_status & TX_UND_RUN)
648 znet->stats.tx_fifo_errors++;
649 if (!(tx_status & TX_HRT_BEAT))
650 znet->stats.tx_heartbeat_errors++;
651 if (tx_status & TX_MAX_COL)
652 znet->stats.tx_aborted_errors++;
653 /* ...and the catch-all. */
654 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))
655 znet->stats.tx_errors++;
657 /* Transceiver may be stuck if cable
658 * was removed while emiting a
659 * packet. Flip it off, then on to
660 * reset it. This is very empirical,
661 * but it seems to work. */
663 znet_transceiver_power (dev, 0);
664 znet_transceiver_power (dev, 1);
666 netif_wake_queue (dev);
669 if ((status & SR0_RECEPTION) ||
670 (status & SR0_EVENT_MASK) == SR0_STOP_REG_HIT) {
673 /* Clear the interrupts we've handled. */
674 outb(CR0_INT_ACK, ioaddr);
675 } while (boguscnt--);
677 spin_unlock (&znet->lock);
679 return IRQ_RETVAL(handled);
682 static void znet_rx(struct net_device *dev)
684 struct znet_private *znet = dev->priv;
685 int ioaddr = dev->base_addr;
687 short next_frame_end_offset = 0; /* Offset of next frame start. */
688 short *cur_frame_end;
689 short cur_frame_end_offset;
691 outb(CR0_STATUS_2, ioaddr);
692 cur_frame_end_offset = inw(ioaddr);
694 if (cur_frame_end_offset == znet->rx_cur - znet->rx_start) {
695 printk(KERN_WARNING "%s: Interrupted, but nothing to receive, offset %03x.\n",
696 dev->name, cur_frame_end_offset);
700 /* Use same method as the Crynwr driver: construct a forward list in
701 the same area of the backwards links we now have. This allows us to
702 pass packets to the upper layers in the order they were received --
703 important for fast-path sequential operations. */
704 while (znet->rx_start + cur_frame_end_offset != znet->rx_cur
705 && ++boguscount < 5) {
706 unsigned short hi_cnt, lo_cnt, hi_status, lo_status;
709 if (cur_frame_end_offset < 4) {
710 /* Oh no, we have a special case: the frame trailer wraps around
711 the end of the ring buffer. We've saved space at the end of
712 the ring buffer for just this problem. */
713 memcpy(znet->rx_end, znet->rx_start, 8);
714 cur_frame_end_offset += (RX_BUF_SIZE/2);
716 cur_frame_end = znet->rx_start + cur_frame_end_offset - 4;
718 lo_status = *cur_frame_end++;
719 hi_status = *cur_frame_end++;
720 status = ((hi_status & 0xff) << 8) + (lo_status & 0xff);
721 lo_cnt = *cur_frame_end++;
722 hi_cnt = *cur_frame_end++;
723 count = ((hi_cnt & 0xff) << 8) + (lo_cnt & 0xff);
726 printk(KERN_DEBUG "Constructing trailer at location %03x, %04x %04x %04x %04x"
727 " count %#x status %04x.\n",
728 cur_frame_end_offset<<1, lo_status, hi_status, lo_cnt, hi_cnt,
730 cur_frame_end[-4] = status;
731 cur_frame_end[-3] = next_frame_end_offset;
732 cur_frame_end[-2] = count;
733 next_frame_end_offset = cur_frame_end_offset;
734 cur_frame_end_offset -= ((count + 1)>>1) + 3;
735 if (cur_frame_end_offset < 0)
736 cur_frame_end_offset += RX_BUF_SIZE/2;
739 /* Now step forward through the list. */
741 ushort *this_rfp_ptr = znet->rx_start + next_frame_end_offset;
742 int status = this_rfp_ptr[-4];
743 int pkt_len = this_rfp_ptr[-2];
746 printk(KERN_DEBUG "Looking at trailer ending at %04x status %04x length %03x"
747 " next %04x.\n", next_frame_end_offset<<1, status, pkt_len,
748 this_rfp_ptr[-3]<<1);
749 /* Once again we must assume that the i82586 docs apply. */
750 if ( ! (status & RX_RCV_OK)) { /* There was an error. */
751 znet->stats.rx_errors++;
752 if (status & RX_CRC_ERR) znet->stats.rx_crc_errors++;
753 if (status & RX_ALG_ERR) znet->stats.rx_frame_errors++;
755 if (status & 0x0200) znet->stats.rx_over_errors++; /* Wrong. */
756 if (status & 0x0100) znet->stats.rx_fifo_errors++;
758 /* maz : Wild guess... */
759 if (status & RX_OVRRUN) znet->stats.rx_over_errors++;
761 if (status & RX_SRT_FRM) znet->stats.rx_length_errors++;
762 } else if (pkt_len > 1536) {
763 znet->stats.rx_length_errors++;
765 /* Malloc up new buffer. */
768 skb = dev_alloc_skb(pkt_len);
771 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
772 znet->stats.rx_dropped++;
776 if (&znet->rx_cur[(pkt_len+1)>>1] > znet->rx_end) {
777 int semi_cnt = (znet->rx_end - znet->rx_cur)<<1;
778 memcpy(skb_put(skb,semi_cnt), znet->rx_cur, semi_cnt);
779 memcpy(skb_put(skb,pkt_len-semi_cnt), znet->rx_start,
782 memcpy(skb_put(skb,pkt_len), znet->rx_cur, pkt_len);
783 if (znet_debug > 6) {
784 unsigned int *packet = (unsigned int *) skb->data;
785 printk(KERN_DEBUG "Packet data is %08x %08x %08x %08x.\n", packet[0],
786 packet[1], packet[2], packet[3]);
789 skb->protocol=eth_type_trans(skb,dev);
791 dev->last_rx = jiffies;
792 znet->stats.rx_packets++;
793 znet->stats.rx_bytes += pkt_len;
795 znet->rx_cur = this_rfp_ptr;
796 if (znet->rx_cur >= znet->rx_end)
797 znet->rx_cur -= RX_BUF_SIZE/2;
798 update_stop_hit(ioaddr, (znet->rx_cur - znet->rx_start)<<1);
799 next_frame_end_offset = this_rfp_ptr[-3];
800 if (next_frame_end_offset == 0) /* Read all the frames? */
801 break; /* Done for now */
802 this_rfp_ptr = znet->rx_start + next_frame_end_offset;
803 } while (--boguscount);
805 /* If any worth-while packets have been received, dev_rint()
806 has done a mark_bh(INET_BH) for us and will work on them
807 when we get to the bottom-half routine. */
811 /* The inverse routine to znet_open(). */
812 static int znet_close(struct net_device *dev)
814 int ioaddr = dev->base_addr;
816 netif_stop_queue (dev);
818 outb(OP0_RESET, ioaddr); /* CMD0_RESET */
821 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
822 /* Turn off transceiver power. */
823 znet_transceiver_power (dev, 0);
825 znet_release_resources (dev);
830 /* Get the current statistics. This may be called with the card open or
832 static struct net_device_stats *net_get_stats(struct net_device *dev)
834 struct znet_private *znet = dev->priv;
839 static void show_dma(struct net_device *dev)
841 short ioaddr = dev->base_addr;
842 unsigned char stat = inb (ioaddr);
843 struct znet_private *znet = dev->priv;
845 short dma_port = ((znet->tx_dma&3)<<2) + IO_DMA2_BASE;
846 unsigned addr = inb(dma_port);
849 addr |= inb(dma_port) << 8;
850 residue = get_dma_residue(znet->tx_dma);
852 if (znet_debug > 1) {
853 flags=claim_dma_lock();
854 printk(KERN_DEBUG "Stat:%02x Addr: %04x cnt:%3x\n",
855 stat, addr<<1, residue);
856 release_dma_lock(flags);
860 /* Initialize the hardware. We have to do this when the board is open()ed
861 or when we come out of suspend mode. */
862 static void hardware_init(struct net_device *dev)
865 short ioaddr = dev->base_addr;
866 struct znet_private *znet = dev->priv;
868 znet->rx_cur = znet->rx_start;
869 znet->tx_cur = znet->tx_start;
871 /* Reset the chip, and start it up. */
872 outb(OP0_RESET, ioaddr);
874 flags=claim_dma_lock();
875 disable_dma(znet->rx_dma); /* reset by an interrupting task. */
876 clear_dma_ff(znet->rx_dma);
877 set_dma_mode(znet->rx_dma, DMA_RX_MODE);
878 set_dma_addr(znet->rx_dma, (unsigned int) znet->rx_start);
879 set_dma_count(znet->rx_dma, RX_BUF_SIZE);
880 enable_dma(znet->rx_dma);
881 /* Now set up the Tx channel. */
882 disable_dma(znet->tx_dma);
883 clear_dma_ff(znet->tx_dma);
884 set_dma_mode(znet->tx_dma, DMA_TX_MODE);
885 set_dma_addr(znet->tx_dma, (unsigned int) znet->tx_start);
886 set_dma_count(znet->tx_dma, znet->tx_buf_len<<1);
887 enable_dma(znet->tx_dma);
888 release_dma_lock(flags);
891 printk(KERN_DEBUG "%s: Initializing the i82593, rx buf %p tx buf %p\n",
892 dev->name, znet->rx_start,znet->tx_start);
893 /* Do an empty configure command, just like the Crynwr driver. This
894 resets to chip to its default values. */
898 outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
900 znet_set_multicast_list (dev);
903 memcpy(znet->tx_cur, dev->dev_addr, 6);
906 outb(OP0_IA_SETUP | CR0_CHNL, ioaddr);
909 update_stop_hit(ioaddr, 8192);
910 if (znet_debug > 1) printk(KERN_DEBUG "enabling Rx.\n");
911 outb(OP0_RCV_ENABLE, ioaddr);
912 netif_start_queue (dev);
915 static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset)
917 outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, ioaddr);
919 printk(KERN_DEBUG "Updating stop hit with value %02x.\n",
920 (rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE);
921 outb((rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE, ioaddr);
922 outb(OP1_SWIT_TO_PORT_0, ioaddr);
925 static __exit void znet_cleanup (void)
928 struct znet_private *znet = znet_dev->priv;
930 unregister_netdev (znet_dev);
931 kfree (znet->rx_start);
932 kfree (znet->tx_start);
933 free_netdev (znet_dev);
937 module_init (znet_probe);
938 module_exit (znet_cleanup);