blob: bc5ae0f6e934f32ad6af763b556ff878e861276a [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>
91#include <linux/errno.h>
92#include <linux/interrupt.h>
93#include <linux/ioport.h>
94#include <linux/init.h>
95#include <linux/delay.h>
96#include <linux/netdevice.h>
97#include <linux/etherdevice.h>
98#include <linux/skbuff.h>
99#include <linux/if_arp.h>
100#include <linux/bitops.h>
101
102#include <asm/system.h>
103#include <asm/io.h>
104#include <asm/dma.h>
105
John W. Linvillec85e9d72009-11-17 10:16:32 -0500106#include <linux/i82593.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700107
108static char version[] __initdata = "znet.c:v1.02 9/23/94 becker@scyld.com\n";
109
110#ifndef ZNET_DEBUG
111#define ZNET_DEBUG 1
112#endif
113static unsigned int znet_debug = ZNET_DEBUG;
114module_param (znet_debug, int, 0);
115MODULE_PARM_DESC (znet_debug, "ZNet debug level");
116MODULE_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 10
127
128struct znet_private {
129 int rx_dma, tx_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 spinlock_t lock;
131 short sia_base, sia_size, io_size;
132 struct i82593_conf_block i593_init;
133 /* The starting, current, and end pointers for the packet buffers. */
134 ushort *rx_start, *rx_cur, *rx_end;
135 ushort *tx_start, *tx_cur, *tx_end;
136 ushort tx_buf_len; /* Tx buffer length, in words. */
137};
138
139/* Only one can be built-in;-> */
140static struct net_device *znet_dev;
141
142struct netidblk {
143 char magic[8]; /* The magic number (string) "NETIDBLK" */
144 unsigned char netid[8]; /* The physical station address */
145 char nettype, globalopt;
146 char vendor[8]; /* The machine vendor and product name. */
147 char product[8];
148 char irq1, irq2; /* Interrupts, only one is currently used. */
149 char dma1, dma2;
150 short dma_mem_misc[8]; /* DMA buffer locations (unused in Linux). */
151 short iobase1, iosize1;
152 short iobase2, iosize2; /* Second iobase unused. */
153 char driver_options; /* Misc. bits */
154 char pad;
155};
156
157static int znet_open(struct net_device *dev);
Stephen Hemminger613573252009-08-31 19:50:58 +0000158static netdev_tx_t znet_send_packet(struct sk_buff *skb,
159 struct net_device *dev);
David Howells7d12e782006-10-05 14:55:46 +0100160static irqreturn_t znet_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700161static void znet_rx(struct net_device *dev);
162static int znet_close(struct net_device *dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163static void hardware_init(struct net_device *dev);
164static void update_stop_hit(short ioaddr, unsigned short rx_stop_offset);
165static void znet_tx_timeout (struct net_device *dev);
166
167/* Request needed resources */
168static int znet_request_resources (struct net_device *dev)
169{
Wang Chen524ad0a2008-11-12 23:39:10 -0800170 struct znet_private *znet = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400171
Joe Perchesa0607fd2009-11-18 23:29:17 -0800172 if (request_irq (dev->irq, znet_interrupt, 0, "ZNet", dev))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173 goto failed;
174 if (request_dma (znet->rx_dma, "ZNet rx"))
175 goto free_irq;
176 if (request_dma (znet->tx_dma, "ZNet tx"))
177 goto free_rx_dma;
178 if (!request_region (znet->sia_base, znet->sia_size, "ZNet SIA"))
179 goto free_tx_dma;
180 if (!request_region (dev->base_addr, znet->io_size, "ZNet I/O"))
181 goto free_sia;
182
183 return 0; /* Happy ! */
184
185 free_sia:
186 release_region (znet->sia_base, znet->sia_size);
187 free_tx_dma:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188 free_dma (znet->tx_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700189 free_rx_dma:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700190 free_dma (znet->rx_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700191 free_irq:
192 free_irq (dev->irq, dev);
193 failed:
194 return -1;
195}
196
197static void znet_release_resources (struct net_device *dev)
198{
Wang Chen524ad0a2008-11-12 23:39:10 -0800199 struct znet_private *znet = netdev_priv(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400200
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 release_region (znet->sia_base, znet->sia_size);
202 release_region (dev->base_addr, znet->io_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700203 free_dma (znet->tx_dma);
204 free_dma (znet->rx_dma);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700205 free_irq (dev->irq, dev);
206}
207
208/* Keep the magical SIA stuff in a single function... */
209static void znet_transceiver_power (struct net_device *dev, int on)
210{
Wang Chen524ad0a2008-11-12 23:39:10 -0800211 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700212 unsigned char v;
213
214 /* Turn on/off the 82501 SIA, using zenith-specific magic. */
215 /* Select LAN control register */
216 outb(0x10, znet->sia_base);
217
218 if (on)
219 v = inb(znet->sia_base + 1) | 0x84;
220 else
221 v = inb(znet->sia_base + 1) & ~0x84;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400222
Linus Torvalds1da177e2005-04-16 15:20:36 -0700223 outb(v, znet->sia_base+1); /* Turn on/off LAN power (bit 2). */
224}
225
226/* Init the i82593, with current promisc/mcast configuration.
227 Also used from hardware_init. */
228static void znet_set_multicast_list (struct net_device *dev)
229{
Wang Chen524ad0a2008-11-12 23:39:10 -0800230 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700231 short ioaddr = dev->base_addr;
232 struct i82593_conf_block *cfblk = &znet->i593_init;
233
234 memset(cfblk, 0x00, sizeof(struct i82593_conf_block));
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400235
Linus Torvalds1da177e2005-04-16 15:20:36 -0700236 /* The configuration block. What an undocumented nightmare.
237 The first set of values are those suggested (without explanation)
238 for ethernet in the Intel 82586 databook. The rest appear to be
239 completely undocumented, except for cryptic notes in the Crynwr
240 packet driver. This driver uses the Crynwr values verbatim. */
241
242 /* maz : Rewritten to take advantage of the wanvelan includes.
243 At least we have names, not just blind values */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400244
Linus Torvalds1da177e2005-04-16 15:20:36 -0700245 /* Byte 0 */
246 cfblk->fifo_limit = 10; /* = 16 B rx and 80 B tx fifo thresholds */
247 cfblk->forgnesi = 0; /* 0=82C501, 1=AMD7992B compatibility */
248 cfblk->fifo_32 = 1;
249 cfblk->d6mod = 0; /* Run in i82593 advanced mode */
250 cfblk->throttle_enb = 1;
251
252 /* Byte 1 */
253 cfblk->throttle = 8; /* Continuous w/interrupts, 128-clock DMA. */
254 cfblk->cntrxint = 0; /* enable continuous mode receive interrupts */
255 cfblk->contin = 1; /* enable continuous mode */
256
257 /* Byte 2 */
258 cfblk->addr_len = ETH_ALEN;
259 cfblk->acloc = 1; /* Disable source addr insertion by i82593 */
260 cfblk->preamb_len = 2; /* 8 bytes preamble */
261 cfblk->loopback = 0; /* Loopback off */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400262
Linus Torvalds1da177e2005-04-16 15:20:36 -0700263 /* Byte 3 */
264 cfblk->lin_prio = 0; /* Default priorities & backoff methods. */
265 cfblk->tbofstop = 0;
266 cfblk->exp_prio = 0;
267 cfblk->bof_met = 0;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400268
Linus Torvalds1da177e2005-04-16 15:20:36 -0700269 /* Byte 4 */
270 cfblk->ifrm_spc = 6; /* 96 bit times interframe spacing */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400271
Linus Torvalds1da177e2005-04-16 15:20:36 -0700272 /* Byte 5 */
273 cfblk->slottim_low = 0; /* 512 bit times slot time (low) */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400274
Linus Torvalds1da177e2005-04-16 15:20:36 -0700275 /* Byte 6 */
276 cfblk->slottim_hi = 2; /* 512 bit times slot time (high) */
277 cfblk->max_retr = 15; /* 15 collisions retries */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400278
Linus Torvalds1da177e2005-04-16 15:20:36 -0700279 /* Byte 7 */
280 cfblk->prmisc = ((dev->flags & IFF_PROMISC) ? 1 : 0); /* Promiscuous mode */
281 cfblk->bc_dis = 0; /* Enable broadcast reception */
282 cfblk->crs_1 = 0; /* Don't transmit without carrier sense */
283 cfblk->nocrc_ins = 0; /* i82593 generates CRC */
284 cfblk->crc_1632 = 0; /* 32-bit Autodin-II CRC */
285 cfblk->crs_cdt = 0; /* CD not to be interpreted as CS */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400286
Linus Torvalds1da177e2005-04-16 15:20:36 -0700287 /* Byte 8 */
288 cfblk->cs_filter = 0; /* CS is recognized immediately */
289 cfblk->crs_src = 0; /* External carrier sense */
290 cfblk->cd_filter = 0; /* CD is recognized immediately */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400291
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292 /* Byte 9 */
293 cfblk->min_fr_len = ETH_ZLEN >> 2; /* Minimum frame length */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400294
Linus Torvalds1da177e2005-04-16 15:20:36 -0700295 /* Byte A */
296 cfblk->lng_typ = 1; /* Type/length checks OFF */
297 cfblk->lng_fld = 1; /* Disable 802.3 length field check */
298 cfblk->rxcrc_xf = 1; /* Don't transfer CRC to memory */
299 cfblk->artx = 1; /* Disable automatic retransmission */
300 cfblk->sarec = 1; /* Disable source addr trig of CD */
301 cfblk->tx_jabber = 0; /* Disable jabber jam sequence */
302 cfblk->hash_1 = 1; /* Use bits 0-5 in mc address hash */
303 cfblk->lbpkpol = 0; /* Loopback pin active high */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400304
Linus Torvalds1da177e2005-04-16 15:20:36 -0700305 /* Byte B */
306 cfblk->fdx = 0; /* Disable full duplex operation */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400307
Linus Torvalds1da177e2005-04-16 15:20:36 -0700308 /* Byte C */
309 cfblk->dummy_6 = 0x3f; /* all ones, Default multicast addresses & backoff. */
310 cfblk->mult_ia = 0; /* No multiple individual addresses */
311 cfblk->dis_bof = 0; /* Disable the backoff algorithm ?! */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400312
Linus Torvalds1da177e2005-04-16 15:20:36 -0700313 /* Byte D */
314 cfblk->dummy_1 = 1; /* set to 1 */
315 cfblk->tx_ifs_retrig = 3; /* Hmm... Disabled */
316 cfblk->mc_all = (dev->mc_list || (dev->flags&IFF_ALLMULTI));/* multicast all mode */
317 cfblk->rcv_mon = 0; /* Monitor mode disabled */
318 cfblk->frag_acpt = 0; /* Do not accept fragments */
319 cfblk->tstrttrs = 0; /* No start transmission threshold */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400320
Linus Torvalds1da177e2005-04-16 15:20:36 -0700321 /* Byte E */
322 cfblk->fretx = 1; /* FIFO automatic retransmission */
323 cfblk->runt_eop = 0; /* drop "runt" packets */
324 cfblk->hw_sw_pin = 0; /* ?? */
325 cfblk->big_endn = 0; /* Big Endian ? no... */
326 cfblk->syncrqs = 1; /* Synchronous DRQ deassertion... */
327 cfblk->sttlen = 1; /* 6 byte status registers */
328 cfblk->rx_eop = 0; /* Signal EOP on packet reception */
329 cfblk->tx_eop = 0; /* Signal EOP on packet transmission */
330
331 /* Byte F */
332 cfblk->rbuf_size = RX_BUF_SIZE >> 12; /* Set receive buffer size */
333 cfblk->rcvstop = 1; /* Enable Receive Stop Register */
334
335 if (znet_debug > 2) {
336 int i;
337 unsigned char *c;
338
339 for (i = 0, c = (char *) cfblk; i < sizeof (*cfblk); i++)
340 printk ("%02X ", c[i]);
341 printk ("\n");
342 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400343
Linus Torvalds1da177e2005-04-16 15:20:36 -0700344 *znet->tx_cur++ = sizeof(struct i82593_conf_block);
345 memcpy(znet->tx_cur, cfblk, sizeof(struct i82593_conf_block));
346 znet->tx_cur += sizeof(struct i82593_conf_block)/2;
347 outb(OP0_CONFIGURE | CR0_CHNL, ioaddr);
348
349 /* XXX FIXME maz : Add multicast addresses here, so having a
350 * multicast address configured isn't equal to IFF_ALLMULTI */
351}
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400352
Stephen Hemmingerbc0443f2009-01-09 13:01:27 +0000353static const struct net_device_ops znet_netdev_ops = {
354 .ndo_open = znet_open,
355 .ndo_stop = znet_close,
356 .ndo_start_xmit = znet_send_packet,
357 .ndo_set_multicast_list = znet_set_multicast_list,
358 .ndo_tx_timeout = znet_tx_timeout,
359 .ndo_change_mtu = eth_change_mtu,
360 .ndo_set_mac_address = eth_mac_addr,
361 .ndo_validate_addr = eth_validate_addr,
362};
363
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364/* The Z-Note probe is pretty easy. The NETIDBLK exists in the safe-to-probe
365 BIOS area. We just scan for the signature, and pull the vital parameters
366 out of the structure. */
367
368static int __init znet_probe (void)
369{
370 int i;
371 struct netidblk *netinfo;
372 struct znet_private *znet;
373 struct net_device *dev;
374 char *p;
375 int err = -ENOMEM;
376
377 /* This code scans the region 0xf0000 to 0xfffff for a "NETIDBLK". */
378 for(p = (char *)phys_to_virt(0xf0000); p < (char *)phys_to_virt(0x100000); p++)
379 if (*p == 'N' && strncmp(p, "NETIDBLK", 8) == 0)
380 break;
381
382 if (p >= (char *)phys_to_virt(0x100000)) {
383 if (znet_debug > 1)
384 printk(KERN_INFO "No Z-Note ethernet adaptor found.\n");
385 return -ENODEV;
386 }
387
388 dev = alloc_etherdev(sizeof(struct znet_private));
389 if (!dev)
390 return -ENOMEM;
391
Wang Chen524ad0a2008-11-12 23:39:10 -0800392 znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
394 netinfo = (struct netidblk *)p;
395 dev->base_addr = netinfo->iobase1;
396 dev->irq = netinfo->irq1;
397
Linus Torvalds1da177e2005-04-16 15:20:36 -0700398 /* The station address is in the "netidblk" at 0x0f0000. */
399 for (i = 0; i < 6; i++)
Joe Perches0795af52007-10-03 17:59:30 -0700400 dev->dev_addr[i] = netinfo->netid[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -0700401
Johannes Berge1749612008-10-27 15:59:26 -0700402 printk(KERN_INFO "%s: ZNET at %#3lx, %pM"
Joe Perches0795af52007-10-03 17:59:30 -0700403 ", using IRQ %d DMA %d and %d.\n",
Johannes Berge1749612008-10-27 15:59:26 -0700404 dev->name, dev->base_addr, dev->dev_addr,
Joe Perches0795af52007-10-03 17:59:30 -0700405 dev->irq, netinfo->dma1, netinfo->dma2);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700406
407 if (znet_debug > 1) {
408 printk(KERN_INFO "%s: vendor '%16.16s' IRQ1 %d IRQ2 %d DMA1 %d DMA2 %d.\n",
409 dev->name, netinfo->vendor,
410 netinfo->irq1, netinfo->irq2,
411 netinfo->dma1, netinfo->dma2);
412 printk(KERN_INFO "%s: iobase1 %#x size %d iobase2 %#x size %d net type %2.2x.\n",
413 dev->name, netinfo->iobase1, netinfo->iosize1,
414 netinfo->iobase2, netinfo->iosize2, netinfo->nettype);
415 }
416
417 if (znet_debug > 0)
418 printk(KERN_INFO "%s", version);
419
420 znet->rx_dma = netinfo->dma1;
421 znet->tx_dma = netinfo->dma2;
422 spin_lock_init(&znet->lock);
423 znet->sia_base = 0xe6; /* Magic address for the 82501 SIA */
424 znet->sia_size = 2;
425 /* maz: Despite the '593 being advertised above as using a
426 * single 8bits I/O port, this driver does many 16bits
427 * access. So set io_size accordingly */
428 znet->io_size = 2;
429
430 if (!(znet->rx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
431 goto free_dev;
432 if (!(znet->tx_start = kmalloc (DMA_BUF_SIZE, GFP_KERNEL | GFP_DMA)))
433 goto free_rx;
434
435 if (!dma_page_eq (znet->rx_start, znet->rx_start + (RX_BUF_SIZE/2-1)) ||
436 !dma_page_eq (znet->tx_start, znet->tx_start + (TX_BUF_SIZE/2-1))) {
437 printk (KERN_WARNING "tx/rx crossing DMA frontiers, giving up\n");
438 goto free_tx;
439 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400440
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441 znet->rx_end = znet->rx_start + RX_BUF_SIZE/2;
442 znet->tx_buf_len = TX_BUF_SIZE/2;
443 znet->tx_end = znet->tx_start + znet->tx_buf_len;
444
445 /* The ZNET-specific entries in the device structure. */
Stephen Hemmingerbc0443f2009-01-09 13:01:27 +0000446 dev->netdev_ops = &znet_netdev_ops;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700447 dev->watchdog_timeo = TX_TIMEOUT;
448 err = register_netdev(dev);
449 if (err)
450 goto free_tx;
451 znet_dev = dev;
452 return 0;
453
454 free_tx:
455 kfree(znet->tx_start);
456 free_rx:
457 kfree(znet->rx_start);
458 free_dev:
459 free_netdev(dev);
460 return err;
461}
462
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400463
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464static int znet_open(struct net_device *dev)
465{
466 int ioaddr = dev->base_addr;
467
468 if (znet_debug > 2)
469 printk(KERN_DEBUG "%s: znet_open() called.\n", dev->name);
470
471 /* These should never fail. You can't add devices to a sealed box! */
472 if (znet_request_resources (dev)) {
473 printk(KERN_WARNING "%s: Not opened -- resource busy?!?\n", dev->name);
474 return -EBUSY;
475 }
476
477 znet_transceiver_power (dev, 1);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400478
Linus Torvalds1da177e2005-04-16 15:20:36 -0700479 /* According to the Crynwr driver we should wait 50 msec. for the
480 LAN clock to stabilize. My experiments indicates that the '593 can
481 be initialized immediately. The delay is probably needed for the
482 DC-to-DC converter to come up to full voltage, and for the oscillator
483 to be spot-on at 20Mhz before transmitting.
484 Until this proves to be a problem we rely on the higher layers for the
485 delay and save allocating a timer entry. */
486
487 /* maz : Well, I'm getting every time the following message
488 * without the delay on a 486@33. This machine is much too
489 * fast... :-) So maybe the Crynwr driver wasn't wrong after
490 * all, even if the message is completly harmless on my
491 * setup. */
492 mdelay (50);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400493
Linus Torvalds1da177e2005-04-16 15:20:36 -0700494 /* This follows the packet driver's lead, and checks for success. */
495 if (inb(ioaddr) != 0x10 && inb(ioaddr) != 0x00)
496 printk(KERN_WARNING "%s: Problem turning on the transceiver power.\n",
497 dev->name);
498
499 hardware_init(dev);
500 netif_start_queue (dev);
501
502 return 0;
503}
504
505
506static void znet_tx_timeout (struct net_device *dev)
507{
508 int ioaddr = dev->base_addr;
509 ushort event, tx_status, rx_offset, state;
510
511 outb (CR0_STATUS_0, ioaddr);
512 event = inb (ioaddr);
513 outb (CR0_STATUS_1, ioaddr);
514 tx_status = inw (ioaddr);
515 outb (CR0_STATUS_2, ioaddr);
516 rx_offset = inw (ioaddr);
517 outb (CR0_STATUS_3, ioaddr);
518 state = inb (ioaddr);
519 printk (KERN_WARNING "%s: transmit timed out, status %02x %04x %04x %02x,"
520 " resetting.\n", dev->name, event, tx_status, rx_offset, state);
521 if (tx_status == TX_LOST_CRS)
522 printk (KERN_WARNING "%s: Tx carrier error, check transceiver cable.\n",
523 dev->name);
524 outb (OP0_RESET, ioaddr);
525 hardware_init (dev);
526 netif_wake_queue (dev);
527}
528
Stephen Hemminger613573252009-08-31 19:50:58 +0000529static netdev_tx_t znet_send_packet(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530{
531 int ioaddr = dev->base_addr;
Wang Chen524ad0a2008-11-12 23:39:10 -0800532 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700533 unsigned long flags;
534 short length = skb->len;
535
536 if (znet_debug > 4)
537 printk(KERN_DEBUG "%s: ZNet_send_packet.\n", dev->name);
538
539 if (length < ETH_ZLEN) {
Herbert Xu5b057c62006-06-23 02:06:41 -0700540 if (skb_padto(skb, ETH_ZLEN))
Patrick McHardy6ed10652009-06-23 06:03:08 +0000541 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700542 length = ETH_ZLEN;
543 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400544
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545 netif_stop_queue (dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400546
Linus Torvalds1da177e2005-04-16 15:20:36 -0700547 /* Check that the part hasn't reset itself, probably from suspend. */
548 outb(CR0_STATUS_0, ioaddr);
549 if (inw(ioaddr) == 0x0010 &&
550 inw(ioaddr) == 0x0000 &&
551 inw(ioaddr) == 0x0010) {
552 if (znet_debug > 1)
553 printk (KERN_WARNING "%s : waking up\n", dev->name);
554 hardware_init(dev);
555 znet_transceiver_power (dev, 1);
556 }
557
558 if (1) {
559 unsigned char *buf = (void *)skb->data;
560 ushort *tx_link = znet->tx_cur - 1;
561 ushort rnd_len = (length + 1)>>1;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400562
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700563 dev->stats.tx_bytes+=length;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700564
565 if (znet->tx_cur >= znet->tx_end)
566 znet->tx_cur = znet->tx_start;
567 *znet->tx_cur++ = length;
568 if (znet->tx_cur + rnd_len + 1 > znet->tx_end) {
569 int semi_cnt = (znet->tx_end - znet->tx_cur)<<1; /* Cvrt to byte cnt. */
570 memcpy(znet->tx_cur, buf, semi_cnt);
571 rnd_len -= semi_cnt>>1;
572 memcpy(znet->tx_start, buf + semi_cnt, length - semi_cnt);
573 znet->tx_cur = znet->tx_start + rnd_len;
574 } else {
575 memcpy(znet->tx_cur, buf, skb->len);
576 znet->tx_cur += rnd_len;
577 }
578 *znet->tx_cur++ = 0;
579
580 spin_lock_irqsave(&znet->lock, flags);
581 {
582 *tx_link = OP0_TRANSMIT | CR0_CHNL;
583 /* Is this always safe to do? */
584 outb(OP0_TRANSMIT | CR0_CHNL, ioaddr);
585 }
586 spin_unlock_irqrestore (&znet->lock, flags);
587
588 dev->trans_start = jiffies;
589 netif_start_queue (dev);
590
591 if (znet_debug > 4)
592 printk(KERN_DEBUG "%s: Transmitter queued, length %d.\n", dev->name, length);
593 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400594 dev_kfree_skb(skb);
Patrick McHardy6ed10652009-06-23 06:03:08 +0000595 return NETDEV_TX_OK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596}
597
598/* The ZNET interrupt handler. */
David Howells7d12e782006-10-05 14:55:46 +0100599static irqreturn_t znet_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600{
601 struct net_device *dev = dev_id;
Wang Chen524ad0a2008-11-12 23:39:10 -0800602 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700603 int ioaddr;
604 int boguscnt = 20;
605 int handled = 0;
606
Linus Torvalds1da177e2005-04-16 15:20:36 -0700607 spin_lock (&znet->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400608
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 ioaddr = dev->base_addr;
610
611 outb(CR0_STATUS_0, ioaddr);
612 do {
613 ushort status = inb(ioaddr);
614 if (znet_debug > 5) {
615 ushort result, rx_ptr, running;
616 outb(CR0_STATUS_1, ioaddr);
617 result = inw(ioaddr);
618 outb(CR0_STATUS_2, ioaddr);
619 rx_ptr = inw(ioaddr);
620 outb(CR0_STATUS_3, ioaddr);
621 running = inb(ioaddr);
622 printk(KERN_DEBUG "%s: interrupt, status %02x, %04x %04x %02x serial %d.\n",
623 dev->name, status, result, rx_ptr, running, boguscnt);
624 }
625 if ((status & SR0_INTERRUPT) == 0)
626 break;
627
628 handled = 1;
629
630 if ((status & SR0_EVENT_MASK) == SR0_TRANSMIT_DONE ||
631 (status & SR0_EVENT_MASK) == SR0_RETRANSMIT_DONE ||
632 (status & SR0_EVENT_MASK) == SR0_TRANSMIT_NO_CRC_DONE) {
633 int tx_status;
634 outb(CR0_STATUS_1, ioaddr);
635 tx_status = inw(ioaddr);
636 /* It's undocumented, but tx_status seems to match the i82586. */
637 if (tx_status & TX_OK) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700638 dev->stats.tx_packets++;
639 dev->stats.collisions += tx_status & TX_NCOL_MASK;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700640 } else {
641 if (tx_status & (TX_LOST_CTS | TX_LOST_CRS))
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700642 dev->stats.tx_carrier_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700643 if (tx_status & TX_UND_RUN)
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700644 dev->stats.tx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700645 if (!(tx_status & TX_HRT_BEAT))
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700646 dev->stats.tx_heartbeat_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700647 if (tx_status & TX_MAX_COL)
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700648 dev->stats.tx_aborted_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 /* ...and the catch-all. */
650 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 -0700651 dev->stats.tx_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700652
653 /* Transceiver may be stuck if cable
654 * was removed while emiting a
655 * packet. Flip it off, then on to
656 * reset it. This is very empirical,
657 * but it seems to work. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400658
Linus Torvalds1da177e2005-04-16 15:20:36 -0700659 znet_transceiver_power (dev, 0);
660 znet_transceiver_power (dev, 1);
661 }
662 netif_wake_queue (dev);
663 }
664
665 if ((status & SR0_RECEPTION) ||
666 (status & SR0_EVENT_MASK) == SR0_STOP_REG_HIT) {
667 znet_rx(dev);
668 }
669 /* Clear the interrupts we've handled. */
670 outb(CR0_INT_ACK, ioaddr);
671 } while (boguscnt--);
672
673 spin_unlock (&znet->lock);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400674
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675 return IRQ_RETVAL(handled);
676}
677
678static void znet_rx(struct net_device *dev)
679{
Wang Chen524ad0a2008-11-12 23:39:10 -0800680 struct znet_private *znet = netdev_priv(dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681 int ioaddr = dev->base_addr;
682 int boguscount = 1;
683 short next_frame_end_offset = 0; /* Offset of next frame start. */
684 short *cur_frame_end;
685 short cur_frame_end_offset;
686
687 outb(CR0_STATUS_2, ioaddr);
688 cur_frame_end_offset = inw(ioaddr);
689
690 if (cur_frame_end_offset == znet->rx_cur - znet->rx_start) {
691 printk(KERN_WARNING "%s: Interrupted, but nothing to receive, offset %03x.\n",
692 dev->name, cur_frame_end_offset);
693 return;
694 }
695
696 /* Use same method as the Crynwr driver: construct a forward list in
697 the same area of the backwards links we now have. This allows us to
698 pass packets to the upper layers in the order they were received --
699 important for fast-path sequential operations. */
Joe Perches8e95a202009-12-03 07:58:21 +0000700 while (znet->rx_start + cur_frame_end_offset != znet->rx_cur &&
701 ++boguscount < 5) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700702 unsigned short hi_cnt, lo_cnt, hi_status, lo_status;
703 int count, status;
704
705 if (cur_frame_end_offset < 4) {
706 /* Oh no, we have a special case: the frame trailer wraps around
707 the end of the ring buffer. We've saved space at the end of
708 the ring buffer for just this problem. */
709 memcpy(znet->rx_end, znet->rx_start, 8);
710 cur_frame_end_offset += (RX_BUF_SIZE/2);
711 }
712 cur_frame_end = znet->rx_start + cur_frame_end_offset - 4;
713
714 lo_status = *cur_frame_end++;
715 hi_status = *cur_frame_end++;
716 status = ((hi_status & 0xff) << 8) + (lo_status & 0xff);
717 lo_cnt = *cur_frame_end++;
718 hi_cnt = *cur_frame_end++;
719 count = ((hi_cnt & 0xff) << 8) + (lo_cnt & 0xff);
720
721 if (znet_debug > 5)
722 printk(KERN_DEBUG "Constructing trailer at location %03x, %04x %04x %04x %04x"
723 " count %#x status %04x.\n",
724 cur_frame_end_offset<<1, lo_status, hi_status, lo_cnt, hi_cnt,
725 count, status);
726 cur_frame_end[-4] = status;
727 cur_frame_end[-3] = next_frame_end_offset;
728 cur_frame_end[-2] = count;
729 next_frame_end_offset = cur_frame_end_offset;
730 cur_frame_end_offset -= ((count + 1)>>1) + 3;
731 if (cur_frame_end_offset < 0)
732 cur_frame_end_offset += RX_BUF_SIZE/2;
733 };
734
735 /* Now step forward through the list. */
736 do {
737 ushort *this_rfp_ptr = znet->rx_start + next_frame_end_offset;
738 int status = this_rfp_ptr[-4];
739 int pkt_len = this_rfp_ptr[-2];
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400740
Linus Torvalds1da177e2005-04-16 15:20:36 -0700741 if (znet_debug > 5)
742 printk(KERN_DEBUG "Looking at trailer ending at %04x status %04x length %03x"
743 " next %04x.\n", next_frame_end_offset<<1, status, pkt_len,
744 this_rfp_ptr[-3]<<1);
745 /* Once again we must assume that the i82586 docs apply. */
746 if ( ! (status & RX_RCV_OK)) { /* There was an error. */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700747 dev->stats.rx_errors++;
748 if (status & RX_CRC_ERR) dev->stats.rx_crc_errors++;
749 if (status & RX_ALG_ERR) dev->stats.rx_frame_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700750#if 0
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700751 if (status & 0x0200) dev->stats.rx_over_errors++; /* Wrong. */
752 if (status & 0x0100) dev->stats.rx_fifo_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700753#else
754 /* maz : Wild guess... */
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700755 if (status & RX_OVRRUN) dev->stats.rx_over_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756#endif
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700757 if (status & RX_SRT_FRM) dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758 } else if (pkt_len > 1536) {
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700759 dev->stats.rx_length_errors++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760 } else {
761 /* Malloc up new buffer. */
762 struct sk_buff *skb;
763
764 skb = dev_alloc_skb(pkt_len);
765 if (skb == NULL) {
766 if (znet_debug)
767 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700768 dev->stats.rx_dropped++;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700769 break;
770 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700771
772 if (&znet->rx_cur[(pkt_len+1)>>1] > znet->rx_end) {
773 int semi_cnt = (znet->rx_end - znet->rx_cur)<<1;
774 memcpy(skb_put(skb,semi_cnt), znet->rx_cur, semi_cnt);
775 memcpy(skb_put(skb,pkt_len-semi_cnt), znet->rx_start,
776 pkt_len - semi_cnt);
777 } else {
778 memcpy(skb_put(skb,pkt_len), znet->rx_cur, pkt_len);
779 if (znet_debug > 6) {
780 unsigned int *packet = (unsigned int *) skb->data;
781 printk(KERN_DEBUG "Packet data is %08x %08x %08x %08x.\n", packet[0],
782 packet[1], packet[2], packet[3]);
783 }
784 }
785 skb->protocol=eth_type_trans(skb,dev);
786 netif_rx(skb);
Jeff Garzik09f75cd2007-10-03 17:41:50 -0700787 dev->stats.rx_packets++;
788 dev->stats.rx_bytes += pkt_len;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700789 }
790 znet->rx_cur = this_rfp_ptr;
791 if (znet->rx_cur >= znet->rx_end)
792 znet->rx_cur -= RX_BUF_SIZE/2;
793 update_stop_hit(ioaddr, (znet->rx_cur - znet->rx_start)<<1);
794 next_frame_end_offset = this_rfp_ptr[-3];
795 if (next_frame_end_offset == 0) /* Read all the frames? */
796 break; /* Done for now */
797 this_rfp_ptr = znet->rx_start + next_frame_end_offset;
798 } while (--boguscount);
799
800 /* If any worth-while packets have been received, dev_rint()
801 has done a mark_bh(INET_BH) for us and will work on them
802 when we get to the bottom-half routine. */
803 return;
804}
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);