blob: ec2800ff8d428241dcb68c36c0fda530719e20d0 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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.
Jeff Garzik6aa20a22006-09-13 13:24:59 -040078
Linus Torvalds1da177e2005-04-16 15:20:36 -070079 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
Linus Torvalds1da177e2005-04-16 15:20:36 -070088#include <linux/module.h>
89#include <linux/kernel.h>
90#include <linux/string.h>
Tejun Heo5a0e3ad2010-03-24 17:04:11 +090091#include <linux/slab.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070092#include <linux/errno.h>
93#include <linux/interrupt.h>
94#include <linux/ioport.h>
95#include <linux/init.h>
96#include <linux/delay.h>
97#include <linux/netdevice.h>
98#include <linux/etherdevice.h>
99#include <linux/skbuff.h>
100#include <linux/if_arp.h>
101#include <linux/bitops.h>
102
103#include <asm/system.h>
104#include <asm/io.h>
105#include <asm/dma.h>
106
John W. Linvillec85e9d72009-11-17 10:16:32 -0500107#include <linux/i82593.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
109static char version[] __initdata = "znet.c:v1.02 9/23/94 becker@scyld.com\n";
110
111#ifndef ZNET_DEBUG
112#define ZNET_DEBUG 1
113#endif
114static unsigned int znet_debug = ZNET_DEBUG;
115module_param (znet_debug, int, 0);
116MODULE_PARM_DESC (znet_debug, "ZNet debug level");
117MODULE_LICENSE("GPL");
118
119/* The DMA modes we need aren't in <dma.h>. */
120#define DMA_RX_MODE 0x14 /* Auto init, I/O to mem, ++, demand. */
121#define DMA_TX_MODE 0x18 /* Auto init, Mem to I/O, ++, demand. */
122#define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
123#define RX_BUF_SIZE 8192
124#define TX_BUF_SIZE 8192
125#define DMA_BUF_SIZE (RX_BUF_SIZE + 16) /* 8k + 16 bytes for trailers */
126
Eric Dumazetc63fdf42010-11-03 22:49:35 +0000127#define TX_TIMEOUT (HZ/10)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700128
129struct znet_private {
130 int rx_dma, tx_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700131 spinlock_t lock;
132 short sia_base, sia_size, io_size;
133 struct i82593_conf_block i593_init;
134 /* The starting, current, and end pointers for the packet buffers. */
135 ushort *rx_start, *rx_cur, *rx_end;
136 ushort *tx_start, *tx_cur, *tx_end;
137 ushort tx_buf_len; /* Tx buffer length, in words. */
138};
139
140/* Only one can be built-in;-> */
141static struct net_device *znet_dev;
142
143struct netidblk {
144 char magic[8]; /* The magic number (string) "NETIDBLK" */
145 unsigned char netid[8]; /* The physical station address */
146 char nettype, globalopt;
147 char vendor[8]; /* The machine vendor and product name. */
148 char product[8];
149 char irq1, irq2; /* Interrupts, only one is currently used. */
150 char dma1, dma2;
151 short dma_mem_misc[8]; /* DMA buffer locations (unused in Linux). */
152 short iobase1, iosize1;
153 short iobase2, iosize2; /* Second iobase unused. */
154 char driver_options; /* Misc. bits */
155 char pad;
156};
157
158static int znet_open(struct net_device *dev);
Stephen Hemminger613573252009-08-31 19:50:58 +0000159static netdev_tx_t znet_send_packet(struct sk_buff *skb,
160 struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100161static irqreturn_t znet_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162static void znet_rx(struct net_device *dev);
163static int znet_close(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700164static void hardware_init(struct net_device *dev);
165static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset);
166static void znet_tx_timeout (struct net_device *dev);
167
168/* Request needed resources */
169static int znet_request_resources (struct net_device *dev)
170{
Wang Chen524ad0a2008-11-12 23:39:10 -0800171 struct znet_private *znet = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400172
Joe Perchesa0607fd2009-11-18 23:29:17 -0800173 if (request_irq (dev->irq, znet_interrupt, 0, "ZNet", dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700174 goto failed;
175 if (request_dma (znet->rx_dma, "ZNet rx"))
176 goto free_irq;
177 if (request_dma (znet->tx_dma, "ZNet tx"))
178 goto free_rx_dma;
179 if (!request_region (znet->sia_base, znet->sia_size, "ZNet SIA"))
180 goto free_tx_dma;
181 if (!request_region (dev->base_addr, znet->io_size, "ZNet I/O"))
182 goto free_sia;
183
184 return 0; /* Happy ! */
185
186 free_sia:
187 release_region (znet->sia_base, znet->sia_size);
188 free_tx_dma:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 free_dma (znet->tx_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 free_rx_dma:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 free_dma (znet->rx_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700192 free_irq:
193 free_irq (dev->irq, dev);
194 failed:
195 return -1;
196}
197
198static void znet_release_resources (struct net_device *dev)
199{
Wang Chen524ad0a2008-11-12 23:39:10 -0800200 struct znet_private *znet = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400201
Linus Torvalds1da177e2005-04-16 15:20:36 -0700202 release_region (znet->sia_base, znet->sia_size);
203 release_region (dev->base_addr, znet->io_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700204 free_dma (znet->tx_dma);
205 free_dma (znet->rx_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700206 free_irq (dev->irq, dev);
207}
208
209/* Keep the magical SIA stuff in a single function... */
210static void znet_transceiver_power (struct net_device *dev, int on)
211{
Wang Chen524ad0a2008-11-12 23:39:10 -0800212 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700213 unsigned char v;
214
215 /* Turn on/off the 82501 SIA, using zenith-specific magic. */
216 /* Select LAN control register */
217 outb(0x10, znet->sia_base);
218
219 if (on)
220 v = inb(znet->sia_base + 1) | 0x84;
221 else
222 v = inb(znet->sia_base + 1) & ~0x84;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400223
Linus Torvalds1da177e2005-04-16 15:20:36 -0700224 outb(v, znet->sia_base+1); /* Turn on/off LAN power (bit 2). */
225}
226
227/* Init the i82593, with current promisc/mcast configuration.
228 Also used from hardware_init. */
229static void znet_set_multicast_list (struct net_device *dev)
230{
Wang Chen524ad0a2008-11-12 23:39:10 -0800231 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700232 short ioaddr = dev->base_addr;
233 struct i82593_conf_block *cfblk = &znet->i593_init;
234
235 memset(cfblk, 0x00, sizeof(struct i82593_conf_block));
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400236
Linus Torvalds1da177e2005-04-16 15:20:36 -0700237 /* The configuration block. What an undocumented nightmare.
238 The first set of values are those suggested (without explanation)
239 for ethernet in the Intel 82586 databook. The rest appear to be
240 completely undocumented, except for cryptic notes in the Crynwr
241 packet driver. This driver uses the Crynwr values verbatim. */
242
243 /* maz : Rewritten to take advantage of the wanvelan includes.
244 At least we have names, not just blind values */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400245
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246 /* Byte 0 */
247 cfblk->fifo_limit = 10; /* = 16 B rx and 80 B tx fifo thresholds */
248 cfblk->forgnesi = 0; /* 0=82C501, 1=AMD7992B compatibility */
249 cfblk->fifo_32 = 1;
250 cfblk->d6mod = 0; /* Run in i82593 advanced mode */
251 cfblk->throttle_enb = 1;
252
253 /* Byte 1 */
254 cfblk->throttle = 8; /* Continuous w/interrupts, 128-clock DMA. */
255 cfblk->cntrxint = 0; /* enable continuous mode receive interrupts */
256 cfblk->contin = 1; /* enable continuous mode */
257
258 /* Byte 2 */
259 cfblk->addr_len = ETH_ALEN;
260 cfblk->acloc = 1; /* Disable source addr insertion by i82593 */
261 cfblk->preamb_len = 2; /* 8 bytes preamble */
262 cfblk->loopback = 0; /* Loopback off */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400263
Linus Torvalds1da177e2005-04-16 15:20:36 -0700264 /* Byte 3 */
265 cfblk->lin_prio = 0; /* Default priorities & backoff methods. */
266 cfblk->tbofstop = 0;
267 cfblk->exp_prio = 0;
268 cfblk->bof_met = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400269
Linus Torvalds1da177e2005-04-16 15:20:36 -0700270 /* Byte 4 */
271 cfblk->ifrm_spc = 6; /* 96 bit times interframe spacing */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400272
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 /* Byte 5 */
274 cfblk->slottim_low = 0; /* 512 bit times slot time (low) */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400275
Linus Torvalds1da177e2005-04-16 15:20:36 -0700276 /* Byte 6 */
277 cfblk->slottim_hi = 2; /* 512 bit times slot time (high) */
278 cfblk->max_retr = 15; /* 15 collisions retries */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400279
Linus Torvalds1da177e2005-04-16 15:20:36 -0700280 /* Byte 7 */
281 cfblk->prmisc = ((dev->flags & IFF_PROMISC) ? 1 : 0); /* Promiscuous mode */
282 cfblk->bc_dis = 0; /* Enable broadcast reception */
283 cfblk->crs_1 = 0; /* Don't transmit without carrier sense */
284 cfblk->nocrc_ins = 0; /* i82593 generates CRC */
285 cfblk->crc_1632 = 0; /* 32-bit Autodin-II CRC */
286 cfblk->crs_cdt = 0; /* CD not to be interpreted as CS */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400287
Linus Torvalds1da177e2005-04-16 15:20:36 -0700288 /* Byte 8 */
289 cfblk->cs_filter = 0; /* CS is recognized immediately */
290 cfblk->crs_src = 0; /* External carrier sense */
291 cfblk->cd_filter = 0; /* CD is recognized immediately */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400292
Linus Torvalds1da177e2005-04-16 15:20:36 -0700293 /* Byte 9 */
294 cfblk->min_fr_len = ETH_ZLEN >> 2; /* Minimum frame length */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400295
Linus Torvalds1da177e2005-04-16 15:20:36 -0700296 /* Byte A */
297 cfblk->lng_typ = 1; /* Type/length checks OFF */
298 cfblk->lng_fld = 1; /* Disable 802.3 length field check */
299 cfblk->rxcrc_xf = 1; /* Don't transfer CRC to memory */
300 cfblk->artx = 1; /* Disable automatic retransmission */
301 cfblk->sarec = 1; /* Disable source addr trig of CD */
302 cfblk->tx_jabber = 0; /* Disable jabber jam sequence */
303 cfblk->hash_1 = 1; /* Use bits 0-5 in mc address hash */
304 cfblk->lbpkpol = 0; /* Loopback pin active high */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306 /* Byte B */
307 cfblk->fdx = 0; /* Disable full duplex operation */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400308
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309 /* Byte C */
310 cfblk->dummy_6 = 0x3f; /* all ones, Default multicast addresses & backoff. */
311 cfblk->mult_ia = 0; /* No multiple individual addresses */
312 cfblk->dis_bof = 0; /* Disable the backoff algorithm ?! */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400313
Linus Torvalds1da177e2005-04-16 15:20:36 -0700314 /* Byte D */
315 cfblk->dummy_1 = 1; /* set to 1 */
316 cfblk->tx_ifs_retrig = 3; /* Hmm... Disabled */
Jiri Pirko567ec872010-02-23 23:17:07 +0000317 cfblk->mc_all = (!netdev_mc_empty(dev) ||
318 (dev->flags & IFF_ALLMULTI)); /* multicast all mode */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700319 cfblk->rcv_mon = 0; /* Monitor mode disabled */
320 cfblk->frag_acpt = 0; /* Do not accept fragments */
321 cfblk->tstrttrs = 0; /* No start transmission threshold */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400322
Linus Torvalds1da177e2005-04-16 15:20:36 -0700323 /* Byte E */
324 cfblk->fretx = 1; /* FIFO automatic retransmission */
325 cfblk->runt_eop = 0; /* drop "runt" packets */
326 cfblk->hw_sw_pin = 0; /* ?? */
327 cfblk->big_endn = 0; /* Big Endian ? no... */
328 cfblk->syncrqs = 1; /* Synchronous DRQ deassertion... */
329 cfblk->sttlen = 1; /* 6 byte status registers */
330 cfblk->rx_eop = 0; /* Signal EOP on packet reception */
331 cfblk->tx_eop = 0; /* Signal EOP on packet transmission */
332
333 /* Byte F */
334 cfblk->rbuf_size = RX_BUF_SIZE >> 12; /* Set receive buffer size */
335 cfblk->rcvstop = 1; /* Enable Receive Stop Register */
336
337 if (znet_debug > 2) {
338 int i;
339 unsigned char *c;
340
341 for (i = 0, c = (char *) cfblk; i < sizeof (*cfblk); i++)
342 printk ("%02X ", c[i]);
343 printk ("\n");
344 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400345
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 *znet->tx_cur++ = sizeof(struct i82593_conf_block);
347 memcpy(znet->tx_cur, cfblk, sizeof(struct i82593_conf_block));
348 znet->tx_cur += sizeof(struct i82593_conf_block)/2;
349 outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
350
351 /* XXX FIXME maz : Add multicast addresses here, so having a
352 * multicast address configured isn't equal to IFF_ALLMULTI */
353}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400354
Stephen Hemmingerbc0443f2009-01-09 13:01:27 +0000355static const struct net_device_ops znet_netdev_ops = {
356 .ndo_open = znet_open,
357 .ndo_stop = znet_close,
358 .ndo_start_xmit = znet_send_packet,
359 .ndo_set_multicast_list = znet_set_multicast_list,
360 .ndo_tx_timeout = znet_tx_timeout,
361 .ndo_change_mtu = eth_change_mtu,
362 .ndo_set_mac_address = eth_mac_addr,
363 .ndo_validate_addr = eth_validate_addr,
364};
365
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366/* The Z-Note probe is pretty easy. The NETIDBLK exists in the safe-to-probe
367 BIOS area. We just scan for the signature, and pull the vital parameters
368 out of the structure. */
369
370static int __init znet_probe (void)
371{
372 int i;
373 struct netidblk *netinfo;
374 struct znet_private *znet;
375 struct net_device *dev;
376 char *p;
377 int err = -ENOMEM;
378
379 /* This code scans the region 0xf0000 to 0xfffff for a "NETIDBLK". */
380 for(p = (char *)phys_to_virt(0xf0000); p < (char *)phys_to_virt(0x100000); p++)
381 if (*p == 'N' && strncmp(p, "NETIDBLK", 8) == 0)
382 break;
383
384 if (p >= (char *)phys_to_virt(0x100000)) {
385 if (znet_debug > 1)
386 printk(KERN_INFO "No Z-Note ethernet adaptor found.\n");
387 return -ENODEV;
388 }
389
390 dev = alloc_etherdev(sizeof(struct znet_private));
391 if (!dev)
392 return -ENOMEM;
393
Wang Chen524ad0a2008-11-12 23:39:10 -0800394 znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700395
396 netinfo = (struct netidblk *)p;
397 dev->base_addr = netinfo->iobase1;
398 dev->irq = netinfo->irq1;
399
Linus Torvalds1da177e2005-04-16 15:20:36 -0700400 /* The station address is in the "netidblk" at 0x0f0000. */
401 for (i = 0; i < 6; i++)
Joe Perches0795af52007-10-03 17:59:30 -0700402 dev->dev_addr[i] = netinfo->netid[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403
Johannes Berge1749612008-10-27 15:59:26 -0700404 printk(KERN_INFO "%s: ZNET at %#3lx, %pM"
Joe Perches0795af52007-10-03 17:59:30 -0700405 ", using IRQ %d DMA %d and %d.\n",
Johannes Berge1749612008-10-27 15:59:26 -0700406 dev->name, dev->base_addr, dev->dev_addr,
Joe Perches0795af52007-10-03 17:59:30 -0700407 dev->irq, netinfo->dma1, netinfo->dma2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700408
409 if (znet_debug > 1) {
410 printk(KERN_INFO "%s: vendor '%16.16s' IRQ1 %d IRQ2 %d DMA1 %d DMA2 %d.\n",
411 dev->name, netinfo->vendor,
412 netinfo->irq1, netinfo->irq2,
413 netinfo->dma1, netinfo->dma2);
414 printk(KERN_INFO "%s: iobase1 %#x size %d iobase2 %#x size %d net type %2.2x.\n",
415 dev->name, netinfo->iobase1, netinfo->iosize1,
416 netinfo->iobase2, netinfo->iosize2, netinfo->nettype);
417 }
418
419 if (znet_debug > 0)
420 printk(KERN_INFO "%s", version);
421
422 znet->rx_dma = netinfo->dma1;
423 znet->tx_dma = netinfo->dma2;
424 spin_lock_init(&znet->lock);
425 znet->sia_base = 0xe6; /* Magic address for the 82501 SIA */
426 znet->sia_size = 2;
427 /* maz: Despite the '593 being advertised above as using a
428 * single 8bits I/O port, this driver does many 16bits
429 * access. So set io_size accordingly */
430 znet->io_size = 2;
431
432 if (!(znet->rx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
433 goto free_dev;
434 if (!(znet->tx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
435 goto free_rx;
436
437 if (!dma_page_eq (znet->rx_start, znet->rx_start + (RX_BUF_SIZE/2-1)) ||
438 !dma_page_eq (znet->tx_start, znet->tx_start + (TX_BUF_SIZE/2-1))) {
439 printk (KERN_WARNING "tx/rx crossing DMA frontiers, giving up\n");
440 goto free_tx;
441 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400442
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443 znet->rx_end = znet->rx_start + RX_BUF_SIZE/2;
444 znet->tx_buf_len = TX_BUF_SIZE/2;
445 znet->tx_end = znet->tx_start + znet->tx_buf_len;
446
447 /* The ZNET-specific entries in the device structure. */
Stephen Hemmingerbc0443f2009-01-09 13:01:27 +0000448 dev->netdev_ops = &znet_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449 dev->watchdog_timeo = TX_TIMEOUT;
450 err = register_netdev(dev);
451 if (err)
452 goto free_tx;
453 znet_dev = dev;
454 return 0;
455
456 free_tx:
457 kfree(znet->tx_start);
458 free_rx:
459 kfree(znet->rx_start);
460 free_dev:
461 free_netdev(dev);
462 return err;
463}
464
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400465
Linus Torvalds1da177e2005-04-16 15:20:36 -0700466static int znet_open(struct net_device *dev)
467{
468 int ioaddr = dev->base_addr;
469
470 if (znet_debug > 2)
471 printk(KERN_DEBUG "%s: znet_open() called.\n", dev->name);
472
473 /* These should never fail. You can't add devices to a sealed box! */
474 if (znet_request_resources (dev)) {
475 printk(KERN_WARNING "%s: Not opened -- resource busy?!?\n", dev->name);
476 return -EBUSY;
477 }
478
479 znet_transceiver_power (dev, 1);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400480
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481 /* According to the Crynwr driver we should wait 50 msec. for the
482 LAN clock to stabilize. My experiments indicates that the '593 can
483 be initialized immediately. The delay is probably needed for the
484 DC-to-DC converter to come up to full voltage, and for the oscillator
485 to be spot-on at 20Mhz before transmitting.
486 Until this proves to be a problem we rely on the higher layers for the
487 delay and save allocating a timer entry. */
488
489 /* maz : Well, I'm getting every time the following message
490 * without the delay on a 486@33. This machine is much too
491 * fast... :-) So maybe the Crynwr driver wasn't wrong after
492 * all, even if the message is completly harmless on my
493 * setup. */
494 mdelay (50);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400495
Linus Torvalds1da177e2005-04-16 15:20:36 -0700496 /* This follows the packet driver's lead, and checks for success. */
497 if (inb(ioaddr) != 0x10 && inb(ioaddr) != 0x00)
498 printk(KERN_WARNING "%s: Problem turning on the transceiver power.\n",
499 dev->name);
500
501 hardware_init(dev);
502 netif_start_queue (dev);
503
504 return 0;
505}
506
507
508static void znet_tx_timeout (struct net_device *dev)
509{
510 int ioaddr = dev->base_addr;
511 ushort event, tx_status, rx_offset, state;
512
513 outb (CR0_STATUS_0, ioaddr);
514 event = inb (ioaddr);
515 outb (CR0_STATUS_1, ioaddr);
516 tx_status = inw (ioaddr);
517 outb (CR0_STATUS_2, ioaddr);
518 rx_offset = inw (ioaddr);
519 outb (CR0_STATUS_3, ioaddr);
520 state = inb (ioaddr);
521 printk (KERN_WARNING "%s: transmit timed out, status %02x %04x %04x %02x,"
522 " resetting.\n", dev->name, event, tx_status, rx_offset, state);
523 if (tx_status == TX_LOST_CRS)
524 printk (KERN_WARNING "%s: Tx carrier error, check transceiver cable.\n",
525 dev->name);
526 outb (OP0_RESET, ioaddr);
527 hardware_init (dev);
528 netif_wake_queue (dev);
529}
530
Stephen Hemminger613573252009-08-31 19:50:58 +0000531static netdev_tx_t znet_send_packet(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532{
533 int ioaddr = dev->base_addr;
Wang Chen524ad0a2008-11-12 23:39:10 -0800534 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700535 unsigned long flags;
536 short length = skb->len;
537
538 if (znet_debug > 4)
539 printk(KERN_DEBUG "%s: ZNet_send_packet.\n", dev->name);
540
541 if (length < ETH_ZLEN) {
Herbert Xu5b057c62006-06-23 02:06:41 -0700542 if (skb_padto(skb, ETH_ZLEN))
Patrick McHardy6ed10652009-06-23 06:03:08 +0000543 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700544 length = ETH_ZLEN;
545 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 netif_stop_queue (dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 /* Check that the part hasn't reset itself, probably from suspend. */
550 outb(CR0_STATUS_0, ioaddr);
551 if (inw(ioaddr) == 0x0010 &&
552 inw(ioaddr) == 0x0000 &&
553 inw(ioaddr) == 0x0010) {
554 if (znet_debug > 1)
555 printk (KERN_WARNING "%s : waking up\n", dev->name);
556 hardware_init(dev);
557 znet_transceiver_power (dev, 1);
558 }
559
560 if (1) {
561 unsigned char *buf = (void *)skb->data;
562 ushort *tx_link = znet->tx_cur - 1;
563 ushort rnd_len = (length + 1)>>1;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400564
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700565 dev->stats.tx_bytes+=length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700566
567 if (znet->tx_cur >= znet->tx_end)
568 znet->tx_cur = znet->tx_start;
569 *znet->tx_cur++ = length;
570 if (znet->tx_cur + rnd_len + 1 > znet->tx_end) {
571 int semi_cnt = (znet->tx_end - znet->tx_cur)<<1; /* Cvrt to byte cnt. */
572 memcpy(znet->tx_cur, buf, semi_cnt);
573 rnd_len -= semi_cnt>>1;
574 memcpy(znet->tx_start, buf + semi_cnt, length - semi_cnt);
575 znet->tx_cur = znet->tx_start + rnd_len;
576 } else {
577 memcpy(znet->tx_cur, buf, skb->len);
578 znet->tx_cur += rnd_len;
579 }
580 *znet->tx_cur++ = 0;
581
582 spin_lock_irqsave(&znet->lock, flags);
583 {
584 *tx_link = OP0_TRANSMIT | CR0_CHNL;
585 /* Is this always safe to do? */
586 outb(OP0_TRANSMIT | CR0_CHNL, ioaddr);
587 }
588 spin_unlock_irqrestore (&znet->lock, flags);
589
Linus Torvalds1da177e2005-04-16 15:20:36 -0700590 netif_start_queue (dev);
591
592 if (znet_debug > 4)
593 printk(KERN_DEBUG "%s: Transmitter queued, length %d.\n", dev->name, length);
594 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400595 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000596 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700597}
598
599/* The ZNET interrupt handler. */
David Howells7d12e782006-10-05 14:55:46 +0100600static irqreturn_t znet_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700601{
602 struct net_device *dev = dev_id;
Wang Chen524ad0a2008-11-12 23:39:10 -0800603 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700604 int ioaddr;
605 int boguscnt = 20;
606 int handled = 0;
607
Linus Torvalds1da177e2005-04-16 15:20:36 -0700608 spin_lock (&znet->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400609
Linus Torvalds1da177e2005-04-16 15:20:36 -0700610 ioaddr = dev->base_addr;
611
612 outb(CR0_STATUS_0, ioaddr);
613 do {
614 ushort status = inb(ioaddr);
615 if (znet_debug > 5) {
616 ushort result, rx_ptr, running;
617 outb(CR0_STATUS_1, ioaddr);
618 result = inw(ioaddr);
619 outb(CR0_STATUS_2, ioaddr);
620 rx_ptr = inw(ioaddr);
621 outb(CR0_STATUS_3, ioaddr);
622 running = inb(ioaddr);
623 printk(KERN_DEBUG "%s: interrupt, status %02x, %04x %04x %02x serial %d.\n",
624 dev->name, status, result, rx_ptr, running, boguscnt);
625 }
626 if ((status & SR0_INTERRUPT) == 0)
627 break;
628
629 handled = 1;
630
631 if ((status & SR0_EVENT_MASK) == SR0_TRANSMIT_DONE ||
632 (status & SR0_EVENT_MASK) == SR0_RETRANSMIT_DONE ||
633 (status & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE) {
634 int tx_status;
635 outb(CR0_STATUS_1, ioaddr);
636 tx_status = inw(ioaddr);
637 /* It's undocumented, but tx_status seems to match the i82586. */
638 if (tx_status & TX_OK) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700639 dev->stats.tx_packets++;
640 dev->stats.collisions += tx_status & TX_NCOL_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 } else {
642 if (tx_status & (TX_LOST_CTS | TX_LOST_CRS))
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700643 dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700644 if (tx_status & TX_UND_RUN)
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700645 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700646 if (!(tx_status & TX_HRT_BEAT))
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700647 dev->stats.tx_heartbeat_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700648 if (tx_status & TX_MAX_COL)
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700649 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700650 /* ...and the catch-all. */
651 if ((tx_status | (TX_LOST_CRS | TX_LOST_CTS | TX_UND_RUN | TX_HRT_BEAT | TX_MAX_COL)) != (TX_LOST_CRS | TX_LOST_CTS | TX_UND_RUN | TX_HRT_BEAT | TX_MAX_COL))
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700652 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700653
654 /* Transceiver may be stuck if cable
Lucas De Marchi25985ed2011-03-30 22:57:33 -0300655 * was removed while emitting a
Linus Torvalds1da177e2005-04-16 15:20:36 -0700656 * packet. Flip it off, then on to
657 * reset it. This is very empirical,
658 * but it seems to work. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400659
Linus Torvalds1da177e2005-04-16 15:20:36 -0700660 znet_transceiver_power (dev, 0);
661 znet_transceiver_power (dev, 1);
662 }
663 netif_wake_queue (dev);
664 }
665
666 if ((status & SR0_RECEPTION) ||
667 (status & SR0_EVENT_MASK) == SR0_STOP_REG_HIT) {
668 znet_rx(dev);
669 }
670 /* Clear the interrupts we've handled. */
671 outb(CR0_INT_ACK, ioaddr);
672 } while (boguscnt--);
673
674 spin_unlock (&znet->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400675
Linus Torvalds1da177e2005-04-16 15:20:36 -0700676 return IRQ_RETVAL(handled);
677}
678
679static void znet_rx(struct net_device *dev)
680{
Wang Chen524ad0a2008-11-12 23:39:10 -0800681 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682 int ioaddr = dev->base_addr;
683 int boguscount = 1;
684 short next_frame_end_offset = 0; /* Offset of next frame start. */
685 short *cur_frame_end;
686 short cur_frame_end_offset;
687
688 outb(CR0_STATUS_2, ioaddr);
689 cur_frame_end_offset = inw(ioaddr);
690
691 if (cur_frame_end_offset == znet->rx_cur - znet->rx_start) {
692 printk(KERN_WARNING "%s: Interrupted, but nothing to receive, offset %03x.\n",
693 dev->name, cur_frame_end_offset);
694 return;
695 }
696
697 /* Use same method as the Crynwr driver: construct a forward list in
698 the same area of the backwards links we now have. This allows us to
699 pass packets to the upper layers in the order they were received --
700 important for fast-path sequential operations. */
Joe Perches8e95a202009-12-03 07:58:21 +0000701 while (znet->rx_start + cur_frame_end_offset != znet->rx_cur &&
702 ++boguscount < 5) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 unsigned short hi_cnt, lo_cnt, hi_status, lo_status;
704 int count, status;
705
706 if (cur_frame_end_offset < 4) {
707 /* Oh no, we have a special case: the frame trailer wraps around
708 the end of the ring buffer. We've saved space at the end of
709 the ring buffer for just this problem. */
710 memcpy(znet->rx_end, znet->rx_start, 8);
711 cur_frame_end_offset += (RX_BUF_SIZE/2);
712 }
713 cur_frame_end = znet->rx_start + cur_frame_end_offset - 4;
714
715 lo_status = *cur_frame_end++;
716 hi_status = *cur_frame_end++;
717 status = ((hi_status & 0xff) << 8) + (lo_status & 0xff);
718 lo_cnt = *cur_frame_end++;
719 hi_cnt = *cur_frame_end++;
720 count = ((hi_cnt & 0xff) << 8) + (lo_cnt & 0xff);
721
722 if (znet_debug > 5)
723 printk(KERN_DEBUG "Constructing trailer at location %03x, %04x %04x %04x %04x"
724 " count %#x status %04x.\n",
725 cur_frame_end_offset<<1, lo_status, hi_status, lo_cnt, hi_cnt,
726 count, status);
727 cur_frame_end[-4] = status;
728 cur_frame_end[-3] = next_frame_end_offset;
729 cur_frame_end[-2] = count;
730 next_frame_end_offset = cur_frame_end_offset;
731 cur_frame_end_offset -= ((count + 1)>>1) + 3;
732 if (cur_frame_end_offset < 0)
733 cur_frame_end_offset += RX_BUF_SIZE/2;
734 };
735
736 /* Now step forward through the list. */
737 do {
738 ushort *this_rfp_ptr = znet->rx_start + next_frame_end_offset;
739 int status = this_rfp_ptr[-4];
740 int pkt_len = this_rfp_ptr[-2];
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400741
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742 if (znet_debug > 5)
743 printk(KERN_DEBUG "Looking at trailer ending at %04x status %04x length %03x"
744 " next %04x.\n", next_frame_end_offset<<1, status, pkt_len,
745 this_rfp_ptr[-3]<<1);
746 /* Once again we must assume that the i82586 docs apply. */
747 if ( ! (status & RX_RCV_OK)) { /* There was an error. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700748 dev->stats.rx_errors++;
749 if (status & RX_CRC_ERR) dev->stats.rx_crc_errors++;
750 if (status & RX_ALG_ERR) dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700751#if 0
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700752 if (status & 0x0200) dev->stats.rx_over_errors++; /* Wrong. */
753 if (status & 0x0100) dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754#else
755 /* maz : Wild guess... */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700756 if (status & RX_OVRRUN) dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757#endif
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700758 if (status & RX_SRT_FRM) dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700759 } else if (pkt_len > 1536) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700760 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 } else {
762 /* Malloc up new buffer. */
763 struct sk_buff *skb;
764
765 skb = dev_alloc_skb(pkt_len);
766 if (skb == NULL) {
767 if (znet_debug)
768 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700769 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700770 break;
771 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
773 if (&znet->rx_cur[(pkt_len+1)>>1] > znet->rx_end) {
774 int semi_cnt = (znet->rx_end - znet->rx_cur)<<1;
775 memcpy(skb_put(skb,semi_cnt), znet->rx_cur, semi_cnt);
776 memcpy(skb_put(skb,pkt_len-semi_cnt), znet->rx_start,
777 pkt_len - semi_cnt);
778 } else {
779 memcpy(skb_put(skb,pkt_len), znet->rx_cur, pkt_len);
780 if (znet_debug > 6) {
781 unsigned int *packet = (unsigned int *) skb->data;
782 printk(KERN_DEBUG "Packet data is %08x %08x %08x %08x.\n", packet[0],
783 packet[1], packet[2], packet[3]);
784 }
785 }
786 skb->protocol=eth_type_trans(skb,dev);
787 netif_rx(skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700788 dev->stats.rx_packets++;
789 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790 }
791 znet->rx_cur = this_rfp_ptr;
792 if (znet->rx_cur >= znet->rx_end)
793 znet->rx_cur -= RX_BUF_SIZE/2;
794 update_stop_hit(ioaddr, (znet->rx_cur - znet->rx_start)<<1);
795 next_frame_end_offset = this_rfp_ptr[-3];
796 if (next_frame_end_offset == 0) /* Read all the frames? */
797 break; /* Done for now */
798 this_rfp_ptr = znet->rx_start + next_frame_end_offset;
799 } while (--boguscount);
800
801 /* If any worth-while packets have been received, dev_rint()
802 has done a mark_bh(INET_BH) for us and will work on them
803 when we get to the bottom-half routine. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804}
805
806/* The inverse routine to znet_open(). */
807static int znet_close(struct net_device *dev)
808{
809 int ioaddr = dev->base_addr;
810
811 netif_stop_queue (dev);
812
813 outb(OP0_RESET, ioaddr); /* CMD0_RESET */
814
815 if (znet_debug > 1)
816 printk(KERN_DEBUG "%s: Shutting down ethercard.\n", dev->name);
817 /* Turn off transceiver power. */
818 znet_transceiver_power (dev, 0);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400819
Linus Torvalds1da177e2005-04-16 15:20:36 -0700820 znet_release_resources (dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400821
Linus Torvalds1da177e2005-04-16 15:20:36 -0700822 return 0;
823}
824
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825static void show_dma(struct net_device *dev)
826{
827 short ioaddr = dev->base_addr;
828 unsigned char stat = inb (ioaddr);
Wang Chen524ad0a2008-11-12 23:39:10 -0800829 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 unsigned long flags;
831 short dma_port = ((znet->tx_dma&3)<<2) + IO_DMA2_BASE;
832 unsigned addr = inb(dma_port);
833 short residue;
834
835 addr |= inb(dma_port) << 8;
836 residue = get_dma_residue(znet->tx_dma);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400837
Linus Torvalds1da177e2005-04-16 15:20:36 -0700838 if (znet_debug > 1) {
839 flags=claim_dma_lock();
840 printk(KERN_DEBUG "Stat:%02x Addr: %04x cnt:%3x\n",
841 stat, addr<<1, residue);
842 release_dma_lock(flags);
843 }
844}
845
846/* Initialize the hardware. We have to do this when the board is open()ed
847 or when we come out of suspend mode. */
848static void hardware_init(struct net_device *dev)
849{
850 unsigned long flags;
851 short ioaddr = dev->base_addr;
Wang Chen524ad0a2008-11-12 23:39:10 -0800852 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
854 znet->rx_cur = znet->rx_start;
855 znet->tx_cur = znet->tx_start;
856
857 /* Reset the chip, and start it up. */
858 outb(OP0_RESET, ioaddr);
859
860 flags=claim_dma_lock();
861 disable_dma(znet->rx_dma); /* reset by an interrupting task. */
862 clear_dma_ff(znet->rx_dma);
863 set_dma_mode(znet->rx_dma, DMA_RX_MODE);
864 set_dma_addr(znet->rx_dma, (unsigned int) znet->rx_start);
865 set_dma_count(znet->rx_dma, RX_BUF_SIZE);
866 enable_dma(znet->rx_dma);
867 /* Now set up the Tx channel. */
868 disable_dma(znet->tx_dma);
869 clear_dma_ff(znet->tx_dma);
870 set_dma_mode(znet->tx_dma, DMA_TX_MODE);
871 set_dma_addr(znet->tx_dma, (unsigned int) znet->tx_start);
872 set_dma_count(znet->tx_dma, znet->tx_buf_len<<1);
873 enable_dma(znet->tx_dma);
874 release_dma_lock(flags);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400875
Linus Torvalds1da177e2005-04-16 15:20:36 -0700876 if (znet_debug > 1)
877 printk(KERN_DEBUG "%s: Initializing the i82593, rx buf %p tx buf %p\n",
878 dev->name, znet->rx_start,znet->tx_start);
879 /* Do an empty configure command, just like the Crynwr driver. This
880 resets to chip to its default values. */
881 *znet->tx_cur++ = 0;
882 *znet->tx_cur++ = 0;
883 show_dma(dev);
884 outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
885
886 znet_set_multicast_list (dev);
887
888 *znet->tx_cur++ = 6;
889 memcpy(znet->tx_cur, dev->dev_addr, 6);
890 znet->tx_cur += 3;
891 show_dma(dev);
892 outb(OP0_IA_SETUP | CR0_CHNL, ioaddr);
893 show_dma(dev);
894
895 update_stop_hit(ioaddr, 8192);
896 if (znet_debug > 1) printk(KERN_DEBUG "enabling Rx.\n");
897 outb(OP0_RCV_ENABLE, ioaddr);
898 netif_start_queue (dev);
899}
900
901static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset)
902{
903 outb(OP0_SWIT_TO_PORT_1 | CR0_CHNL, ioaddr);
904 if (znet_debug > 5)
905 printk(KERN_DEBUG "Updating stop hit with value %02x.\n",
906 (rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE);
907 outb((rx_stop_offset >> 6) | CR1_STOP_REG_UPDATE, ioaddr);
908 outb(OP1_SWIT_TO_PORT_0, ioaddr);
909}
910
911static __exit void znet_cleanup (void)
912{
913 if (znet_dev) {
Wang Chen524ad0a2008-11-12 23:39:10 -0800914 struct znet_private *znet = netdev_priv(znet_dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700915
916 unregister_netdev (znet_dev);
917 kfree (znet->rx_start);
918 kfree (znet->tx_start);
919 free_netdev (znet_dev);
920 }
921}
922
923module_init (znet_probe);
924module_exit (znet_cleanup);