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