1 /* znet.c: An Zenith Z-Note ethernet driver for linux. */
4 Written by Donald Becker.
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.
11 Thanks to Mike Hollick for alpha testing and suggestions.
14 The Crynwr packet driver.
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
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.
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.)
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
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.
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.
65 o Resurected for Linux 2.5+ by Marc Zyngier <maz@wild-wind.fr.eu.org> :
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.
77 Some code was taken from wavelan_cs.
79 Tested on a vintage Zenith Z-Note 433Lnp+. Probably broken on
80 anything else. Testers (and detailed bug reports) are welcome :-).
84 - Properly handle multicast
85 - Understand why some traffic patterns add a 1s latency...
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>
106 #include <linux/i82593.h>
108 static char version
[] __initdata
= "znet.c:v1.02 9/23/94 becker@scyld.com\n";
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");
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 */
126 #define TX_TIMEOUT (HZ/10)
128 struct znet_private
{
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. */
139 /* Only one can be built-in;-> */
140 static struct net_device
*znet_dev
;
142 #define NETIDBLK_MAGIC "NETIDBLK"
143 #define NETIDBLK_MAGIC_SIZE 8
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. */
151 char irq1
, irq2
; /* Interrupts, only one is currently used. */
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 */
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
);
170 /* Request needed resources */
171 static int znet_request_resources (struct net_device
*dev
)
173 struct znet_private
*znet
= netdev_priv(dev
);
175 if (request_irq (dev
->irq
, znet_interrupt
, 0, "ZNet", dev
))
177 if (request_dma (znet
->rx_dma
, "ZNet rx"))
179 if (request_dma (znet
->tx_dma
, "ZNet tx"))
181 if (!request_region (znet
->sia_base
, znet
->sia_size
, "ZNet SIA"))
183 if (!request_region (dev
->base_addr
, znet
->io_size
, "ZNet I/O"))
186 return 0; /* Happy ! */
189 release_region (znet
->sia_base
, znet
->sia_size
);
191 free_dma (znet
->tx_dma
);
193 free_dma (znet
->rx_dma
);
195 free_irq (dev
->irq
, dev
);
200 static void znet_release_resources (struct net_device
*dev
)
202 struct znet_private
*znet
= netdev_priv(dev
);
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
);
211 /* Keep the magical SIA stuff in a single function... */
212 static void znet_transceiver_power (struct net_device
*dev
, int on
)
214 struct znet_private
*znet
= netdev_priv(dev
);
217 /* Turn on/off the 82501 SIA, using zenith-specific magic. */
218 /* Select LAN control register */
219 outb(0x10, znet
->sia_base
);
222 v
= inb(znet
->sia_base
+ 1) | 0x84;
224 v
= inb(znet
->sia_base
+ 1) & ~0x84;
226 outb(v
, znet
->sia_base
+1); /* Turn on/off LAN power (bit 2). */
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
)
233 struct znet_private
*znet
= netdev_priv(dev
);
234 short ioaddr
= dev
->base_addr
;
235 struct i82593_conf_block
*cfblk
= &znet
->i593_init
;
237 memset(cfblk
, 0x00, sizeof(struct i82593_conf_block
));
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. */
245 /* maz : Rewritten to take advantage of the wanvelan includes.
246 At least we have names, not just blind values */
249 cfblk
->fifo_limit
= 10; /* = 16 B rx and 80 B tx fifo thresholds */
250 cfblk
->forgnesi
= 0; /* 0=82C501, 1=AMD7992B compatibility */
252 cfblk
->d6mod
= 0; /* Run in i82593 advanced mode */
253 cfblk
->throttle_enb
= 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 */
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 */
267 cfblk
->lin_prio
= 0; /* Default priorities & backoff methods. */
273 cfblk
->ifrm_spc
= 6; /* 96 bit times interframe spacing */
276 cfblk
->slottim_low
= 0; /* 512 bit times slot time (low) */
279 cfblk
->slottim_hi
= 2; /* 512 bit times slot time (high) */
280 cfblk
->max_retr
= 15; /* 15 collisions retries */
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 */
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 */
296 cfblk
->min_fr_len
= ETH_ZLEN
>> 2; /* Minimum frame length */
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 */
309 cfblk
->fdx
= 0; /* Disable full duplex operation */
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 ?! */
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 */
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 */
336 cfblk
->rbuf_size
= RX_BUF_SIZE
>> 12; /* Set receive buffer size */
337 cfblk
->rcvstop
= 1; /* Enable Receive Stop Register */
339 if (znet_debug
> 2) {
343 for (i
= 0, c
= (char *) cfblk
; i
< sizeof (*cfblk
); i
++)
344 printk ("%02X ", c
[i
]);
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
);
353 /* XXX FIXME maz : Add multicast addresses here, so having a
354 * multicast address configured isn't equal to IFF_ALLMULTI */
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
,
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. */
372 static int __init
znet_probe (void)
375 struct netidblk
*netinfo
;
376 struct znet_private
*znet
;
377 struct net_device
*dev
;
379 char *plast
= phys_to_virt(0x100000 - NETIDBLK_MAGIC_SIZE
);
382 /* This code scans the region 0xf0000 to 0xfffff for a "NETIDBLK". */
383 for(p
= (char *)phys_to_virt(0xf0000); p
<= plast
; p
++)
385 strncmp(p
, NETIDBLK_MAGIC
, NETIDBLK_MAGIC_SIZE
) == 0)
390 printk(KERN_INFO
"No Z-Note ethernet adaptor found.\n");
394 dev
= alloc_etherdev(sizeof(struct znet_private
));
398 znet
= netdev_priv(dev
);
400 netinfo
= (struct netidblk
*)p
;
401 dev
->base_addr
= netinfo
->iobase1
;
402 dev
->irq
= netinfo
->irq1
;
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
];
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
);
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
);
424 printk(KERN_INFO
"%s", version
);
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 */
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 */
436 if (!(znet
->rx_start
= kmalloc (DMA_BUF_SIZE
, GFP_KERNEL
| GFP_DMA
)))
438 if (!(znet
->tx_start
= kmalloc (DMA_BUF_SIZE
, GFP_KERNEL
| GFP_DMA
)))
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");
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
;
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
);
461 kfree(znet
->tx_start
);
463 kfree(znet
->rx_start
);
470 static int znet_open(struct net_device
*dev
)
472 int ioaddr
= dev
->base_addr
;
475 printk(KERN_DEBUG
"%s: znet_open() called.\n", dev
->name
);
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
);
483 znet_transceiver_power (dev
, 1);
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. */
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
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",
506 netif_start_queue (dev
);
512 static void znet_tx_timeout (struct net_device
*dev
)
514 int ioaddr
= dev
->base_addr
;
515 ushort event
, tx_status
, rx_offset
, state
;
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",
530 outb (OP0_RESET
, ioaddr
);
532 netif_wake_queue (dev
);
535 static netdev_tx_t
znet_send_packet(struct sk_buff
*skb
, struct net_device
*dev
)
537 int ioaddr
= dev
->base_addr
;
538 struct znet_private
*znet
= netdev_priv(dev
);
540 short length
= skb
->len
;
543 printk(KERN_DEBUG
"%s: ZNet_send_packet.\n", dev
->name
);
545 if (length
< ETH_ZLEN
) {
546 if (skb_padto(skb
, ETH_ZLEN
))
551 netif_stop_queue (dev
);
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) {
559 printk (KERN_WARNING
"%s : waking up\n", dev
->name
);
561 znet_transceiver_power (dev
, 1);
565 unsigned char *buf
= (void *)skb
->data
;
566 ushort
*tx_link
= znet
->tx_cur
- 1;
567 ushort rnd_len
= (length
+ 1)>>1;
569 dev
->stats
.tx_bytes
+=length
;
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
;
581 memcpy(znet
->tx_cur
, buf
, skb
->len
);
582 znet
->tx_cur
+= rnd_len
;
586 spin_lock_irqsave(&znet
->lock
, flags
);
588 *tx_link
= OP0_TRANSMIT
| CR0_CHNL
;
589 /* Is this always safe to do? */
590 outb(OP0_TRANSMIT
| CR0_CHNL
, ioaddr
);
592 spin_unlock_irqrestore (&znet
->lock
, flags
);
594 netif_start_queue (dev
);
597 printk(KERN_DEBUG
"%s: Transmitter queued, length %d.\n", dev
->name
, length
);
603 /* The ZNET interrupt handler. */
604 static irqreturn_t
znet_interrupt(int irq
, void *dev_id
)
606 struct net_device
*dev
= dev_id
;
607 struct znet_private
*znet
= netdev_priv(dev
);
612 spin_lock (&znet
->lock
);
614 ioaddr
= dev
->base_addr
;
616 outb(CR0_STATUS_0
, ioaddr
);
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
);
630 if ((status
& SR0_INTERRUPT
) == 0)
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
) {
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
;
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
++;
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. */
664 znet_transceiver_power (dev
, 0);
665 znet_transceiver_power (dev
, 1);
667 netif_wake_queue (dev
);
670 if ((status
& SR0_RECEPTION
) ||
671 (status
& SR0_EVENT_MASK
) == SR0_STOP_REG_HIT
) {
674 /* Clear the interrupts we've handled. */
675 outb(CR0_INT_ACK
, ioaddr
);
676 } while (boguscnt
--);
678 spin_unlock (&znet
->lock
);
680 return IRQ_RETVAL(handled
);
683 static void znet_rx(struct net_device
*dev
)
685 struct znet_private
*znet
= netdev_priv(dev
);
686 int ioaddr
= dev
->base_addr
;
688 short next_frame_end_offset
= 0; /* Offset of next frame start. */
689 short *cur_frame_end
;
690 short cur_frame_end_offset
;
692 outb(CR0_STATUS_2
, ioaddr
);
693 cur_frame_end_offset
= inw(ioaddr
);
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
);
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
&&
707 unsigned short hi_cnt
, lo_cnt
, hi_status
, lo_status
;
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);
717 cur_frame_end
= znet
->rx_start
+ cur_frame_end_offset
- 4;
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);
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
,
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;
740 /* Now step forward through the list. */
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];
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
++;
756 if (status
& 0x0200) dev
->stats
.rx_over_errors
++; /* Wrong. */
757 if (status
& 0x0100) dev
->stats
.rx_fifo_errors
++;
759 /* maz : Wild guess... */
760 if (status
& RX_OVRRUN
) dev
->stats
.rx_over_errors
++;
762 if (status
& RX_SRT_FRM
) dev
->stats
.rx_length_errors
++;
763 } else if (pkt_len
> 1536) {
764 dev
->stats
.rx_length_errors
++;
766 /* Malloc up new buffer. */
769 skb
= netdev_alloc_skb(dev
, pkt_len
);
772 printk(KERN_WARNING
"%s: Memory squeeze, dropping packet.\n", dev
->name
);
773 dev
->stats
.rx_dropped
++;
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
,
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]);
790 skb
->protocol
=eth_type_trans(skb
,dev
);
792 dev
->stats
.rx_packets
++;
793 dev
->stats
.rx_bytes
+= pkt_len
;
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
);
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. */
810 /* The inverse routine to znet_open(). */
811 static int znet_close(struct net_device
*dev
)
813 int ioaddr
= dev
->base_addr
;
815 netif_stop_queue (dev
);
817 outb(OP0_RESET
, ioaddr
); /* CMD0_RESET */
820 printk(KERN_DEBUG
"%s: Shutting down ethercard.\n", dev
->name
);
821 /* Turn off transceiver power. */
822 znet_transceiver_power (dev
, 0);
824 znet_release_resources (dev
);
829 static void show_dma(struct net_device
*dev
)
831 short ioaddr
= dev
->base_addr
;
832 unsigned char stat
= inb (ioaddr
);
833 struct znet_private
*znet
= netdev_priv(dev
);
835 short dma_port
= ((znet
->tx_dma
&3)<<2) + IO_DMA2_BASE
;
836 unsigned addr
= inb(dma_port
);
839 addr
|= inb(dma_port
) << 8;
840 residue
= get_dma_residue(znet
->tx_dma
);
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
);
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
)
855 short ioaddr
= dev
->base_addr
;
856 struct znet_private
*znet
= netdev_priv(dev
);
858 znet
->rx_cur
= znet
->rx_start
;
859 znet
->tx_cur
= znet
->tx_start
;
861 /* Reset the chip, and start it up. */
862 outb(OP0_RESET
, ioaddr
);
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
, (unsigned int) 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
, (unsigned int) 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
);
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. */
888 outb(OP0_CONFIGURE
| CR0_CHNL
, ioaddr
);
890 znet_set_multicast_list (dev
);
893 memcpy(znet
->tx_cur
, dev
->dev_addr
, 6);
896 outb(OP0_IA_SETUP
| CR0_CHNL
, ioaddr
);
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
);
905 static void update_stop_hit(short ioaddr
, unsigned short rx_stop_offset
)
907 outb(OP0_SWIT_TO_PORT_1
| CR0_CHNL
, ioaddr
);
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
);
915 static __exit
void znet_cleanup (void)
918 struct znet_private
*znet
= netdev_priv(znet_dev
);
920 unregister_netdev (znet_dev
);
921 kfree (znet
->rx_start
);
922 kfree (znet
->tx_start
);
923 free_netdev (znet_dev
);
927 module_init (znet_probe
);
928 module_exit (znet_cleanup
);