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 #include <linux/i82593.h>
 107
 108 static char version[] __initdata = "znet.c:v1.02 9/23/94 becker@scyld.com\n";
 109
 110 #ifndef ZNET_DEBUG
 111 #define ZNET_DEBUG 1
 112 #endif
 113 static unsigned int znet_debug = ZNET_DEBUG;
 114 module_param (znet_debug, int, 0);
 115 MODULE_PARM_DESC (znet_debug, "ZNet debug level");
 116 MODULE_LICENSE("GPL");
 117
 118 /* The DMA modes we need aren't in <dma.h>. */
 119 #define DMA_RX_MODE             0x14    /* Auto init, I/O to mem, ++, demand. */
 120 #define DMA_TX_MODE             0x18    /* Auto init, Mem to I/O, ++, demand. */
 121 #define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
 122 #define RX_BUF_SIZE 8192
 123 #define TX_BUF_SIZE 8192
 124 #define DMA_BUF_SIZE (RX_BUF_SIZE + 16) /* 8k + 16 bytes for trailers */
 125
 126 #define TX_TIMEOUT      10
 127
 128 struct znet_private {
 129         int rx_dma, tx_dma;
 130         spinlock_t lock;
 131         short sia_base, sia_size, io_size;
 132         struct i82593_conf_block i593_init;
 133         /* The starting, current, and end pointers for the packet buffers. */
 134         ushort *rx_start, *rx_cur, *rx_end;
 135         ushort *tx_start, *tx_cur, *tx_end;
 136         ushort tx_buf_len;                      /* Tx buffer length, in words. */
 137 };
 138
 139 /* Only one can be built-in;-> */
 140 static struct net_device *znet_dev;
 141
 142 struct netidblk {
 143         char magic[8];          /* The magic number (string) "NETIDBLK" */
 144         unsigned char netid[8]; /* The physical station address */
 145         char nettype, globalopt;
 146         char vendor[8];         /* The machine vendor and product name. */
 147         char product[8];
 148         char irq1, irq2;                /* Interrupts, only one is currently used.      */
 149         char dma1, dma2;
 150         short dma_mem_misc[8];          /* DMA buffer locations (unused in Linux). */
 151         short iobase1, iosize1;
 152         short iobase2, iosize2;         /* Second iobase unused. */
 153         char driver_options;                    /* Misc. bits */
 154         char pad;
 155 };
 156
 157 static int      znet_open(struct net_device *dev);
 158 static netdev_tx_t znet_send_packet(struct sk_buff *skb,
 159                                     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
 172         if (request_irq (dev->irq, znet_interrupt, 0, "ZNet", dev))
 173                 goto failed;
 174         if (request_dma (znet->rx_dma, "ZNet rx"))
 175                 goto free_irq;
 176         if (request_dma (znet->tx_dma, "ZNet tx"))
 177                 goto free_rx_dma;
 178         if (!request_region (znet->sia_base, znet->sia_size, "ZNet SIA"))
 179                 goto free_tx_dma;
 180         if (!request_region (dev->base_addr, znet->io_size, "ZNet I/O"))
 181                 goto free_sia;
 182
 183         return 0;                               /* Happy ! */
 184
 185  free_sia:
 186         release_region (znet->sia_base, znet->sia_size);
 187  free_tx_dma:
 188         free_dma (znet->tx_dma);
 189  free_rx_dma:
 190         free_dma (znet->rx_dma);
 191  free_irq:
 192         free_irq (dev->irq, dev);
 193  failed:
 194         return -1;
 195 }
 196
 197 static void znet_release_resources (struct net_device *dev)
 198 {
 199         struct znet_private *znet = netdev_priv(dev);
 200
 201         release_region (znet->sia_base, znet->sia_size);
 202         release_region (dev->base_addr, znet->io_size);
 203         free_dma (znet->tx_dma);
 204         free_dma (znet->rx_dma);
 205         free_irq (dev->irq, dev);
 206 }
 207
 208 /* Keep the magical SIA stuff in a single function... */
 209 static void znet_transceiver_power (struct net_device *dev, int on)
 210 {
 211         struct znet_private *znet = netdev_priv(dev);
 212         unsigned char v;
 213
 214         /* Turn on/off the 82501 SIA, using zenith-specific magic. */
 215         /* Select LAN control register */
 216         outb(0x10, znet->sia_base);
 217
 218         if (on)
 219                 v = inb(znet->sia_base + 1) | 0x84;
 220         else
 221                 v = inb(znet->sia_base + 1) & ~0x84;
 222
 223         outb(v, znet->sia_base+1); /* Turn on/off LAN power (bit 2). */
 224 }
 225
 226 /* Init the i82593, with current promisc/mcast configuration.
 227    Also used from hardware_init. */
 228 static void znet_set_multicast_list (struct net_device *dev)
 229 {
 230         struct znet_private *znet = netdev_priv(dev);
 231         short ioaddr = dev->base_addr;
 232         struct i82593_conf_block *cfblk = &znet->i593_init;
 233
 234         memset(cfblk, 0x00, sizeof(struct i82593_conf_block));
 235
 236         /* The configuration block.  What an undocumented nightmare.
 237            The first set of values are those suggested (without explanation)
 238            for ethernet in the Intel 82586 databook.  The rest appear to be
 239            completely undocumented, except for cryptic notes in the Crynwr
 240            packet driver.  This driver uses the Crynwr values verbatim. */
 241
 242         /* maz : Rewritten to take advantage of the wanvelan includes.
 243            At least we have names, not just blind values */
 244
 245         /* Byte 0 */
 246         cfblk->fifo_limit = 10; /* = 16 B rx and 80 B tx fifo thresholds */
 247         cfblk->forgnesi = 0;    /* 0=82C501, 1=AMD7992B compatibility */
 248         cfblk->fifo_32 = 1;
 249         cfblk->d6mod = 0;       /* Run in i82593 advanced mode */
 250         cfblk->throttle_enb = 1;
 251
 252         /* Byte 1 */
 253         cfblk->throttle = 8;    /* Continuous w/interrupts, 128-clock DMA. */
 254         cfblk->cntrxint = 0;    /* enable continuous mode receive interrupts */
 255         cfblk->contin = 1;      /* enable continuous mode */
 256
 257         /* Byte 2 */
 258         cfblk->addr_len = ETH_ALEN;
 259         cfblk->acloc = 1;       /* Disable source addr insertion by i82593 */
 260         cfblk->preamb_len = 2;  /* 8 bytes preamble */
 261         cfblk->loopback = 0;    /* Loopback off */
 262
 263         /* Byte 3 */
 264         cfblk->lin_prio = 0;    /* Default priorities & backoff methods. */
 265         cfblk->tbofstop = 0;
 266         cfblk->exp_prio = 0;
 267         cfblk->bof_met = 0;
 268
 269         /* Byte 4 */
 270         cfblk->ifrm_spc = 6;    /* 96 bit times interframe spacing */
 271
 272         /* Byte 5 */
 273         cfblk->slottim_low = 0; /* 512 bit times slot time (low) */
 274
 275         /* Byte 6 */
 276         cfblk->slottim_hi = 2;  /* 512 bit times slot time (high) */
 277         cfblk->max_retr = 15;   /* 15 collisions retries */
 278
 279         /* Byte 7 */
 280         cfblk->prmisc = ((dev->flags & IFF_PROMISC) ? 1 : 0); /* Promiscuous mode */
 281         cfblk->bc_dis = 0;      /* Enable broadcast reception */
 282         cfblk->crs_1 = 0;       /* Don't transmit without carrier sense */
 283         cfblk->nocrc_ins = 0;   /* i82593 generates CRC */
 284         cfblk->crc_1632 = 0;    /* 32-bit Autodin-II CRC */
 285         cfblk->crs_cdt = 0;     /* CD not to be interpreted as CS */
 286
 287         /* Byte 8 */
 288         cfblk->cs_filter = 0;   /* CS is recognized immediately */
 289         cfblk->crs_src = 0;     /* External carrier sense */
 290         cfblk->cd_filter = 0;   /* CD is recognized immediately */
 291
 292         /* Byte 9 */
 293         cfblk->min_fr_len = ETH_ZLEN >> 2; /* Minimum frame length */
 294
 295         /* Byte A */
 296         cfblk->lng_typ = 1;     /* Type/length checks OFF */
 297         cfblk->lng_fld = 1;     /* Disable 802.3 length field check */
 298         cfblk->rxcrc_xf = 1;    /* Don't transfer CRC to memory */
 299         cfblk->artx = 1;        /* Disable automatic retransmission */
 300         cfblk->sarec = 1;       /* Disable source addr trig of CD */
 301         cfblk->tx_jabber = 0;   /* Disable jabber jam sequence */
 302         cfblk->hash_1 = 1;      /* Use bits 0-5 in mc address hash */
 303         cfblk->lbpkpol = 0;     /* Loopback pin active high */
 304
 305         /* Byte B */
 306         cfblk->fdx = 0;         /* Disable full duplex operation */
 307
 308         /* Byte C */
 309         cfblk->dummy_6 = 0x3f;  /* all ones, Default multicast addresses & backoff. */
 310         cfblk->mult_ia = 0;     /* No multiple individual addresses */
 311         cfblk->dis_bof = 0;     /* Disable the backoff algorithm ?! */
 312
 313         /* Byte D */
 314         cfblk->dummy_1 = 1;     /* set to 1 */
 315         cfblk->tx_ifs_retrig = 3; /* Hmm... Disabled */
 316         cfblk->mc_all = (dev->mc_list || (dev->flags&IFF_ALLMULTI));/* multicast all mode */
 317         cfblk->rcv_mon = 0;     /* Monitor mode disabled */
 318         cfblk->frag_acpt = 0;   /* Do not accept fragments */
 319         cfblk->tstrttrs = 0;    /* No start transmission threshold */
 320
 321         /* Byte E */
 322         cfblk->fretx = 1;       /* FIFO automatic retransmission */
 323         cfblk->runt_eop = 0;    /* drop "runt" packets */
 324         cfblk->hw_sw_pin = 0;   /* ?? */
 325         cfblk->big_endn = 0;    /* Big Endian ? no... */
 326         cfblk->syncrqs = 1;     /* Synchronous DRQ deassertion... */
 327         cfblk->sttlen = 1;      /* 6 byte status registers */
 328         cfblk->rx_eop = 0;      /* Signal EOP on packet reception */
 329         cfblk->tx_eop = 0;      /* Signal EOP on packet transmission */
 330
 331         /* Byte F */
 332         cfblk->rbuf_size = RX_BUF_SIZE >> 12; /* Set receive buffer size */
 333         cfblk->rcvstop = 1;     /* Enable Receive Stop Register */
 334
 335         if (znet_debug > 2) {
 336                 int i;
 337                 unsigned char *c;
 338
 339                 for (i = 0, c = (char *) cfblk; i < sizeof (*cfblk); i++)
 340                         printk ("%02X ", c[i]);
 341                 printk ("\n");
 342         }
 343
 344         *znet->tx_cur++ = sizeof(struct i82593_conf_block);
 345         memcpy(znet->tx_cur, cfblk, sizeof(struct i82593_conf_block));
 346         znet->tx_cur += sizeof(struct i82593_conf_block)/2;
 347         outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
 348
 349         /* XXX FIXME maz : Add multicast addresses here, so having a
 350          * multicast address configured isn't equal to IFF_ALLMULTI */
 351 }
 352
 353 static const struct net_device_ops znet_netdev_ops = {
 354         .ndo_open               = znet_open,
 355         .ndo_stop               = znet_close,
 356         .ndo_start_xmit         = znet_send_packet,
 357         .ndo_set_multicast_list = znet_set_multicast_list,
 358         .ndo_tx_timeout         = znet_tx_timeout,
 359         .ndo_change_mtu         = eth_change_mtu,
 360         .ndo_set_mac_address    = eth_mac_addr,
 361         .ndo_validate_addr      = eth_validate_addr,
 362 };
 363
 364 /* The Z-Note probe is pretty easy.  The NETIDBLK exists in the safe-to-probe
 365    BIOS area.  We just scan for the signature, and pull the vital parameters
 366    out of the structure. */
 367
 368 static int __init znet_probe (void)
 369 {
 370         int i;
 371         struct netidblk *netinfo;
 372         struct znet_private *znet;
 373         struct net_device *dev;
 374         char *p;
 375         int err = -ENOMEM;
 376
 377         /* This code scans the region 0xf0000 to 0xfffff for a "NETIDBLK". */
 378         for(p = (char *)phys_to_virt(0xf0000); p < (char *)phys_to_virt(0x100000); p++)
 379                 if (*p == 'N'  &&  strncmp(p, "NETIDBLK", 8) == 0)
 380                         break;
 381
 382         if (p >= (char *)phys_to_virt(0x100000)) {
 383                 if (znet_debug > 1)
 384                         printk(KERN_INFO "No Z-Note ethernet adaptor found.\n");
 385                 return -ENODEV;
 386         }
 387
 388         dev = alloc_etherdev(sizeof(struct znet_private));
 389         if (!dev)
 390                 return -ENOMEM;
 391
 392         znet = netdev_priv(dev);
 393
 394         netinfo = (struct netidblk *)p;
 395         dev->base_addr = netinfo->iobase1;
 396         dev->irq = netinfo->irq1;
 397
 398         /* The station address is in the "netidblk" at 0x0f0000. */
 399         for (i = 0; i < 6; i++)
 400                 dev->dev_addr[i] = netinfo->netid[i];
 401
 402         printk(KERN_INFO "%s: ZNET at %#3lx, %pM"
 403                ", using IRQ %d DMA %d and %d.\n",
 404                dev->name, dev->base_addr, dev->dev_addr,
 405                dev->irq, netinfo->dma1, netinfo->dma2);
 406
 407         if (znet_debug > 1) {
 408                 printk(KERN_INFO "%s: vendor '%16.16s' IRQ1 %d IRQ2 %d DMA1 %d DMA2 %d.\n",
 409                        dev->name, netinfo->vendor,
 410                        netinfo->irq1, netinfo->irq2,
 411                        netinfo->dma1, netinfo->dma2);
 412                 printk(KERN_INFO "%s: iobase1 %#x size %d iobase2 %#x size %d net type %2.2x.\n",
 413                        dev->name, netinfo->iobase1, netinfo->iosize1,
 414                        netinfo->iobase2, netinfo->iosize2, netinfo->nettype);
 415         }
 416
 417         if (znet_debug > 0)
 418                 printk(KERN_INFO "%s", version);
 419
 420         znet->rx_dma = netinfo->dma1;
 421         znet->tx_dma = netinfo->dma2;
 422         spin_lock_init(&znet->lock);
 423         znet->sia_base = 0xe6;  /* Magic address for the 82501 SIA */
 424         znet->sia_size = 2;
 425         /* maz: Despite the '593 being advertised above as using a
 426          * single 8bits I/O port, this driver does many 16bits
 427          * access. So set io_size accordingly */
 428         znet->io_size  = 2;
 429
 430         if (!(znet->rx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
 431                 goto free_dev;
 432         if (!(znet->tx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
 433                 goto free_rx;
 434
 435         if (!dma_page_eq (znet->rx_start, znet->rx_start + (RX_BUF_SIZE/2-1)) ||
 436             !dma_page_eq (znet->tx_start, znet->tx_start + (TX_BUF_SIZE/2-1))) {
 437                 printk (KERN_WARNING "tx/rx crossing DMA frontiers, giving up\n");
 438                 goto free_tx;
 439         }
 440
 441         znet->rx_end = znet->rx_start + RX_BUF_SIZE/2;
 442         znet->tx_buf_len = TX_BUF_SIZE/2;
 443         znet->tx_end = znet->tx_start + znet->tx_buf_len;
 444
 445         /* The ZNET-specific entries in the device structure. */
 446         dev->netdev_ops = &znet_netdev_ops;
 447         dev->watchdog_timeo = TX_TIMEOUT;
 448         err = register_netdev(dev);
 449         if (err)
 450                 goto free_tx;
 451         znet_dev = dev;
 452         return 0;
 453
 454  free_tx:
 455         kfree(znet->tx_start);
 456  free_rx:
 457         kfree(znet->rx_start);
 458  free_dev:
 459         free_netdev(dev);
 460         return err;
 461 }
 462
 463
 464 static int znet_open(struct net_device *dev)
 465 {
 466         int ioaddr = dev->base_addr;
 467
 468         if (znet_debug > 2)
 469                 printk(KERN_DEBUG "%s: znet_open() called.\n", dev->name);
 470
 471         /* These should never fail.  You can't add devices to a sealed box! */
 472         if (znet_request_resources (dev)) {
 473                 printk(KERN_WARNING "%s: Not opened -- resource busy?!?\n", dev->name);
 474                 return -EBUSY;
 475         }
 476
 477         znet_transceiver_power (dev, 1);
 478
 479         /* According to the Crynwr driver we should wait 50 msec. for the
 480            LAN clock to stabilize.  My experiments indicates that the '593 can
 481            be initialized immediately.  The delay is probably needed for the
 482            DC-to-DC converter to come up to full voltage, and for the oscillator
 483            to be spot-on at 20Mhz before transmitting.
 484            Until this proves to be a problem we rely on the higher layers for the
 485            delay and save allocating a timer entry. */
 486
 487         /* maz : Well, I'm getting every time the following message
 488          * without the delay on a 486@33. This machine is much too
 489          * fast... :-) So maybe the Crynwr driver wasn't wrong after
 490          * all, even if the message is completly harmless on my
 491          * setup. */
 492         mdelay (50);
 493
 494         /* This follows the packet driver's lead, and checks for success. */
 495         if (inb(ioaddr) != 0x10 && inb(ioaddr) != 0x00)
 496                 printk(KERN_WARNING "%s: Problem turning on the transceiver power.\n",
 497                        dev->name);
 498
 499         hardware_init(dev);
 500         netif_start_queue (dev);
 501
 502         return 0;
 503 }
 504
 505
 506 static void znet_tx_timeout (struct net_device *dev)
 507 {
 508         int ioaddr = dev->base_addr;
 509         ushort event, tx_status, rx_offset, state;
 510
 511         outb (CR0_STATUS_0, ioaddr);
 512         event = inb (ioaddr);
 513         outb (CR0_STATUS_1, ioaddr);
 514         tx_status = inw (ioaddr);
 515         outb (CR0_STATUS_2, ioaddr);
 516         rx_offset = inw (ioaddr);
 517         outb (CR0_STATUS_3, ioaddr);
 518         state = inb (ioaddr);
 519         printk (KERN_WARNING "%s: transmit timed out, status %02x %04x %04x %02x,"
 520          " resetting.\n", dev->name, event, tx_status, rx_offset, state);
 521         if (tx_status == TX_LOST_CRS)
 522                 printk (KERN_WARNING "%s: Tx carrier error, check transceiver cable.\n",
 523                         dev->name);
 524         outb (OP0_RESET, ioaddr);
 525         hardware_init (dev);
 526         netif_wake_queue (dev);
 527 }
 528
 529 static netdev_tx_t znet_send_packet(struct sk_buff *skb, struct net_device *dev)
 530 {
 531         int ioaddr = dev->base_addr;
 532         struct znet_private *znet = netdev_priv(dev);
 533         unsigned long flags;
 534         short length = skb->len;
 535
 536         if (znet_debug > 4)
 537                 printk(KERN_DEBUG "%s: ZNet_send_packet.\n", dev->name);
 538
 539         if (length < ETH_ZLEN) {
 540                 if (skb_padto(skb, ETH_ZLEN))
 541                         return NETDEV_TX_OK;
 542                 length = ETH_ZLEN;
 543         }
 544
 545         netif_stop_queue (dev);
 546
 547         /* Check that the part hasn't reset itself, probably from suspend. */
 548         outb(CR0_STATUS_0, ioaddr);
 549         if (inw(ioaddr) == 0x0010 &&
 550             inw(ioaddr) == 0x0000 &&
 551             inw(ioaddr) == 0x0010) {
 552                 if (znet_debug > 1)
 553                         printk (KERN_WARNING "%s : waking up\n", dev->name);
 554                 hardware_init(dev);
 555                 znet_transceiver_power (dev, 1);
 556         }
 557
 558         if (1) {
 559                 unsigned char *buf = (void *)skb->data;
 560                 ushort *tx_link = znet->tx_cur - 1;
 561                 ushort rnd_len = (length + 1)>>1;
 562
 563                 dev->stats.tx_bytes+=length;
 564
 565                 if (znet->tx_cur >= znet->tx_end)
 566                   znet->tx_cur = znet->tx_start;
 567                 *znet->tx_cur++ = length;
 568                 if (znet->tx_cur + rnd_len + 1 > znet->tx_end) {
 569                         int semi_cnt = (znet->tx_end - znet->tx_cur)<<1; /* Cvrt to byte cnt. */
 570                         memcpy(znet->tx_cur, buf, semi_cnt);
 571                         rnd_len -= semi_cnt>>1;
 572                         memcpy(znet->tx_start, buf + semi_cnt, length - semi_cnt);
 573                         znet->tx_cur = znet->tx_start + rnd_len;
 574                 } else {
 575                         memcpy(znet->tx_cur, buf, skb->len);
 576                         znet->tx_cur += rnd_len;
 577                 }
 578                 *znet->tx_cur++ = 0;
 579
 580                 spin_lock_irqsave(&znet->lock, flags);
 581                 {
 582                         *tx_link = OP0_TRANSMIT | CR0_CHNL;
 583                         /* Is this always safe to do? */
 584                         outb(OP0_TRANSMIT | CR0_CHNL, ioaddr);
 585                 }
 586                 spin_unlock_irqrestore (&znet->lock, flags);
 587
 588                 dev->trans_start = jiffies;
 589                 netif_start_queue (dev);
 590
 591                 if (znet_debug > 4)
 592                   printk(KERN_DEBUG "%s: Transmitter queued, length %d.\n", dev->name, length);
 593         }
 594         dev_kfree_skb(skb);
 595         return NETDEV_TX_OK;
 596 }
 597
 598 /* The ZNET interrupt handler. */
 599 static irqreturn_t znet_interrupt(int irq, void *dev_id)
 600 {
 601         struct net_device *dev = dev_id;
 602         struct znet_private *znet = netdev_priv(dev);
 603         int ioaddr;
 604         int boguscnt = 20;
 605         int handled = 0;
 606
 607         spin_lock (&znet->lock);
 608
 609         ioaddr = dev->base_addr;
 610
 611         outb(CR0_STATUS_0, ioaddr);
 612         do {
 613                 ushort status = inb(ioaddr);
 614                 if (znet_debug > 5) {
 615                         ushort result, rx_ptr, running;
 616                         outb(CR0_STATUS_1, ioaddr);
 617                         result = inw(ioaddr);
 618                         outb(CR0_STATUS_2, ioaddr);
 619                         rx_ptr = inw(ioaddr);
 620                         outb(CR0_STATUS_3, ioaddr);
 621                         running = inb(ioaddr);
 622                         printk(KERN_DEBUG "%s: interrupt, status %02x, %04x %04x %02x serial %d.\n",
 623                                  dev->name, status, result, rx_ptr, running, boguscnt);
 624                 }
 625                 if ((status & SR0_INTERRUPT) == 0)
 626                         break;
 627
 628                 handled = 1;
 629
 630                 if ((status & SR0_EVENT_MASK) == SR0_TRANSMIT_DONE ||
 631                     (status & SR0_EVENT_MASK) == SR0_RETRANSMIT_DONE ||
 632                     (status & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE) {
 633                         int tx_status;
 634                         outb(CR0_STATUS_1, ioaddr);
 635                         tx_status = inw(ioaddr);
 636                         /* It's undocumented, but tx_status seems to match the i82586. */
 637                         if (tx_status & TX_OK) {
 638                                 dev->stats.tx_packets++;
 639                                 dev->stats.collisions += tx_status & TX_NCOL_MASK;
 640                         } else {
 641                                 if (tx_status & (TX_LOST_CTS | TX_LOST_CRS))
 642                                         dev->stats.tx_carrier_errors++;
 643                                 if (tx_status & TX_UND_RUN)
 644                                         dev->stats.tx_fifo_errors++;
 645                                 if (!(tx_status & TX_HRT_BEAT))
 646                                         dev->stats.tx_heartbeat_errors++;
 647                                 if (tx_status & TX_MAX_COL)
 648                                         dev->stats.tx_aborted_errors++;
 649                                 /* ...and the catch-all. */
 650                                 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))
 651                                         dev->stats.tx_errors++;
 652
 653                                 /* Transceiver may be stuck if cable
 654                                  * was removed while emiting a
 655                                  * packet. Flip it off, then on to
 656                                  * reset it. This is very empirical,
 657                                  * but it seems to work. */
 658
 659                                 znet_transceiver_power (dev, 0);
 660                                 znet_transceiver_power (dev, 1);
 661                         }
 662                         netif_wake_queue (dev);
 663                 }
 664
 665                 if ((status & SR0_RECEPTION) ||
 666                     (status & SR0_EVENT_MASK) == SR0_STOP_REG_HIT) {
 667                         znet_rx(dev);
 668                 }
 669                 /* Clear the interrupts we've handled. */
 670                 outb(CR0_INT_ACK, ioaddr);
 671         } while (boguscnt--);
 672
 673         spin_unlock (&znet->lock);
 674
 675         return IRQ_RETVAL(handled);
 676 }
 677
 678 static void znet_rx(struct net_device *dev)
 679 {
 680         struct znet_private *znet = netdev_priv(dev);
 681         int ioaddr = dev->base_addr;
 682         int boguscount = 1;
 683         short next_frame_end_offset = 0;                /* Offset of next frame start. */
 684         short *cur_frame_end;
 685         short cur_frame_end_offset;
 686
 687         outb(CR0_STATUS_2, ioaddr);
 688         cur_frame_end_offset = inw(ioaddr);
 689
 690         if (cur_frame_end_offset == znet->rx_cur - znet->rx_start) {
 691                 printk(KERN_WARNING "%s: Interrupted, but nothing to receive, offset %03x.\n",
 692                            dev->name, cur_frame_end_offset);
 693                 return;
 694         }
 695
 696         /* Use same method as the Crynwr driver: construct a forward list in
 697            the same area of the backwards links we now have.  This allows us to
 698            pass packets to the upper layers in the order they were received --
 699            important for fast-path sequential operations. */
 700         while (znet->rx_start + cur_frame_end_offset != znet->rx_cur &&
 701                ++boguscount < 5) {
 702                 unsigned short hi_cnt, lo_cnt, hi_status, lo_status;
 703                 int count, status;
 704
 705                 if (cur_frame_end_offset < 4) {
 706                         /* Oh no, we have a special case: the frame trailer wraps around
 707                            the end of the ring buffer.  We've saved space at the end of
 708                            the ring buffer for just this problem. */
 709                         memcpy(znet->rx_end, znet->rx_start, 8);
 710                         cur_frame_end_offset += (RX_BUF_SIZE/2);
 711                 }
 712                 cur_frame_end = znet->rx_start + cur_frame_end_offset - 4;
 713
 714                 lo_status = *cur_frame_end++;
 715                 hi_status = *cur_frame_end++;
 716                 status = ((hi_status & 0xff) << 8) + (lo_status & 0xff);
 717                 lo_cnt = *cur_frame_end++;
 718                 hi_cnt = *cur_frame_end++;
 719                 count = ((hi_cnt & 0xff) << 8) + (lo_cnt & 0xff);
 720
 721                 if (znet_debug > 5)
 722                   printk(KERN_DEBUG "Constructing trailer at location %03x, %04x %04x %04x %04x"
 723                                  " count %#x status %04x.\n",
 724                                  cur_frame_end_offset<<1, lo_status, hi_status, lo_cnt, hi_cnt,
 725                                  count, status);
 726                 cur_frame_end[-4] = status;
 727                 cur_frame_end[-3] = next_frame_end_offset;
 728                 cur_frame_end[-2] = count;
 729                 next_frame_end_offset = cur_frame_end_offset;
 730                 cur_frame_end_offset -= ((count + 1)>>1) + 3;
 731                 if (cur_frame_end_offset < 0)
 732                   cur_frame_end_offset += RX_BUF_SIZE/2;
 733         };
 734
 735         /* Now step  forward through the list. */
 736         do {
 737                 ushort *this_rfp_ptr = znet->rx_start + next_frame_end_offset;
 738                 int status = this_rfp_ptr[-4];
 739                 int pkt_len = this_rfp_ptr[-2];
 740
 741                 if (znet_debug > 5)
 742                   printk(KERN_DEBUG "Looking at trailer ending at %04x status %04x length %03x"
 743                                  " next %04x.\n", next_frame_end_offset<<1, status, pkt_len,
 744                                  this_rfp_ptr[-3]<<1);
 745                 /* Once again we must assume that the i82586 docs apply. */
 746                 if ( ! (status & RX_RCV_OK)) { /* There was an error. */
 747                         dev->stats.rx_errors++;
 748                         if (status & RX_CRC_ERR) dev->stats.rx_crc_errors++;
 749                         if (status & RX_ALG_ERR) dev->stats.rx_frame_errors++;
 750 #if 0
 751                         if (status & 0x0200) dev->stats.rx_over_errors++; /* Wrong. */
 752                         if (status & 0x0100) dev->stats.rx_fifo_errors++;
 753 #else
 754                         /* maz : Wild guess... */
 755                         if (status & RX_OVRRUN) dev->stats.rx_over_errors++;
 756 #endif
 757                         if (status & RX_SRT_FRM) dev->stats.rx_length_errors++;
 758                 } else if (pkt_len > 1536) {
 759                         dev->stats.rx_length_errors++;
 760                 } else {
 761                         /* Malloc up new buffer. */
 762                         struct sk_buff *skb;
 763
 764                         skb = dev_alloc_skb(pkt_len);
 765                         if (skb == NULL) {
 766                                 if (znet_debug)
 767                                   printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
 768                                 dev->stats.rx_dropped++;
 769                                 break;
 770                         }
 771
 772                         if (&znet->rx_cur[(pkt_len+1)>>1] > znet->rx_end) {
 773                                 int semi_cnt = (znet->rx_end - znet->rx_cur)<<1;
 774                                 memcpy(skb_put(skb,semi_cnt), znet->rx_cur, semi_cnt);
 775                                 memcpy(skb_put(skb,pkt_len-semi_cnt), znet->rx_start,
 776                                            pkt_len - semi_cnt);
 777                         } else {
 778                                 memcpy(skb_put(skb,pkt_len), znet->rx_cur, pkt_len);
 779                                 if (znet_debug > 6) {
 780                                         unsigned int *packet = (unsigned int *) skb->data;
 781                                         printk(KERN_DEBUG "Packet data is %08x %08x %08x %08x.\n", packet[0],
 782                                                    packet[1], packet[2], packet[3]);
 783                                 }
 784                   }
 785                   skb->protocol=eth_type_trans(skb,dev);
 786                   netif_rx(skb);
 787                   dev->stats.rx_packets++;
 788                   dev->stats.rx_bytes += pkt_len;
 789                 }
 790                 znet->rx_cur = this_rfp_ptr;
 791                 if (znet->rx_cur >= znet->rx_end)
 792                         znet->rx_cur -= RX_BUF_SIZE/2;
 793                 update_stop_hit(ioaddr, (znet->rx_cur - znet->rx_start)<<1);
 794                 next_frame_end_offset = this_rfp_ptr[-3];
 795                 if (next_frame_end_offset == 0)         /* Read all the frames? */
 796                         break;                  /* Done for now */
 797                 this_rfp_ptr = znet->rx_start + next_frame_end_offset;
 798         } while (--boguscount);
 799
 800         /* If any worth-while packets have been received, dev_rint()
 801            has done a mark_bh(INET_BH) for us and will work on them
 802            when we get to the bottom-half routine. */
 803         return;
 804 }
 805
 806 /* The inverse routine to znet_open(). */
 807 static int znet_close(struct net_device *dev)
 808 {
 809         int ioaddr = dev->base_addr;
 810
 811         netif_stop_queue (dev);
 812
 813         outb(OP0_RESET, ioaddr);                        /* CMD0_RESET */
 814
 815         if (znet_debug > 1)
 816                 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
 817         /* Turn off transceiver power. */
 818         znet_transceiver_power (dev, 0);
 819
 820         znet_release_resources (dev);
 821
 822         return 0;
 823 }
 824
 825 static void show_dma(struct net_device *dev)
 826 {
 827         short ioaddr = dev->base_addr;
 828         unsigned char stat = inb (ioaddr);
 829         struct znet_private *znet = netdev_priv(dev);
 830         unsigned long flags;
 831         short dma_port = ((znet->tx_dma&3)<<2) + IO_DMA2_BASE;
 832         unsigned addr = inb(dma_port);
 833         short residue;
 834
 835         addr |= inb(dma_port) << 8;
 836         residue = get_dma_residue(znet->tx_dma);
 837
 838         if (znet_debug > 1) {
 839                 flags=claim_dma_lock();
 840                 printk(KERN_DEBUG "Stat:%02x Addr: %04x cnt:%3x\n",
 841                        stat, addr<<1, residue);
 842                 release_dma_lock(flags);
 843         }
 844 }
 845
 846 /* Initialize the hardware.  We have to do this when the board is open()ed
 847    or when we come out of suspend mode. */
 848 static void hardware_init(struct net_device *dev)
 849 {
 850         unsigned long flags;
 851         short ioaddr = dev->base_addr;
 852         struct znet_private *znet = netdev_priv(dev);
 853
 854         znet->rx_cur = znet->rx_start;
 855         znet->tx_cur = znet->tx_start;
 856
 857         /* Reset the chip, and start it up. */
 858         outb(OP0_RESET, ioaddr);
 859
 860         flags=claim_dma_lock();
 861         disable_dma(znet->rx_dma);              /* reset by an interrupting task. */
 862         clear_dma_ff(znet->rx_dma);
 863         set_dma_mode(znet->rx_dma, DMA_RX_MODE);
 864         set_dma_addr(znet->rx_dma, (unsigned int) znet->rx_start);
 865         set_dma_count(znet->rx_dma, RX_BUF_SIZE);
 866         enable_dma(znet->rx_dma);
 867         /* Now set up the Tx channel. */
 868         disable_dma(znet->tx_dma);
 869         clear_dma_ff(znet->tx_dma);
 870         set_dma_mode(znet->tx_dma, DMA_TX_MODE);
 871         set_dma_addr(znet->tx_dma, (unsigned int) znet->tx_start);
 872         set_dma_count(znet->tx_dma, znet->tx_buf_len<<1);
 873         enable_dma(znet->tx_dma);
 874         release_dma_lock(flags);
 875
 876         if (znet_debug > 1)
 877           printk(KERN_DEBUG "%s: Initializing the i82593, rx buf %p tx buf %p\n",
 878                          dev->name, znet->rx_start,znet->tx_start);
 879         /* Do an empty configure command, just like the Crynwr driver.  This
 880            resets to chip to its default values. */
 881         *znet->tx_cur++ = 0;
 882         *znet->tx_cur++ = 0;
 883         show_dma(dev);
 884         outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
 885
 886         znet_set_multicast_list (dev);
 887
 888         *znet->tx_cur++ = 6;
 889         memcpy(znet->tx_cur, dev->dev_addr, 6);
 890         znet->tx_cur += 3;
 891         show_dma(dev);
 892         outb(OP0_IA_SETUP | CR0_CHNL, ioaddr);
 893         show_dma(dev);
 894
 895         update_stop_hit(ioaddr, 8192);
 896         if (znet_debug > 1)  printk(KERN_DEBUG "enabling Rx.\n");
 897         outb(OP0_RCV_ENABLE, ioaddr);
 898         netif_start_queue (dev);
 899 }
 900
 901 static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset)
 902 {
 903         outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, ioaddr);
 904         if (znet_debug > 5)
 905           printk(KERN_DEBUG "Updating stop hit with value %02x.\n",
 906                          (rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE);
 907         outb((rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE, ioaddr);
 908         outb(OP1_SWIT_TO_PORT_0, ioaddr);
 909 }
 910
 911 static __exit void znet_cleanup (void)
 912 {
 913         if (znet_dev) {
 914                 struct znet_private *znet = netdev_priv(znet_dev);
 915
 916                 unregister_netdev (znet_dev);
 917                 kfree (znet->rx_start);
 918                 kfree (znet->tx_start);
 919                 free_netdev (znet_dev);
 920         }
 921 }
 922
 923 module_init (znet_probe);
 924 module_exit (znet_cleanup);