1 /* mac89x0.c: A Crystal Semiconductor CS89[02]0 driver for linux. */
2 /*
3 	Written 1996 by Russell Nelson, with reference to skeleton.c
4 	written 1993-1994 by Donald Becker.
5 
6 	This software may be used and distributed according to the terms
7 	of the GNU General Public License, incorporated herein by reference.
8 
9 	The author may be reached at nelson@crynwr.com, Crynwr
10 	Software, 11 Grant St., Potsdam, NY 13676
11 
12   Changelog:
13 
14   Mike Cruse        : mcruse@cti-ltd.com
15                     : Changes for Linux 2.0 compatibility.
16                     : Added dev_id parameter in net_interrupt(),
17                     : request_irq() and free_irq(). Just NULL for now.
18 
19   Mike Cruse        : Added MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros
20                     : in net_open() and net_close() so kerneld would know
21                     : that the module is in use and wouldn't eject the
22                     : driver prematurely.
23 
24   Mike Cruse        : Rewrote init_module() and cleanup_module using 8390.c
25                     : as an example. Disabled autoprobing in init_module(),
26                     : not a good thing to do to other devices while Linux
27                     : is running from all accounts.
28 
29   Alan Cox          : Removed 1.2 support, added 2.1 extra counters.
30 
31   David Huggins-Daines <dhd@debian.org>
32 
33   Split this off into mac89x0.c, and gutted it of all parts which are
34   not relevant to the existing CS8900 cards on the Macintosh
35   (i.e. basically the Daynaport CS and LC cards).  To be precise:
36 
37     * Removed all the media-detection stuff, because these cards are
38     TP-only.
39 
40     * Lobotomized the ISA interrupt bogosity, because these cards use
41     a hardwired NuBus interrupt and a magic ISAIRQ value in the card.
42 
43     * Basically eliminated everything not relevant to getting the
44     cards minimally functioning on the Macintosh.
45 
46   I might add that these cards are badly designed even from the Mac
47   standpoint, in that Dayna, in their infinite wisdom, used NuBus slot
48   I/O space and NuBus interrupts for these cards, but neglected to
49   provide anything even remotely resembling a NuBus ROM.  Therefore we
50   have to probe for them in a brain-damaged ISA-like fashion.
51 
52   Arnaldo Carvalho de Melo <acme@conectiva.com.br> - 11/01/2001
53   check kmalloc and release the allocated memory on failure in
54   mac89x0_probe and in init_module
55   use local_irq_{save,restore}(flags) in net_get_stat, not just
56   local_irq_{dis,en}able()
57 */
58 
59 static char *version =
60 "cs89x0.c:v1.02 11/26/96 Russell Nelson <nelson@crynwr.com>\n";
61 
62 /* ======================= configure the driver here ======================= */
63 
64 /* use 0 for production, 1 for verification, >2 for debug */
65 #ifndef NET_DEBUG
66 #define NET_DEBUG 0
67 #endif
68 
69 /* ======================= end of configuration ======================= */
70 
71 
72 /* Always include 'config.h' first in case the user wants to turn on
73    or override something. */
74 #include <linux/module.h>
75 
76 /*
77   Sources:
78 
79 	Crynwr packet driver epktisa.
80 
81 	Crystal Semiconductor data sheets.
82 
83 */
84 
85 #include <linux/kernel.h>
86 #include <linux/types.h>
87 #include <linux/fcntl.h>
88 #include <linux/interrupt.h>
89 #include <linux/ioport.h>
90 #include <linux/in.h>
91 #include <linux/string.h>
92 #include <linux/nubus.h>
93 #include <linux/errno.h>
94 #include <linux/init.h>
95 #include <linux/netdevice.h>
96 #include <linux/etherdevice.h>
97 #include <linux/skbuff.h>
98 #include <linux/delay.h>
99 #include <linux/bitops.h>
100 #include <linux/gfp.h>
101 
102 #include <asm/io.h>
103 #include <asm/hwtest.h>
104 #include <asm/macints.h>
105 
106 #include "cs89x0.h"
107 
108 static unsigned int net_debug = NET_DEBUG;
109 
110 /* Information that need to be kept for each board. */
111 struct net_local {
112 	int chip_type;		/* one of: CS8900, CS8920, CS8920M */
113 	char chip_revision;	/* revision letter of the chip ('A'...) */
114 	int send_cmd;		/* the propercommand used to send a packet. */
115 	int rx_mode;
116 	int curr_rx_cfg;
117         int send_underrun;      /* keep track of how many underruns in a row we get */
118 	struct sk_buff *skb;
119 };
120 
121 /* Index to functions, as function prototypes. */
122 
123 #if 0
124 extern void reset_chip(struct net_device *dev);
125 #endif
126 static int net_open(struct net_device *dev);
127 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
128 static irqreturn_t net_interrupt(int irq, void *dev_id);
129 static void set_multicast_list(struct net_device *dev);
130 static void net_rx(struct net_device *dev);
131 static int net_close(struct net_device *dev);
132 static struct net_device_stats *net_get_stats(struct net_device *dev);
133 static int set_mac_address(struct net_device *dev, void *addr);
134 
135 
136 /* Example routines you must write ;->. */
137 #define tx_done(dev) 1
138 
139 /* For reading/writing registers ISA-style */
140 static inline int
141 readreg_io(struct net_device *dev, int portno)
142 {
143 	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
144 	return swab16(nubus_readw(dev->base_addr + DATA_PORT));
145 }
146 
147 static inline void
148 writereg_io(struct net_device *dev, int portno, int value)
149 {
150 	nubus_writew(swab16(portno), dev->base_addr + ADD_PORT);
151 	nubus_writew(swab16(value), dev->base_addr + DATA_PORT);
152 }
153 
154 /* These are for reading/writing registers in shared memory */
155 static inline int
156 readreg(struct net_device *dev, int portno)
157 {
158 	return swab16(nubus_readw(dev->mem_start + portno));
159 }
160 
161 static inline void
162 writereg(struct net_device *dev, int portno, int value)
163 {
164 	nubus_writew(swab16(value), dev->mem_start + portno);
165 }
166 
167 static const struct net_device_ops mac89x0_netdev_ops = {
168 	.ndo_open		= net_open,
169 	.ndo_stop		= net_close,
170 	.ndo_start_xmit		= net_send_packet,
171 	.ndo_get_stats		= net_get_stats,
172 	.ndo_set_rx_mode	= set_multicast_list,
173 	.ndo_set_mac_address	= set_mac_address,
174 	.ndo_validate_addr	= eth_validate_addr,
175 	.ndo_change_mtu		= eth_change_mtu,
176 };
177 
178 /* Probe for the CS8900 card in slot E.  We won't bother looking
179    anywhere else until we have a really good reason to do so. */
180 struct net_device * __init mac89x0_probe(int unit)
181 {
182 	struct net_device *dev;
183 	static int once_is_enough;
184 	struct net_local *lp;
185 	static unsigned version_printed;
186 	int i, slot;
187 	unsigned rev_type = 0;
188 	unsigned long ioaddr;
189 	unsigned short sig;
190 	int err = -ENODEV;
191 
192 	if (!MACH_IS_MAC)
193 		return ERR_PTR(-ENODEV);
194 
195 	dev = alloc_etherdev(sizeof(struct net_local));
196 	if (!dev)
197 		return ERR_PTR(-ENOMEM);
198 
199 	if (unit >= 0) {
200 		sprintf(dev->name, "eth%d", unit);
201 		netdev_boot_setup_check(dev);
202 	}
203 
204 	if (once_is_enough)
205 		goto out;
206 	once_is_enough = 1;
207 
208 	/* We might have to parameterize this later */
209 	slot = 0xE;
210 	/* Get out now if there's a real NuBus card in slot E */
211 	if (nubus_find_slot(slot, NULL) != NULL)
212 		goto out;
213 
214 	/* The pseudo-ISA bits always live at offset 0x300 (gee,
215            wonder why...) */
216 	ioaddr = (unsigned long)
217 		nubus_slot_addr(slot) | (((slot&0xf) << 20) + DEFAULTIOBASE);
218 	{
219 		unsigned long flags;
220 		int card_present;
221 
222 		local_irq_save(flags);
223 		card_present = (hwreg_present((void*) ioaddr+4) &&
224 				hwreg_present((void*) ioaddr + DATA_PORT));
225 		local_irq_restore(flags);
226 
227 		if (!card_present)
228 			goto out;
229 	}
230 
231 	nubus_writew(0, ioaddr + ADD_PORT);
232 	sig = nubus_readw(ioaddr + DATA_PORT);
233 	if (sig != swab16(CHIP_EISA_ID_SIG))
234 		goto out;
235 
236 	/* Initialize the net_device structure. */
237 	lp = netdev_priv(dev);
238 
239 	/* Fill in the 'dev' fields. */
240 	dev->base_addr = ioaddr;
241 	dev->mem_start = (unsigned long)
242 		nubus_slot_addr(slot) | (((slot&0xf) << 20) + MMIOBASE);
243 	dev->mem_end = dev->mem_start + 0x1000;
244 
245 	/* Turn on shared memory */
246 	writereg_io(dev, PP_BusCTL, MEMORY_ON);
247 
248 	/* get the chip type */
249 	rev_type = readreg(dev, PRODUCT_ID_ADD);
250 	lp->chip_type = rev_type &~ REVISON_BITS;
251 	lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
252 
253 	/* Check the chip type and revision in order to set the correct send command
254 	CS8920 revision C and CS8900 revision F can use the faster send. */
255 	lp->send_cmd = TX_AFTER_381;
256 	if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
257 		lp->send_cmd = TX_NOW;
258 	if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
259 		lp->send_cmd = TX_NOW;
260 
261 	if (net_debug && version_printed++ == 0)
262 		printk(version);
263 
264 	printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#8lx",
265 	       dev->name,
266 	       lp->chip_type==CS8900?'0':'2',
267 	       lp->chip_type==CS8920M?"M":"",
268 	       lp->chip_revision,
269 	       dev->base_addr);
270 
271 	/* Try to read the MAC address */
272 	if ((readreg(dev, PP_SelfST) & (EEPROM_PRESENT | EEPROM_OK)) == 0) {
273 		printk("\nmac89x0: No EEPROM, giving up now.\n");
274 		goto out1;
275         } else {
276                 for (i = 0; i < ETH_ALEN; i += 2) {
277 			/* Big-endian (why??!) */
278 			unsigned short s = readreg(dev, PP_IA + i);
279                         dev->dev_addr[i] = s >> 8;
280                         dev->dev_addr[i+1] = s & 0xff;
281                 }
282         }
283 
284 	dev->irq = SLOT2IRQ(slot);
285 
286 	/* print the IRQ and ethernet address. */
287 
288 	printk(" IRQ %d ADDR %pM\n", dev->irq, dev->dev_addr);
289 
290 	dev->netdev_ops		= &mac89x0_netdev_ops;
291 
292 	err = register_netdev(dev);
293 	if (err)
294 		goto out1;
295 	return NULL;
296 out1:
297 	nubus_writew(0, dev->base_addr + ADD_PORT);
298 out:
299 	free_netdev(dev);
300 	return ERR_PTR(err);
301 }
302 
303 #if 0
304 /* This is useful for something, but I don't know what yet. */
305 void __init reset_chip(struct net_device *dev)
306 {
307 	int reset_start_time;
308 
309 	writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
310 
311 	/* wait 30 ms */
312 	msleep_interruptible(30);
313 
314 	/* Wait until the chip is reset */
315 	reset_start_time = jiffies;
316 	while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
317 		;
318 }
319 #endif
320 
321 /* Open/initialize the board.  This is called (in the current kernel)
322    sometime after booting when the 'ifconfig' program is run.
323 
324    This routine should set everything up anew at each open, even
325    registers that "should" only need to be set once at boot, so that
326    there is non-reboot way to recover if something goes wrong.
327    */
328 static int
329 net_open(struct net_device *dev)
330 {
331 	struct net_local *lp = netdev_priv(dev);
332 	int i;
333 
334 	/* Disable the interrupt for now */
335 	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) & ~ENABLE_IRQ);
336 
337 	/* Grab the interrupt */
338 	if (request_irq(dev->irq, net_interrupt, 0, "cs89x0", dev))
339 		return -EAGAIN;
340 
341 	/* Set up the IRQ - Apparently magic */
342 	if (lp->chip_type == CS8900)
343 		writereg(dev, PP_CS8900_ISAINT, 0);
344 	else
345 		writereg(dev, PP_CS8920_ISAINT, 0);
346 
347 	/* set the Ethernet address */
348 	for (i=0; i < ETH_ALEN/2; i++)
349 		writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
350 
351 	/* Turn on both receive and transmit operations */
352 	writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
353 
354 	/* Receive only error free packets addressed to this card */
355 	lp->rx_mode = 0;
356 	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
357 
358 	lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
359 
360 	writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
361 
362 	writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
363 	       TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
364 
365 	writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
366 		 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
367 
368 	/* now that we've got our act together, enable everything */
369 	writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
370 	netif_start_queue(dev);
371 	return 0;
372 }
373 
374 static int
375 net_send_packet(struct sk_buff *skb, struct net_device *dev)
376 {
377 	struct net_local *lp = netdev_priv(dev);
378 	unsigned long flags;
379 
380 	if (net_debug > 3)
381 		printk("%s: sent %d byte packet of type %x\n",
382 		       dev->name, skb->len,
383 		       (skb->data[ETH_ALEN+ETH_ALEN] << 8)
384 		       | skb->data[ETH_ALEN+ETH_ALEN+1]);
385 
386 	/* keep the upload from being interrupted, since we
387 	   ask the chip to start transmitting before the
388 	   whole packet has been completely uploaded. */
389 	local_irq_save(flags);
390 	netif_stop_queue(dev);
391 
392 	/* initiate a transmit sequence */
393 	writereg(dev, PP_TxCMD, lp->send_cmd);
394 	writereg(dev, PP_TxLength, skb->len);
395 
396 	/* Test to see if the chip has allocated memory for the packet */
397 	if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
398 		/* Gasp!  It hasn't.  But that shouldn't happen since
399 		   we're waiting for TxOk, so return 1 and requeue this packet. */
400 		local_irq_restore(flags);
401 		return NETDEV_TX_BUSY;
402 	}
403 
404 	/* Write the contents of the packet */
405 	skb_copy_from_linear_data(skb, (void *)(dev->mem_start + PP_TxFrame),
406 				  skb->len+1);
407 
408 	local_irq_restore(flags);
409 	dev_kfree_skb (skb);
410 
411 	return NETDEV_TX_OK;
412 }
413 
414 /* The typical workload of the driver:
415    Handle the network interface interrupts. */
416 static irqreturn_t net_interrupt(int irq, void *dev_id)
417 {
418 	struct net_device *dev = dev_id;
419 	struct net_local *lp;
420 	int ioaddr, status;
421 
422 	if (dev == NULL) {
423 		printk ("net_interrupt(): irq %d for unknown device.\n", irq);
424 		return IRQ_NONE;
425 	}
426 
427 	ioaddr = dev->base_addr;
428 	lp = netdev_priv(dev);
429 
430 	/* we MUST read all the events out of the ISQ, otherwise we'll never
431            get interrupted again.  As a consequence, we can't have any limit
432            on the number of times we loop in the interrupt handler.  The
433            hardware guarantees that eventually we'll run out of events.  Of
434            course, if you're on a slow machine, and packets are arriving
435            faster than you can read them off, you're screwed.  Hasta la
436            vista, baby!  */
437 	while ((status = swab16(nubus_readw(dev->base_addr + ISQ_PORT)))) {
438 		if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
439 		switch(status & ISQ_EVENT_MASK) {
440 		case ISQ_RECEIVER_EVENT:
441 			/* Got a packet(s). */
442 			net_rx(dev);
443 			break;
444 		case ISQ_TRANSMITTER_EVENT:
445 			dev->stats.tx_packets++;
446 			netif_wake_queue(dev);
447 			if ((status & TX_OK) == 0)
448 				dev->stats.tx_errors++;
449 			if (status & TX_LOST_CRS)
450 				dev->stats.tx_carrier_errors++;
451 			if (status & TX_SQE_ERROR)
452 				dev->stats.tx_heartbeat_errors++;
453 			if (status & TX_LATE_COL)
454 				dev->stats.tx_window_errors++;
455 			if (status & TX_16_COL)
456 				dev->stats.tx_aborted_errors++;
457 			break;
458 		case ISQ_BUFFER_EVENT:
459 			if (status & READY_FOR_TX) {
460 				/* we tried to transmit a packet earlier,
461                                    but inexplicably ran out of buffers.
462                                    That shouldn't happen since we only ever
463                                    load one packet.  Shrug.  Do the right
464                                    thing anyway. */
465 				netif_wake_queue(dev);
466 			}
467 			if (status & TX_UNDERRUN) {
468 				if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
469                                 lp->send_underrun++;
470                                 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
471                                 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
472                         }
473 			break;
474 		case ISQ_RX_MISS_EVENT:
475 			dev->stats.rx_missed_errors += (status >> 6);
476 			break;
477 		case ISQ_TX_COL_EVENT:
478 			dev->stats.collisions += (status >> 6);
479 			break;
480 		}
481 	}
482 	return IRQ_HANDLED;
483 }
484 
485 /* We have a good packet(s), get it/them out of the buffers. */
486 static void
487 net_rx(struct net_device *dev)
488 {
489 	struct sk_buff *skb;
490 	int status, length;
491 
492 	status = readreg(dev, PP_RxStatus);
493 	if ((status & RX_OK) == 0) {
494 		dev->stats.rx_errors++;
495 		if (status & RX_RUNT)
496 				dev->stats.rx_length_errors++;
497 		if (status & RX_EXTRA_DATA)
498 				dev->stats.rx_length_errors++;
499 		if ((status & RX_CRC_ERROR) &&
500 		    !(status & (RX_EXTRA_DATA|RX_RUNT)))
501 			/* per str 172 */
502 			dev->stats.rx_crc_errors++;
503 		if (status & RX_DRIBBLE)
504 				dev->stats.rx_frame_errors++;
505 		return;
506 	}
507 
508 	length = readreg(dev, PP_RxLength);
509 	/* Malloc up new buffer. */
510 	skb = alloc_skb(length, GFP_ATOMIC);
511 	if (skb == NULL) {
512 		printk("%s: Memory squeeze, dropping packet.\n", dev->name);
513 		dev->stats.rx_dropped++;
514 		return;
515 	}
516 	skb_put(skb, length);
517 
518 	skb_copy_to_linear_data(skb, (void *)(dev->mem_start + PP_RxFrame),
519 				length);
520 
521 	if (net_debug > 3)printk("%s: received %d byte packet of type %x\n",
522                                  dev->name, length,
523                                  (skb->data[ETH_ALEN+ETH_ALEN] << 8)
524 				 | skb->data[ETH_ALEN+ETH_ALEN+1]);
525 
526         skb->protocol=eth_type_trans(skb,dev);
527 	netif_rx(skb);
528 	dev->stats.rx_packets++;
529 	dev->stats.rx_bytes += length;
530 }
531 
532 /* The inverse routine to net_open(). */
533 static int
534 net_close(struct net_device *dev)
535 {
536 
537 	writereg(dev, PP_RxCFG, 0);
538 	writereg(dev, PP_TxCFG, 0);
539 	writereg(dev, PP_BufCFG, 0);
540 	writereg(dev, PP_BusCTL, 0);
541 
542 	netif_stop_queue(dev);
543 
544 	free_irq(dev->irq, dev);
545 
546 	/* Update the statistics here. */
547 
548 	return 0;
549 
550 }
551 
552 /* Get the current statistics.	This may be called with the card open or
553    closed. */
554 static struct net_device_stats *
555 net_get_stats(struct net_device *dev)
556 {
557 	unsigned long flags;
558 
559 	local_irq_save(flags);
560 	/* Update the statistics from the device registers. */
561 	dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
562 	dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
563 	local_irq_restore(flags);
564 
565 	return &dev->stats;
566 }
567 
568 static void set_multicast_list(struct net_device *dev)
569 {
570 	struct net_local *lp = netdev_priv(dev);
571 
572 	if(dev->flags&IFF_PROMISC)
573 	{
574 		lp->rx_mode = RX_ALL_ACCEPT;
575 	} else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev)) {
576 		/* The multicast-accept list is initialized to accept-all, and we
577 		   rely on higher-level filtering for now. */
578 		lp->rx_mode = RX_MULTCAST_ACCEPT;
579 	}
580 	else
581 		lp->rx_mode = 0;
582 
583 	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
584 
585 	/* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
586 	writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
587 	     (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
588 }
589 
590 
591 static int set_mac_address(struct net_device *dev, void *addr)
592 {
593 	struct sockaddr *saddr = addr;
594 	int i;
595 
596 	if (!is_valid_ether_addr(saddr->sa_data))
597 		return -EADDRNOTAVAIL;
598 
599 	memcpy(dev->dev_addr, saddr->sa_data, ETH_ALEN);
600 	printk("%s: Setting MAC address to %pM\n", dev->name, dev->dev_addr);
601 
602 	/* set the Ethernet address */
603 	for (i=0; i < ETH_ALEN/2; i++)
604 		writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
605 
606 	return 0;
607 }
608 
609 #ifdef MODULE
610 
611 static struct net_device *dev_cs89x0;
612 static int debug;
613 
614 module_param(debug, int, 0);
615 MODULE_PARM_DESC(debug, "CS89[02]0 debug level (0-5)");
616 MODULE_LICENSE("GPL");
617 
618 int __init
619 init_module(void)
620 {
621 	net_debug = debug;
622         dev_cs89x0 = mac89x0_probe(-1);
623 	if (IS_ERR(dev_cs89x0)) {
624                 printk(KERN_WARNING "mac89x0.c: No card found\n");
625 		return PTR_ERR(dev_cs89x0);
626 	}
627 	return 0;
628 }
629 
630 void
631 cleanup_module(void)
632 {
633 	unregister_netdev(dev_cs89x0);
634 	nubus_writew(0, dev_cs89x0->base_addr + ADD_PORT);
635 	free_netdev(dev_cs89x0);
636 }
637 #endif /* MODULE */
638