Root/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
109static 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
114static unsigned int znet_debug = ZNET_DEBUG;
115module_param (znet_debug, int, 0);
116MODULE_PARM_DESC (znet_debug, "ZNet debug level");
117MODULE_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
129struct 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;-> */
141static struct net_device *znet_dev;
142
143struct 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
158static int znet_open(struct net_device *dev);
159static int znet_send_packet(struct sk_buff *skb, struct net_device *dev);
160static irqreturn_t znet_interrupt(int irq, void *dev_id);
161static void znet_rx(struct net_device *dev);
162static int znet_close(struct net_device *dev);
163static void hardware_init(struct net_device *dev);
164static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset);
165static void znet_tx_timeout (struct net_device *dev);
166
167/* Request needed resources */
168static int znet_request_resources (struct net_device *dev)
169{
170    struct znet_private *znet = netdev_priv(dev);
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
202static void znet_release_resources (struct net_device *dev)
203{
204    struct znet_private *znet = netdev_priv(dev);
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... */
217static void znet_transceiver_power (struct net_device *dev, int on)
218{
219    struct znet_private *znet = netdev_priv(dev);
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. */
236static void znet_set_multicast_list (struct net_device *dev)
237{
238    struct znet_private *znet = netdev_priv(dev);
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
361static 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,
370};
371
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. */
375
376static int __init znet_probe (void)
377{
378    int i;
379    struct netidblk *netinfo;
380    struct znet_private *znet;
381    struct net_device *dev;
382    char *p;
383    int err = -ENOMEM;
384
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)
388            break;
389
390    if (p >= (char *)phys_to_virt(0x100000)) {
391        if (znet_debug > 1)
392            printk(KERN_INFO "No Z-Note ethernet adaptor found.\n");
393        return -ENODEV;
394    }
395
396    dev = alloc_etherdev(sizeof(struct znet_private));
397    if (!dev)
398        return -ENOMEM;
399
400    znet = netdev_priv(dev);
401
402    netinfo = (struct netidblk *)p;
403    dev->base_addr = netinfo->iobase1;
404    dev->irq = netinfo->irq1;
405
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];
409
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);
414
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);
423    }
424
425    if (znet_debug > 0)
426        printk(KERN_INFO "%s", version);
427
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 */
432    znet->sia_size = 2;
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 */
436    znet->io_size = 2;
437
438    if (!(znet->rx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
439        goto free_dev;
440    if (!(znet->tx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
441        goto free_rx;
442
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");
446        goto free_tx;
447    }
448
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;
452
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);
457    if (err)
458        goto free_tx;
459    znet_dev = dev;
460    return 0;
461
462 free_tx:
463    kfree(znet->tx_start);
464 free_rx:
465    kfree(znet->rx_start);
466 free_dev:
467    free_netdev(dev);
468    return err;
469}
470
471
472static int znet_open(struct net_device *dev)
473{
474    int ioaddr = dev->base_addr;
475
476    if (znet_debug > 2)
477        printk(KERN_DEBUG "%s: znet_open() called.\n", dev->name);
478
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);
482        return -EBUSY;
483    }
484
485    znet_transceiver_power (dev, 1);
486
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. */
494
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
499     * setup. */
500    mdelay (50);
501
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",
505               dev->name);
506
507    hardware_init(dev);
508    netif_start_queue (dev);
509
510    return 0;
511}
512
513
514static void znet_tx_timeout (struct net_device *dev)
515{
516    int ioaddr = dev->base_addr;
517    ushort event, tx_status, rx_offset, state;
518
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",
531            dev->name);
532    outb (OP0_RESET, ioaddr);
533    hardware_init (dev);
534    netif_wake_queue (dev);
535}
536
537static int znet_send_packet(struct sk_buff *skb, struct net_device *dev)
538{
539    int ioaddr = dev->base_addr;
540    struct znet_private *znet = netdev_priv(dev);
541    unsigned long flags;
542    short length = skb->len;
543
544    if (znet_debug > 4)
545        printk(KERN_DEBUG "%s: ZNet_send_packet.\n", dev->name);
546
547    if (length < ETH_ZLEN) {
548        if (skb_padto(skb, ETH_ZLEN))
549            return 0;
550        length = ETH_ZLEN;
551    }
552
553    netif_stop_queue (dev);
554
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) {
560        if (znet_debug > 1)
561            printk (KERN_WARNING "%s : waking up\n", dev->name);
562        hardware_init(dev);
563        znet_transceiver_power (dev, 1);
564    }
565
566    if (1) {
567        unsigned char *buf = (void *)skb->data;
568        ushort *tx_link = znet->tx_cur - 1;
569        ushort rnd_len = (length + 1)>>1;
570
571        dev->stats.tx_bytes+=length;
572
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;
582        } else {
583            memcpy(znet->tx_cur, buf, skb->len);
584            znet->tx_cur += rnd_len;
585        }
586        *znet->tx_cur++ = 0;
587
588        spin_lock_irqsave(&znet->lock, flags);
589        {
590            *tx_link = OP0_TRANSMIT | CR0_CHNL;
591            /* Is this always safe to do? */
592            outb(OP0_TRANSMIT | CR0_CHNL, ioaddr);
593        }
594        spin_unlock_irqrestore (&znet->lock, flags);
595
596        dev->trans_start = jiffies;
597        netif_start_queue (dev);
598
599        if (znet_debug > 4)
600          printk(KERN_DEBUG "%s: Transmitter queued, length %d.\n", dev->name, length);
601    }
602    dev_kfree_skb(skb);
603    return 0;
604}
605
606/* The ZNET interrupt handler. */
607static irqreturn_t znet_interrupt(int irq, void *dev_id)
608{
609    struct net_device *dev = dev_id;
610    struct znet_private *znet = netdev_priv(dev);
611    int ioaddr;
612    int boguscnt = 20;
613    int handled = 0;
614
615    spin_lock (&znet->lock);
616
617    ioaddr = dev->base_addr;
618
619    outb(CR0_STATUS_0, ioaddr);
620    do {
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);
632        }
633        if ((status & SR0_INTERRUPT) == 0)
634            break;
635
636        handled = 1;
637
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) {
641            int tx_status;
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;
648            } else {
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++;
660
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. */
666
667                znet_transceiver_power (dev, 0);
668                znet_transceiver_power (dev, 1);
669            }
670            netif_wake_queue (dev);
671        }
672
673        if ((status & SR0_RECEPTION) ||
674            (status & SR0_EVENT_MASK) == SR0_STOP_REG_HIT) {
675            znet_rx(dev);
676        }
677        /* Clear the interrupts we've handled. */
678        outb(CR0_INT_ACK, ioaddr);
679    } while (boguscnt--);
680
681    spin_unlock (&znet->lock);
682
683    return IRQ_RETVAL(handled);
684}
685
686static void znet_rx(struct net_device *dev)
687{
688    struct znet_private *znet = netdev_priv(dev);
689    int ioaddr = dev->base_addr;
690    int boguscount = 1;
691    short next_frame_end_offset = 0; /* Offset of next frame start. */
692    short *cur_frame_end;
693    short cur_frame_end_offset;
694
695    outb(CR0_STATUS_2, ioaddr);
696    cur_frame_end_offset = inw(ioaddr);
697
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);
701        return;
702    }
703
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;
711        int count, status;
712
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);
719        }
720        cur_frame_end = znet->rx_start + cur_frame_end_offset - 4;
721
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);
728
729        if (znet_debug > 5)
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,
733                 count, status);
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;
741    };
742
743    /* Now step forward through the list. */
744    do {
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];
748
749        if (znet_debug > 5)
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++;
758#if 0
759            if (status & 0x0200) dev->stats.rx_over_errors++; /* Wrong. */
760            if (status & 0x0100) dev->stats.rx_fifo_errors++;
761#else
762            /* maz : Wild guess... */
763            if (status & RX_OVRRUN) dev->stats.rx_over_errors++;
764#endif
765            if (status & RX_SRT_FRM) dev->stats.rx_length_errors++;
766        } else if (pkt_len > 1536) {
767            dev->stats.rx_length_errors++;
768        } else {
769            /* Malloc up new buffer. */
770            struct sk_buff *skb;
771
772            skb = dev_alloc_skb(pkt_len);
773            if (skb == NULL) {
774                if (znet_debug)
775                  printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
776                dev->stats.rx_dropped++;
777                break;
778            }
779
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,
784                       pkt_len - semi_cnt);
785            } else {
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]);
791                }
792          }
793          skb->protocol=eth_type_trans(skb,dev);
794          netif_rx(skb);
795          dev->stats.rx_packets++;
796          dev->stats.rx_bytes += pkt_len;
797        }
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);
807
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. */
811    return;
812}
813
814/* The inverse routine to znet_open(). */
815static int znet_close(struct net_device *dev)
816{
817    int ioaddr = dev->base_addr;
818
819    netif_stop_queue (dev);
820
821    outb(OP0_RESET, ioaddr); /* CMD0_RESET */
822
823    if (znet_debug > 1)
824        printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
825    /* Turn off transceiver power. */
826    znet_transceiver_power (dev, 0);
827
828    znet_release_resources (dev);
829
830    return 0;
831}
832
833static void show_dma(struct net_device *dev)
834{
835    short ioaddr = dev->base_addr;
836    unsigned char stat = inb (ioaddr);
837    struct znet_private *znet = netdev_priv(dev);
838    unsigned long flags;
839    short dma_port = ((znet->tx_dma&3)<<2) + IO_DMA2_BASE;
840    unsigned addr = inb(dma_port);
841    short residue;
842
843    addr |= inb(dma_port) << 8;
844    residue = get_dma_residue(znet->tx_dma);
845
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);
851    }
852}
853
854/* Initialize the hardware. We have to do this when the board is open()ed
855   or when we come out of suspend mode. */
856static void hardware_init(struct net_device *dev)
857{
858    unsigned long flags;
859    short ioaddr = dev->base_addr;
860    struct znet_private *znet = netdev_priv(dev);
861
862    znet->rx_cur = znet->rx_start;
863    znet->tx_cur = znet->tx_start;
864
865    /* Reset the chip, and start it up. */
866    outb(OP0_RESET, ioaddr);
867
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);
883
884    if (znet_debug > 1)
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. */
889    *znet->tx_cur++ = 0;
890    *znet->tx_cur++ = 0;
891    show_dma(dev);
892    outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
893
894    znet_set_multicast_list (dev);
895
896    *znet->tx_cur++ = 6;
897    memcpy(znet->tx_cur, dev->dev_addr, 6);
898    znet->tx_cur += 3;
899    show_dma(dev);
900    outb(OP0_IA_SETUP | CR0_CHNL, ioaddr);
901    show_dma(dev);
902
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);
907}
908
909static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset)
910{
911    outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, ioaddr);
912    if (znet_debug > 5)
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);
917}
918
919static __exit void znet_cleanup (void)
920{
921    if (znet_dev) {
922        struct znet_private *znet = netdev_priv(znet_dev);
923
924        unregister_netdev (znet_dev);
925        kfree (znet->rx_start);
926        kfree (znet->tx_start);
927        free_netdev (znet_dev);
928    }
929}
930
931module_init (znet_probe);
932module_exit (znet_cleanup);
933

Archive Download this file

Branches:
ben-wpan
ben-wpan-stefan
javiroman/ks7010
jz-2.6.34
jz-2.6.34-rc5
jz-2.6.34-rc6
jz-2.6.34-rc7
jz-2.6.35
jz-2.6.36
jz-2.6.37
jz-2.6.38
jz-2.6.39
jz-3.0
jz-3.1
jz-3.2
jz-3.3
jz-3.4
jz47xx
jz47xx-2.6.38
master
xiangfu/openwrt/v3.0.0
xiangfu/openwrt/v3.2.1

Tags:
od-2011-09-04
od-2011-09-18
v2.6.34-rc5
v2.6.34-rc6
v2.6.34-rc7



interactive