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