Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
znet.c
Go to the documentation of this file.
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 [email protected].
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 <[email protected]> :
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 [email protected]\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 {
133  /* The starting, current, and end pointers for the packet buffers. */
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 */
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' &&
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);
868  set_dma_addr(znet->rx_dma, isa_virt_to_bus(znet->rx_start));
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);
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);