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 = 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
 202 static 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... */
 217 static 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. */
 236 static 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
 361 static const struct net_device_ops znet_netdev_ops = {
 362         .ndo_open               = znet_open,
 363         .ndo_stop               = znet_close,
 364         .ndo_start_xmit         = znet_send_packet,
 365         .ndo_set_multicast_list = znet_set_multicast_list,
 366         .ndo_tx_timeout         = znet_tx_timeout,
 367         .ndo_change_mtu         = eth_change_mtu,
 368         .ndo_set_mac_address    = eth_mac_addr,
 369         .ndo_validate_addr      = eth_validate_addr,
 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
 376 static 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
 472 static 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
 514 static 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
 537 static 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 NETDEV_TX_OK;
 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 NETDEV_TX_OK;
 604 }
 605
 606 /* The ZNET interrupt handler. */
 607 static 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
 686 static 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(). */
 815 static 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
 833 static 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. */
 856 static 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
 909 static 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
 919 static __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
 931 module_init (znet_probe);
 932 module_exit (znet_cleanup);