[netdrvr] Trim trailing whitespace for several drivers
[linux-2.6.git] / drivers / net / znet.c
1 /* znet.c: An Zenith Z-Note ethernet driver for linux. */
2
3 /*
4         Written by Donald Becker.
5
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.
10
11         Thanks to Mike Hollick for alpha testing and suggestions.
12
13   References:
14            The Crynwr packet driver.
15
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
21         related i82586.
22
23                                         Theory of Operation
24
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.
27
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.)
37
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
43         to 8K.)
44
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.
53
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.
61  */
62
63 /* 10/2002
64
65    o Resurected for Linux 2.5+ by Marc Zyngier <maz@wild-wind.fr.eu.org> :
66
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.
76
77    Some code was taken from wavelan_cs.
78
79    Tested on a vintage Zenith Z-Note 433Lnp+. Probably broken on
80    anything else. Testers (and detailed bug reports) are welcome :-).
81
82    o TODO :
83
84    - Properly handle multicast
85    - Understand why some traffic patterns add a 1s latency...
86  */
87
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>
101
102 #include <asm/system.h>
103 #include <asm/io.h>
104 #include <asm/dma.h>
105
106 /* This include could be elsewhere, since it is not wireless specific */
107 #include "wireless/i82593.h"
108
109 static char version[] __initdata = "znet.c:v1.02 9/23/94 becker@scyld.com\n";
110
111 #ifndef ZNET_DEBUG
112 #define ZNET_DEBUG 1
113 #endif
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");
118
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 */
126
127 #define TX_TIMEOUT      10
128
129 struct znet_private {
130         int rx_dma, tx_dma;
131         spinlock_t lock;
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. */
138 };
139
140 /* Only one can be built-in;-> */
141 static struct net_device *znet_dev;
142
143 struct netidblk {
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. */
148         char product[8];
149         char irq1, irq2;                /* Interrupts, only one is currently used.      */
150         char dma1, dma2;
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 */
155         char pad;
156 };
157
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);
166
167 /* Request needed resources */
168 static int znet_request_resources (struct net_device *dev)
169 {
170         struct znet_private *znet = dev->priv;
171         unsigned long flags;
172
173         if (request_irq (dev->irq, &znet_interrupt, 0, "ZNet", dev))
174                 goto failed;
175         if (request_dma (znet->rx_dma, "ZNet rx"))
176                 goto free_irq;
177         if (request_dma (znet->tx_dma, "ZNet tx"))
178                 goto free_rx_dma;
179         if (!request_region (znet->sia_base, znet->sia_size, "ZNet SIA"))
180                 goto free_tx_dma;
181         if (!request_region (dev->base_addr, znet->io_size, "ZNet I/O"))
182                 goto free_sia;
183
184         return 0;                               /* Happy ! */
185
186  free_sia:
187         release_region (znet->sia_base, znet->sia_size);
188  free_tx_dma:
189         flags = claim_dma_lock();
190         free_dma (znet->tx_dma);
191         release_dma_lock (flags);
192  free_rx_dma:
193         flags = claim_dma_lock();
194         free_dma (znet->rx_dma);
195         release_dma_lock (flags);
196  free_irq:
197         free_irq (dev->irq, dev);
198  failed:
199         return -1;
200 }
201
202 static void znet_release_resources (struct net_device *dev)
203 {
204         struct znet_private *znet = dev->priv;
205         unsigned long flags;
206
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);
214 }
215
216 /* Keep the magical SIA stuff in a single function... */
217 static void znet_transceiver_power (struct net_device *dev, int on)
218 {
219         struct znet_private *znet = dev->priv;
220         unsigned char v;
221
222         /* Turn on/off the 82501 SIA, using zenith-specific magic. */
223         /* Select LAN control register */
224         outb(0x10, znet->sia_base);
225
226         if (on)
227                 v = inb(znet->sia_base + 1) | 0x84;
228         else
229                 v = inb(znet->sia_base + 1) & ~0x84;
230
231         outb(v, znet->sia_base+1); /* Turn on/off LAN power (bit 2). */
232 }
233
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)
237 {
238         struct znet_private *znet = dev->priv;
239         short ioaddr = dev->base_addr;
240         struct i82593_conf_block *cfblk = &znet->i593_init;
241
242         memset(cfblk, 0x00, sizeof(struct i82593_conf_block));
243
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. */
249
250         /* maz : Rewritten to take advantage of the wanvelan includes.
251            At least we have names, not just blind values */
252
253         /* Byte 0 */
254         cfblk->fifo_limit = 10; /* = 16 B rx and 80 B tx fifo thresholds */
255         cfblk->forgnesi = 0;    /* 0=82C501, 1=AMD7992B compatibility */
256         cfblk->fifo_32 = 1;
257         cfblk->d6mod = 0;       /* Run in i82593 advanced mode */
258         cfblk->throttle_enb = 1;
259
260         /* Byte 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 */
264
265         /* Byte 2 */
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 */
270
271         /* Byte 3 */
272         cfblk->lin_prio = 0;    /* Default priorities & backoff methods. */
273         cfblk->tbofstop = 0;
274         cfblk->exp_prio = 0;
275         cfblk->bof_met = 0;
276
277         /* Byte 4 */
278         cfblk->ifrm_spc = 6;    /* 96 bit times interframe spacing */
279
280         /* Byte 5 */
281         cfblk->slottim_low = 0; /* 512 bit times slot time (low) */
282
283         /* Byte 6 */
284         cfblk->slottim_hi = 2;  /* 512 bit times slot time (high) */
285         cfblk->max_retr = 15;   /* 15 collisions retries */
286
287         /* Byte 7 */
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 */
294
295         /* Byte 8 */
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 */
299
300         /* Byte 9 */
301         cfblk->min_fr_len = ETH_ZLEN >> 2; /* Minimum frame length */
302
303         /* Byte A */
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 */
312
313         /* Byte B */
314         cfblk->fdx = 0;         /* Disable full duplex operation */
315
316         /* Byte C */
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 ?! */
320
321         /* Byte D */
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 */
328
329         /* Byte E */
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 */
338
339         /* Byte F */
340         cfblk->rbuf_size = RX_BUF_SIZE >> 12; /* Set receive buffer size */
341         cfblk->rcvstop = 1;     /* Enable Receive Stop Register */
342
343         if (znet_debug > 2) {
344                 int i;
345                 unsigned char *c;
346
347                 for (i = 0, c = (char *) cfblk; i < sizeof (*cfblk); i++)
348                         printk ("%02X ", c[i]);
349                 printk ("\n");
350         }
351
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);
356
357         /* XXX FIXME maz : Add multicast addresses here, so having a
358          * multicast address configured isn't equal to IFF_ALLMULTI */
359 }
360
361 /* The Z-Note probe is pretty easy.  The NETIDBLK exists in the safe-to-probe
362    BIOS area.  We just scan for the signature, and pull the vital parameters
363    out of the structure. */
364
365 static int __init znet_probe (void)
366 {
367         int i;
368         struct netidblk *netinfo;
369         struct znet_private *znet;
370         struct net_device *dev;
371         char *p;
372         int err = -ENOMEM;
373         DECLARE_MAC_BUF(mac);
374
375         /* This code scans the region 0xf0000 to 0xfffff for a "NETIDBLK". */
376         for(p = (char *)phys_to_virt(0xf0000); p < (char *)phys_to_virt(0x100000); p++)
377                 if (*p == 'N'  &&  strncmp(p, "NETIDBLK", 8) == 0)
378                         break;
379
380         if (p >= (char *)phys_to_virt(0x100000)) {
381                 if (znet_debug > 1)
382                         printk(KERN_INFO "No Z-Note ethernet adaptor found.\n");
383                 return -ENODEV;
384         }
385
386         dev = alloc_etherdev(sizeof(struct znet_private));
387         if (!dev)
388                 return -ENOMEM;
389
390         znet = dev->priv;
391
392         netinfo = (struct netidblk *)p;
393         dev->base_addr = netinfo->iobase1;
394         dev->irq = netinfo->irq1;
395
396         /* The station address is in the "netidblk" at 0x0f0000. */
397         for (i = 0; i < 6; i++)
398                 dev->dev_addr[i] = netinfo->netid[i];
399
400         printk(KERN_INFO "%s: ZNET at %#3lx, %s"
401                ", using IRQ %d DMA %d and %d.\n",
402                dev->name, dev->base_addr, print_mac(mac, dev->dev_addr),
403                dev->irq, netinfo->dma1, netinfo->dma2);
404
405         if (znet_debug > 1) {
406                 printk(KERN_INFO "%s: vendor '%16.16s' IRQ1 %d IRQ2 %d DMA1 %d DMA2 %d.\n",
407                        dev->name, netinfo->vendor,
408                        netinfo->irq1, netinfo->irq2,
409                        netinfo->dma1, netinfo->dma2);
410                 printk(KERN_INFO "%s: iobase1 %#x size %d iobase2 %#x size %d net type %2.2x.\n",
411                        dev->name, netinfo->iobase1, netinfo->iosize1,
412                        netinfo->iobase2, netinfo->iosize2, netinfo->nettype);
413         }
414
415         if (znet_debug > 0)
416                 printk(KERN_INFO "%s", version);
417
418         znet->rx_dma = netinfo->dma1;
419         znet->tx_dma = netinfo->dma2;
420         spin_lock_init(&znet->lock);
421         znet->sia_base = 0xe6;  /* Magic address for the 82501 SIA */
422         znet->sia_size = 2;
423         /* maz: Despite the '593 being advertised above as using a
424          * single 8bits I/O port, this driver does many 16bits
425          * access. So set io_size accordingly */
426         znet->io_size  = 2;
427
428         if (!(znet->rx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
429                 goto free_dev;
430         if (!(znet->tx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
431                 goto free_rx;
432
433         if (!dma_page_eq (znet->rx_start, znet->rx_start + (RX_BUF_SIZE/2-1)) ||
434             !dma_page_eq (znet->tx_start, znet->tx_start + (TX_BUF_SIZE/2-1))) {
435                 printk (KERN_WARNING "tx/rx crossing DMA frontiers, giving up\n");
436                 goto free_tx;
437         }
438
439         znet->rx_end = znet->rx_start + RX_BUF_SIZE/2;
440         znet->tx_buf_len = TX_BUF_SIZE/2;
441         znet->tx_end = znet->tx_start + znet->tx_buf_len;
442
443         /* The ZNET-specific entries in the device structure. */
444         dev->open = &znet_open;
445         dev->hard_start_xmit = &znet_send_packet;
446         dev->stop = &znet_close;
447         dev->set_multicast_list = &znet_set_multicast_list;
448         dev->tx_timeout = znet_tx_timeout;
449         dev->watchdog_timeo = TX_TIMEOUT;
450         err = register_netdev(dev);
451         if (err)
452                 goto free_tx;
453         znet_dev = dev;
454         return 0;
455
456  free_tx:
457         kfree(znet->tx_start);
458  free_rx:
459         kfree(znet->rx_start);
460  free_dev:
461         free_netdev(dev);
462         return err;
463 }
464
465
466 static int znet_open(struct net_device *dev)
467 {
468         int ioaddr = dev->base_addr;
469
470         if (znet_debug > 2)
471                 printk(KERN_DEBUG "%s: znet_open() called.\n", dev->name);
472
473         /* These should never fail.  You can't add devices to a sealed box! */
474         if (znet_request_resources (dev)) {
475                 printk(KERN_WARNING "%s: Not opened -- resource busy?!?\n", dev->name);
476                 return -EBUSY;
477         }
478
479         znet_transceiver_power (dev, 1);
480
481         /* According to the Crynwr driver we should wait 50 msec. for the
482            LAN clock to stabilize.  My experiments indicates that the '593 can
483            be initialized immediately.  The delay is probably needed for the
484            DC-to-DC converter to come up to full voltage, and for the oscillator
485            to be spot-on at 20Mhz before transmitting.
486            Until this proves to be a problem we rely on the higher layers for the
487            delay and save allocating a timer entry. */
488
489         /* maz : Well, I'm getting every time the following message
490          * without the delay on a 486@33. This machine is much too
491          * fast... :-) So maybe the Crynwr driver wasn't wrong after
492          * all, even if the message is completly harmless on my
493          * setup. */
494         mdelay (50);
495
496         /* This follows the packet driver's lead, and checks for success. */
497         if (inb(ioaddr) != 0x10 && inb(ioaddr) != 0x00)
498                 printk(KERN_WARNING "%s: Problem turning on the transceiver power.\n",
499                        dev->name);
500
501         hardware_init(dev);
502         netif_start_queue (dev);
503
504         return 0;
505 }
506
507
508 static void znet_tx_timeout (struct net_device *dev)
509 {
510         int ioaddr = dev->base_addr;
511         ushort event, tx_status, rx_offset, state;
512
513         outb (CR0_STATUS_0, ioaddr);
514         event = inb (ioaddr);
515         outb (CR0_STATUS_1, ioaddr);
516         tx_status = inw (ioaddr);
517         outb (CR0_STATUS_2, ioaddr);
518         rx_offset = inw (ioaddr);
519         outb (CR0_STATUS_3, ioaddr);
520         state = inb (ioaddr);
521         printk (KERN_WARNING "%s: transmit timed out, status %02x %04x %04x %02x,"
522          " resetting.\n", dev->name, event, tx_status, rx_offset, state);
523         if (tx_status == TX_LOST_CRS)
524                 printk (KERN_WARNING "%s: Tx carrier error, check transceiver cable.\n",
525                         dev->name);
526         outb (OP0_RESET, ioaddr);
527         hardware_init (dev);
528         netif_wake_queue (dev);
529 }
530
531 static int znet_send_packet(struct sk_buff *skb, struct net_device *dev)
532 {
533         int ioaddr = dev->base_addr;
534         struct znet_private *znet = dev->priv;
535         unsigned long flags;
536         short length = skb->len;
537
538         if (znet_debug > 4)
539                 printk(KERN_DEBUG "%s: ZNet_send_packet.\n", dev->name);
540
541         if (length < ETH_ZLEN) {
542                 if (skb_padto(skb, ETH_ZLEN))
543                         return 0;
544                 length = ETH_ZLEN;
545         }
546
547         netif_stop_queue (dev);
548
549         /* Check that the part hasn't reset itself, probably from suspend. */
550         outb(CR0_STATUS_0, ioaddr);
551         if (inw(ioaddr) == 0x0010 &&
552             inw(ioaddr) == 0x0000 &&
553             inw(ioaddr) == 0x0010) {
554                 if (znet_debug > 1)
555                         printk (KERN_WARNING "%s : waking up\n", dev->name);
556                 hardware_init(dev);
557                 znet_transceiver_power (dev, 1);
558         }
559
560         if (1) {
561                 unsigned char *buf = (void *)skb->data;
562                 ushort *tx_link = znet->tx_cur - 1;
563                 ushort rnd_len = (length + 1)>>1;
564
565                 dev->stats.tx_bytes+=length;
566
567                 if (znet->tx_cur >= znet->tx_end)
568                   znet->tx_cur = znet->tx_start;
569                 *znet->tx_cur++ = length;
570                 if (znet->tx_cur + rnd_len + 1 > znet->tx_end) {
571                         int semi_cnt = (znet->tx_end - znet->tx_cur)<<1; /* Cvrt to byte cnt. */
572                         memcpy(znet->tx_cur, buf, semi_cnt);
573                         rnd_len -= semi_cnt>>1;
574                         memcpy(znet->tx_start, buf + semi_cnt, length - semi_cnt);
575                         znet->tx_cur = znet->tx_start + rnd_len;
576                 } else {
577                         memcpy(znet->tx_cur, buf, skb->len);
578                         znet->tx_cur += rnd_len;
579                 }
580                 *znet->tx_cur++ = 0;
581
582                 spin_lock_irqsave(&znet->lock, flags);
583                 {
584                         *tx_link = OP0_TRANSMIT | CR0_CHNL;
585                         /* Is this always safe to do? */
586                         outb(OP0_TRANSMIT | CR0_CHNL, ioaddr);
587                 }
588                 spin_unlock_irqrestore (&znet->lock, flags);
589
590                 dev->trans_start = jiffies;
591                 netif_start_queue (dev);
592
593                 if (znet_debug > 4)
594                   printk(KERN_DEBUG "%s: Transmitter queued, length %d.\n", dev->name, length);
595         }
596         dev_kfree_skb(skb);
597         return 0;
598 }
599
600 /* The ZNET interrupt handler. */
601 static irqreturn_t znet_interrupt(int irq, void *dev_id)
602 {
603         struct net_device *dev = dev_id;
604         struct znet_private *znet = dev->priv;
605         int ioaddr;
606         int boguscnt = 20;
607         int handled = 0;
608
609         spin_lock (&znet->lock);
610
611         ioaddr = dev->base_addr;
612
613         outb(CR0_STATUS_0, ioaddr);
614         do {
615                 ushort status = inb(ioaddr);
616                 if (znet_debug > 5) {
617                         ushort result, rx_ptr, running;
618                         outb(CR0_STATUS_1, ioaddr);
619                         result = inw(ioaddr);
620                         outb(CR0_STATUS_2, ioaddr);
621                         rx_ptr = inw(ioaddr);
622                         outb(CR0_STATUS_3, ioaddr);
623                         running = inb(ioaddr);
624                         printk(KERN_DEBUG "%s: interrupt, status %02x, %04x %04x %02x serial %d.\n",
625                                  dev->name, status, result, rx_ptr, running, boguscnt);
626                 }
627                 if ((status & SR0_INTERRUPT) == 0)
628                         break;
629
630                 handled = 1;
631
632                 if ((status & SR0_EVENT_MASK) == SR0_TRANSMIT_DONE ||
633                     (status & SR0_EVENT_MASK) == SR0_RETRANSMIT_DONE ||
634                     (status & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE) {
635                         int tx_status;
636                         outb(CR0_STATUS_1, ioaddr);
637                         tx_status = inw(ioaddr);
638                         /* It's undocumented, but tx_status seems to match the i82586. */
639                         if (tx_status & TX_OK) {
640                                 dev->stats.tx_packets++;
641                                 dev->stats.collisions += tx_status & TX_NCOL_MASK;
642                         } else {
643                                 if (tx_status & (TX_LOST_CTS | TX_LOST_CRS))
644                                         dev->stats.tx_carrier_errors++;
645                                 if (tx_status & TX_UND_RUN)
646                                         dev->stats.tx_fifo_errors++;
647                                 if (!(tx_status & TX_HRT_BEAT))
648                                         dev->stats.tx_heartbeat_errors++;
649                                 if (tx_status & TX_MAX_COL)
650                                         dev->stats.tx_aborted_errors++;
651                                 /* ...and the catch-all. */
652                                 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))
653                                         dev->stats.tx_errors++;
654
655                                 /* Transceiver may be stuck if cable
656                                  * was removed while emiting a
657                                  * packet. Flip it off, then on to
658                                  * reset it. This is very empirical,
659                                  * but it seems to work. */
660
661                                 znet_transceiver_power (dev, 0);
662                                 znet_transceiver_power (dev, 1);
663                         }
664                         netif_wake_queue (dev);
665                 }
666
667                 if ((status & SR0_RECEPTION) ||
668                     (status & SR0_EVENT_MASK) == SR0_STOP_REG_HIT) {
669                         znet_rx(dev);
670                 }
671                 /* Clear the interrupts we've handled. */
672                 outb(CR0_INT_ACK, ioaddr);
673         } while (boguscnt--);
674
675         spin_unlock (&znet->lock);
676
677         return IRQ_RETVAL(handled);
678 }
679
680 static void znet_rx(struct net_device *dev)
681 {
682         struct znet_private *znet = dev->priv;
683         int ioaddr = dev->base_addr;
684         int boguscount = 1;
685         short next_frame_end_offset = 0;                /* Offset of next frame start. */
686         short *cur_frame_end;
687         short cur_frame_end_offset;
688
689         outb(CR0_STATUS_2, ioaddr);
690         cur_frame_end_offset = inw(ioaddr);
691
692         if (cur_frame_end_offset == znet->rx_cur - znet->rx_start) {
693                 printk(KERN_WARNING "%s: Interrupted, but nothing to receive, offset %03x.\n",
694                            dev->name, cur_frame_end_offset);
695                 return;
696         }
697
698         /* Use same method as the Crynwr driver: construct a forward list in
699            the same area of the backwards links we now have.  This allows us to
700            pass packets to the upper layers in the order they were received --
701            important for fast-path sequential operations. */
702          while (znet->rx_start + cur_frame_end_offset != znet->rx_cur
703                         && ++boguscount < 5) {
704                 unsigned short hi_cnt, lo_cnt, hi_status, lo_status;
705                 int count, status;
706
707                 if (cur_frame_end_offset < 4) {
708                         /* Oh no, we have a special case: the frame trailer wraps around
709                            the end of the ring buffer.  We've saved space at the end of
710                            the ring buffer for just this problem. */
711                         memcpy(znet->rx_end, znet->rx_start, 8);
712                         cur_frame_end_offset += (RX_BUF_SIZE/2);
713                 }
714                 cur_frame_end = znet->rx_start + cur_frame_end_offset - 4;
715
716                 lo_status = *cur_frame_end++;
717                 hi_status = *cur_frame_end++;
718                 status = ((hi_status & 0xff) << 8) + (lo_status & 0xff);
719                 lo_cnt = *cur_frame_end++;
720                 hi_cnt = *cur_frame_end++;
721                 count = ((hi_cnt & 0xff) << 8) + (lo_cnt & 0xff);
722
723                 if (znet_debug > 5)
724                   printk(KERN_DEBUG "Constructing trailer at location %03x, %04x %04x %04x %04x"
725                                  " count %#x status %04x.\n",
726                                  cur_frame_end_offset<<1, lo_status, hi_status, lo_cnt, hi_cnt,
727                                  count, status);
728                 cur_frame_end[-4] = status;
729                 cur_frame_end[-3] = next_frame_end_offset;
730                 cur_frame_end[-2] = count;
731                 next_frame_end_offset = cur_frame_end_offset;
732                 cur_frame_end_offset -= ((count + 1)>>1) + 3;
733                 if (cur_frame_end_offset < 0)
734                   cur_frame_end_offset += RX_BUF_SIZE/2;
735         };
736
737         /* Now step  forward through the list. */
738         do {
739                 ushort *this_rfp_ptr = znet->rx_start + next_frame_end_offset;
740                 int status = this_rfp_ptr[-4];
741                 int pkt_len = this_rfp_ptr[-2];
742
743                 if (znet_debug > 5)
744                   printk(KERN_DEBUG "Looking at trailer ending at %04x status %04x length %03x"
745                                  " next %04x.\n", next_frame_end_offset<<1, status, pkt_len,
746                                  this_rfp_ptr[-3]<<1);
747                 /* Once again we must assume that the i82586 docs apply. */
748                 if ( ! (status & RX_RCV_OK)) { /* There was an error. */
749                         dev->stats.rx_errors++;
750                         if (status & RX_CRC_ERR) dev->stats.rx_crc_errors++;
751                         if (status & RX_ALG_ERR) dev->stats.rx_frame_errors++;
752 #if 0
753                         if (status & 0x0200) dev->stats.rx_over_errors++; /* Wrong. */
754                         if (status & 0x0100) dev->stats.rx_fifo_errors++;
755 #else
756                         /* maz : Wild guess... */
757                         if (status & RX_OVRRUN) dev->stats.rx_over_errors++;
758 #endif
759                         if (status & RX_SRT_FRM) dev->stats.rx_length_errors++;
760                 } else if (pkt_len > 1536) {
761                         dev->stats.rx_length_errors++;
762                 } else {
763                         /* Malloc up new buffer. */
764                         struct sk_buff *skb;
765
766                         skb = dev_alloc_skb(pkt_len);
767                         if (skb == NULL) {
768                                 if (znet_debug)
769                                   printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
770                                 dev->stats.rx_dropped++;
771                                 break;
772                         }
773
774                         if (&znet->rx_cur[(pkt_len+1)>>1] > znet->rx_end) {
775                                 int semi_cnt = (znet->rx_end - znet->rx_cur)<<1;
776                                 memcpy(skb_put(skb,semi_cnt), znet->rx_cur, semi_cnt);
777                                 memcpy(skb_put(skb,pkt_len-semi_cnt), znet->rx_start,
778                                            pkt_len - semi_cnt);
779                         } else {
780                                 memcpy(skb_put(skb,pkt_len), znet->rx_cur, pkt_len);
781                                 if (znet_debug > 6) {
782                                         unsigned int *packet = (unsigned int *) skb->data;
783                                         printk(KERN_DEBUG "Packet data is %08x %08x %08x %08x.\n", packet[0],
784                                                    packet[1], packet[2], packet[3]);
785                                 }
786                   }
787                   skb->protocol=eth_type_trans(skb,dev);
788                   netif_rx(skb);
789                   dev->last_rx = jiffies;
790                   dev->stats.rx_packets++;
791                   dev->stats.rx_bytes += pkt_len;
792                 }
793                 znet->rx_cur = this_rfp_ptr;
794                 if (znet->rx_cur >= znet->rx_end)
795                         znet->rx_cur -= RX_BUF_SIZE/2;
796                 update_stop_hit(ioaddr, (znet->rx_cur - znet->rx_start)<<1);
797                 next_frame_end_offset = this_rfp_ptr[-3];
798                 if (next_frame_end_offset == 0)         /* Read all the frames? */
799                         break;                  /* Done for now */
800                 this_rfp_ptr = znet->rx_start + next_frame_end_offset;
801         } while (--boguscount);
802
803         /* If any worth-while packets have been received, dev_rint()
804            has done a mark_bh(INET_BH) for us and will work on them
805            when we get to the bottom-half routine. */
806         return;
807 }
808
809 /* The inverse routine to znet_open(). */
810 static int znet_close(struct net_device *dev)
811 {
812         int ioaddr = dev->base_addr;
813
814         netif_stop_queue (dev);
815
816         outb(OP0_RESET, ioaddr);                        /* CMD0_RESET */
817
818         if (znet_debug > 1)
819                 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
820         /* Turn off transceiver power. */
821         znet_transceiver_power (dev, 0);
822
823         znet_release_resources (dev);
824
825         return 0;
826 }
827
828 static void show_dma(struct net_device *dev)
829 {
830         short ioaddr = dev->base_addr;
831         unsigned char stat = inb (ioaddr);
832         struct znet_private *znet = dev->priv;
833         unsigned long flags;
834         short dma_port = ((znet->tx_dma&3)<<2) + IO_DMA2_BASE;
835         unsigned addr = inb(dma_port);
836         short residue;
837
838         addr |= inb(dma_port) << 8;
839         residue = get_dma_residue(znet->tx_dma);
840
841         if (znet_debug > 1) {
842                 flags=claim_dma_lock();
843                 printk(KERN_DEBUG "Stat:%02x Addr: %04x cnt:%3x\n",
844                        stat, addr<<1, residue);
845                 release_dma_lock(flags);
846         }
847 }
848
849 /* Initialize the hardware.  We have to do this when the board is open()ed
850    or when we come out of suspend mode. */
851 static void hardware_init(struct net_device *dev)
852 {
853         unsigned long flags;
854         short ioaddr = dev->base_addr;
855         struct znet_private *znet = dev->priv;
856
857         znet->rx_cur = znet->rx_start;
858         znet->tx_cur = znet->tx_start;
859
860         /* Reset the chip, and start it up. */
861         outb(OP0_RESET, ioaddr);
862
863         flags=claim_dma_lock();
864         disable_dma(znet->rx_dma);              /* reset by an interrupting task. */
865         clear_dma_ff(znet->rx_dma);
866         set_dma_mode(znet->rx_dma, DMA_RX_MODE);
867         set_dma_addr(znet->rx_dma, (unsigned int) znet->rx_start);
868         set_dma_count(znet->rx_dma, RX_BUF_SIZE);
869         enable_dma(znet->rx_dma);
870         /* Now set up the Tx channel. */
871         disable_dma(znet->tx_dma);
872         clear_dma_ff(znet->tx_dma);
873         set_dma_mode(znet->tx_dma, DMA_TX_MODE);
874         set_dma_addr(znet->tx_dma, (unsigned int) znet->tx_start);
875         set_dma_count(znet->tx_dma, znet->tx_buf_len<<1);
876         enable_dma(znet->tx_dma);
877         release_dma_lock(flags);
878
879         if (znet_debug > 1)
880           printk(KERN_DEBUG "%s: Initializing the i82593, rx buf %p tx buf %p\n",
881                          dev->name, znet->rx_start,znet->tx_start);
882         /* Do an empty configure command, just like the Crynwr driver.  This
883            resets to chip to its default values. */
884         *znet->tx_cur++ = 0;
885         *znet->tx_cur++ = 0;
886         show_dma(dev);
887         outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
888
889         znet_set_multicast_list (dev);
890
891         *znet->tx_cur++ = 6;
892         memcpy(znet->tx_cur, dev->dev_addr, 6);
893         znet->tx_cur += 3;
894         show_dma(dev);
895         outb(OP0_IA_SETUP | CR0_CHNL, ioaddr);
896         show_dma(dev);
897
898         update_stop_hit(ioaddr, 8192);
899         if (znet_debug > 1)  printk(KERN_DEBUG "enabling Rx.\n");
900         outb(OP0_RCV_ENABLE, ioaddr);
901         netif_start_queue (dev);
902 }
903
904 static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset)
905 {
906         outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, ioaddr);
907         if (znet_debug > 5)
908           printk(KERN_DEBUG "Updating stop hit with value %02x.\n",
909                          (rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE);
910         outb((rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE, ioaddr);
911         outb(OP1_SWIT_TO_PORT_0, ioaddr);
912 }
913
914 static __exit void znet_cleanup (void)
915 {
916         if (znet_dev) {
917                 struct znet_private *znet = znet_dev->priv;
918
919                 unregister_netdev (znet_dev);
920                 kfree (znet->rx_start);
921                 kfree (znet->tx_start);
922                 free_netdev (znet_dev);
923         }
924 }
925
926 module_init (znet_probe);
927 module_exit (znet_cleanup);