1 /* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0
2  *           driver for linux.
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, 521 Pleasant Valley Rd., Potsdam, NY 13676
11  *
12  * Other contributors:
13  * Mike Cruse        : mcruse@cti-ltd.com
14  * Russ Nelson
15  * Melody Lee        : ethernet@crystal.cirrus.com
16  * Alan Cox
17  * Andrew Morton
18  * Oskar Schirmer    : oskar@scara.com
19  * Deepak Saxena     : dsaxena@plexity.net
20  * Dmitry Pervushin  : dpervushin@ru.mvista.com
21  * Deepak Saxena     : dsaxena@plexity.net
22  * Domenico Andreoli : cavokz@gmail.com
23  */
24 
25 
26 /*
27  * Set this to zero to disable DMA code
28  *
29  * Note that even if DMA is turned off we still support the 'dma' and  'use_dma'
30  * module options so we don't break any startup scripts.
31  */
32 #ifndef CONFIG_ISA_DMA_API
33 #define ALLOW_DMA	0
34 #else
35 #define ALLOW_DMA	1
36 #endif
37 
38 /*
39  * Set this to zero to remove all the debug statements via
40  * dead code elimination
41  */
42 #define DEBUGGING	1
43 
44 /* Sources:
45  *	Crynwr packet driver epktisa.
46  *	Crystal Semiconductor data sheets.
47  */
48 
49 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
50 
51 #include <linux/module.h>
52 #include <linux/printk.h>
53 #include <linux/errno.h>
54 #include <linux/netdevice.h>
55 #include <linux/etherdevice.h>
56 #include <linux/platform_device.h>
57 #include <linux/kernel.h>
58 #include <linux/types.h>
59 #include <linux/fcntl.h>
60 #include <linux/interrupt.h>
61 #include <linux/ioport.h>
62 #include <linux/in.h>
63 #include <linux/skbuff.h>
64 #include <linux/spinlock.h>
65 #include <linux/string.h>
66 #include <linux/init.h>
67 #include <linux/bitops.h>
68 #include <linux/delay.h>
69 #include <linux/gfp.h>
70 #include <linux/io.h>
71 
72 #include <asm/irq.h>
73 #include <linux/atomic.h>
74 #if ALLOW_DMA
75 #include <asm/dma.h>
76 #endif
77 
78 #include "cs89x0.h"
79 
80 #define cs89_dbg(val, level, fmt, ...)				\
81 do {								\
82 	if (val <= net_debug)					\
83 		pr_##level(fmt, ##__VA_ARGS__);			\
84 } while (0)
85 
86 static char version[] __initdata =
87 	"v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton";
88 
89 #define DRV_NAME "cs89x0"
90 
91 /* First, a few definitions that the brave might change.
92  * A zero-terminated list of I/O addresses to be probed. Some special flags..
93  * Addr & 1 = Read back the address port, look for signature and reset
94  * the page window before probing
95  * Addr & 3 = Reset the page window and probe
96  * The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,
97  * but it is possible that a Cirrus board could be plugged into the ISA
98  * slots.
99  */
100 /* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
101  * them to system IRQ numbers. This mapping is card specific and is set to
102  * the configuration of the Cirrus Eval board for this chip.
103  */
104 #ifndef CONFIG_CS89x0_PLATFORM
105 static unsigned int netcard_portlist[] __used __initdata = {
106 	0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240,
107 	0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0
108 };
109 static unsigned int cs8900_irq_map[] = {
110 	10, 11, 12, 5
111 };
112 #endif
113 
114 #if DEBUGGING
115 static unsigned int net_debug = DEBUGGING;
116 #else
117 #define net_debug 0	/* gcc will remove all the debug code for us */
118 #endif
119 
120 /* The number of low I/O ports used by the ethercard. */
121 #define NETCARD_IO_EXTENT	16
122 
123 /* we allow the user to override various values normally set in the EEPROM */
124 #define FORCE_RJ45	0x0001    /* pick one of these three */
125 #define FORCE_AUI	0x0002
126 #define FORCE_BNC	0x0004
127 
128 #define FORCE_AUTO	0x0010    /* pick one of these three */
129 #define FORCE_HALF	0x0020
130 #define FORCE_FULL	0x0030
131 
132 /* Information that need to be kept for each board. */
133 struct net_local {
134 	int chip_type;		/* one of: CS8900, CS8920, CS8920M */
135 	char chip_revision;	/* revision letter of the chip ('A'...) */
136 	int send_cmd;		/* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
137 	int auto_neg_cnf;	/* auto-negotiation word from EEPROM */
138 	int adapter_cnf;	/* adapter configuration from EEPROM */
139 	int isa_config;		/* ISA configuration from EEPROM */
140 	int irq_map;		/* IRQ map from EEPROM */
141 	int rx_mode;		/* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
142 	int curr_rx_cfg;	/* a copy of PP_RxCFG */
143 	int linectl;		/* either 0 or LOW_RX_SQUELCH, depending on configuration. */
144 	int send_underrun;	/* keep track of how many underruns in a row we get */
145 	int force;		/* force various values; see FORCE* above. */
146 	spinlock_t lock;
147 	void __iomem *virt_addr;/* CS89x0 virtual address. */
148 	unsigned long size;	/* Length of CS89x0 memory region. */
149 #if ALLOW_DMA
150 	int use_dma;		/* Flag: we're using dma */
151 	int dma;		/* DMA channel */
152 	int dmasize;		/* 16 or 64 */
153 	unsigned char *dma_buff;	/* points to the beginning of the buffer */
154 	unsigned char *end_dma_buff;	/* points to the end of the buffer */
155 	unsigned char *rx_dma_ptr;	/* points to the next packet  */
156 #endif
157 };
158 
159 /* Example routines you must write ;->. */
160 #define tx_done(dev) 1
161 
162 /*
163  * Permit 'cs89x0_dma=N' in the kernel boot environment
164  */
165 #if !defined(MODULE)
166 #if ALLOW_DMA
167 static int g_cs89x0_dma;
168 
169 static int __init dma_fn(char *str)
170 {
171 	g_cs89x0_dma = simple_strtol(str, NULL, 0);
172 	return 1;
173 }
174 
175 __setup("cs89x0_dma=", dma_fn);
176 #endif	/* ALLOW_DMA */
177 
178 static int g_cs89x0_media__force;
179 
180 static int __init media_fn(char *str)
181 {
182 	if (!strcmp(str, "rj45"))
183 		g_cs89x0_media__force = FORCE_RJ45;
184 	else if (!strcmp(str, "aui"))
185 		g_cs89x0_media__force = FORCE_AUI;
186 	else if (!strcmp(str, "bnc"))
187 		g_cs89x0_media__force = FORCE_BNC;
188 
189 	return 1;
190 }
191 
192 __setup("cs89x0_media=", media_fn);
193 #endif
194 
195 static void readwords(struct net_local *lp, int portno, void *buf, int length)
196 {
197 	u8 *buf8 = (u8 *)buf;
198 
199 	do {
200 		u16 tmp16;
201 
202 		tmp16 = ioread16(lp->virt_addr + portno);
203 		*buf8++ = (u8)tmp16;
204 		*buf8++ = (u8)(tmp16 >> 8);
205 	} while (--length);
206 }
207 
208 static void writewords(struct net_local *lp, int portno, void *buf, int length)
209 {
210 	u8 *buf8 = (u8 *)buf;
211 
212 	do {
213 		u16 tmp16;
214 
215 		tmp16 = *buf8++;
216 		tmp16 |= (*buf8++) << 8;
217 		iowrite16(tmp16, lp->virt_addr + portno);
218 	} while (--length);
219 }
220 
221 static u16
222 readreg(struct net_device *dev, u16 regno)
223 {
224 	struct net_local *lp = netdev_priv(dev);
225 
226 	iowrite16(regno, lp->virt_addr + ADD_PORT);
227 	return ioread16(lp->virt_addr + DATA_PORT);
228 }
229 
230 static void
231 writereg(struct net_device *dev, u16 regno, u16 value)
232 {
233 	struct net_local *lp = netdev_priv(dev);
234 
235 	iowrite16(regno, lp->virt_addr + ADD_PORT);
236 	iowrite16(value, lp->virt_addr + DATA_PORT);
237 }
238 
239 static int __init
240 wait_eeprom_ready(struct net_device *dev)
241 {
242 	int timeout = jiffies;
243 	/* check to see if the EEPROM is ready,
244 	 * a timeout is used just in case EEPROM is ready when
245 	 * SI_BUSY in the PP_SelfST is clear
246 	 */
247 	while (readreg(dev, PP_SelfST) & SI_BUSY)
248 		if (jiffies - timeout >= 40)
249 			return -1;
250 	return 0;
251 }
252 
253 static int __init
254 get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
255 {
256 	int i;
257 
258 	cs89_dbg(3, info, "EEPROM data from %x for %x:", off, len);
259 	for (i = 0; i < len; i++) {
260 		if (wait_eeprom_ready(dev) < 0)
261 			return -1;
262 		/* Now send the EEPROM read command and EEPROM location to read */
263 		writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
264 		if (wait_eeprom_ready(dev) < 0)
265 			return -1;
266 		buffer[i] = readreg(dev, PP_EEData);
267 		cs89_dbg(3, cont, " %04x", buffer[i]);
268 	}
269 	cs89_dbg(3, cont, "\n");
270 	return 0;
271 }
272 
273 static int  __init
274 get_eeprom_cksum(int off, int len, int *buffer)
275 {
276 	int i, cksum;
277 
278 	cksum = 0;
279 	for (i = 0; i < len; i++)
280 		cksum += buffer[i];
281 	cksum &= 0xffff;
282 	if (cksum == 0)
283 		return 0;
284 	return -1;
285 }
286 
287 static void
288 write_irq(struct net_device *dev, int chip_type, int irq)
289 {
290 	int i;
291 
292 	if (chip_type == CS8900) {
293 #ifndef CONFIG_CS89x0_PLATFORM
294 		/* Search the mapping table for the corresponding IRQ pin. */
295 		for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
296 			if (cs8900_irq_map[i] == irq)
297 				break;
298 		/* Not found */
299 		if (i == ARRAY_SIZE(cs8900_irq_map))
300 			i = 3;
301 #else
302 		/* INTRQ0 pin is used for interrupt generation. */
303 		i = 0;
304 #endif
305 		writereg(dev, PP_CS8900_ISAINT, i);
306 	} else {
307 		writereg(dev, PP_CS8920_ISAINT, irq);
308 	}
309 }
310 
311 static void
312 count_rx_errors(int status, struct net_device *dev)
313 {
314 	dev->stats.rx_errors++;
315 	if (status & RX_RUNT)
316 		dev->stats.rx_length_errors++;
317 	if (status & RX_EXTRA_DATA)
318 		dev->stats.rx_length_errors++;
319 	if ((status & RX_CRC_ERROR) && !(status & (RX_EXTRA_DATA | RX_RUNT)))
320 		/* per str 172 */
321 		dev->stats.rx_crc_errors++;
322 	if (status & RX_DRIBBLE)
323 		dev->stats.rx_frame_errors++;
324 }
325 
326 /*********************************
327  * This page contains DMA routines
328  *********************************/
329 
330 #if ALLOW_DMA
331 
332 #define dma_page_eq(ptr1, ptr2) ((long)(ptr1) >> 17 == (long)(ptr2) >> 17)
333 
334 static void
335 get_dma_channel(struct net_device *dev)
336 {
337 	struct net_local *lp = netdev_priv(dev);
338 
339 	if (lp->dma) {
340 		dev->dma = lp->dma;
341 		lp->isa_config |= ISA_RxDMA;
342 	} else {
343 		if ((lp->isa_config & ANY_ISA_DMA) == 0)
344 			return;
345 		dev->dma = lp->isa_config & DMA_NO_MASK;
346 		if (lp->chip_type == CS8900)
347 			dev->dma += 5;
348 		if (dev->dma < 5 || dev->dma > 7) {
349 			lp->isa_config &= ~ANY_ISA_DMA;
350 			return;
351 		}
352 	}
353 }
354 
355 static void
356 write_dma(struct net_device *dev, int chip_type, int dma)
357 {
358 	struct net_local *lp = netdev_priv(dev);
359 	if ((lp->isa_config & ANY_ISA_DMA) == 0)
360 		return;
361 	if (chip_type == CS8900)
362 		writereg(dev, PP_CS8900_ISADMA, dma - 5);
363 	else
364 		writereg(dev, PP_CS8920_ISADMA, dma);
365 }
366 
367 static void
368 set_dma_cfg(struct net_device *dev)
369 {
370 	struct net_local *lp = netdev_priv(dev);
371 
372 	if (lp->use_dma) {
373 		if ((lp->isa_config & ANY_ISA_DMA) == 0) {
374 			cs89_dbg(3, err, "set_dma_cfg(): no DMA\n");
375 			return;
376 		}
377 		if (lp->isa_config & ISA_RxDMA) {
378 			lp->curr_rx_cfg |= RX_DMA_ONLY;
379 			cs89_dbg(3, info, "set_dma_cfg(): RX_DMA_ONLY\n");
380 		} else {
381 			lp->curr_rx_cfg |= AUTO_RX_DMA;	/* not that we support it... */
382 			cs89_dbg(3, info, "set_dma_cfg(): AUTO_RX_DMA\n");
383 		}
384 	}
385 }
386 
387 static int
388 dma_bufcfg(struct net_device *dev)
389 {
390 	struct net_local *lp = netdev_priv(dev);
391 	if (lp->use_dma)
392 		return (lp->isa_config & ANY_ISA_DMA) ? RX_DMA_ENBL : 0;
393 	else
394 		return 0;
395 }
396 
397 static int
398 dma_busctl(struct net_device *dev)
399 {
400 	int retval = 0;
401 	struct net_local *lp = netdev_priv(dev);
402 	if (lp->use_dma) {
403 		if (lp->isa_config & ANY_ISA_DMA)
404 			retval |= RESET_RX_DMA; /* Reset the DMA pointer */
405 		if (lp->isa_config & DMA_BURST)
406 			retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
407 		if (lp->dmasize == 64)
408 			retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
409 		retval |= MEMORY_ON;	/* we need memory enabled to use DMA. */
410 	}
411 	return retval;
412 }
413 
414 static void
415 dma_rx(struct net_device *dev)
416 {
417 	struct net_local *lp = netdev_priv(dev);
418 	struct sk_buff *skb;
419 	int status, length;
420 	unsigned char *bp = lp->rx_dma_ptr;
421 
422 	status = bp[0] + (bp[1] << 8);
423 	length = bp[2] + (bp[3] << 8);
424 	bp += 4;
425 
426 	cs89_dbg(5, debug, "%s: receiving DMA packet at %lx, status %x, length %x\n",
427 		 dev->name, (unsigned long)bp, status, length);
428 
429 	if ((status & RX_OK) == 0) {
430 		count_rx_errors(status, dev);
431 		goto skip_this_frame;
432 	}
433 
434 	/* Malloc up new buffer. */
435 	skb = netdev_alloc_skb(dev, length + 2);
436 	if (skb == NULL) {
437 		dev->stats.rx_dropped++;
438 
439 		/* AKPM: advance bp to the next frame */
440 skip_this_frame:
441 		bp += (length + 3) & ~3;
442 		if (bp >= lp->end_dma_buff)
443 			bp -= lp->dmasize * 1024;
444 		lp->rx_dma_ptr = bp;
445 		return;
446 	}
447 	skb_reserve(skb, 2);	/* longword align L3 header */
448 
449 	if (bp + length > lp->end_dma_buff) {
450 		int semi_cnt = lp->end_dma_buff - bp;
451 		memcpy(skb_put(skb, semi_cnt), bp, semi_cnt);
452 		memcpy(skb_put(skb, length - semi_cnt), lp->dma_buff,
453 		       length - semi_cnt);
454 	} else {
455 		memcpy(skb_put(skb, length), bp, length);
456 	}
457 	bp += (length + 3) & ~3;
458 	if (bp >= lp->end_dma_buff)
459 		bp -= lp->dmasize*1024;
460 	lp->rx_dma_ptr = bp;
461 
462 	cs89_dbg(3, info, "%s: received %d byte DMA packet of type %x\n",
463 		 dev->name, length,
464 		 ((skb->data[ETH_ALEN + ETH_ALEN] << 8) |
465 		  skb->data[ETH_ALEN + ETH_ALEN + 1]));
466 
467 	skb->protocol = eth_type_trans(skb, dev);
468 	netif_rx(skb);
469 	dev->stats.rx_packets++;
470 	dev->stats.rx_bytes += length;
471 }
472 
473 static void release_dma_buff(struct net_local *lp)
474 {
475 	if (lp->dma_buff) {
476 		free_pages((unsigned long)(lp->dma_buff),
477 			   get_order(lp->dmasize * 1024));
478 		lp->dma_buff = NULL;
479 	}
480 }
481 
482 #endif	/* ALLOW_DMA */
483 
484 static void
485 control_dc_dc(struct net_device *dev, int on_not_off)
486 {
487 	struct net_local *lp = netdev_priv(dev);
488 	unsigned int selfcontrol;
489 	int timenow = jiffies;
490 	/* control the DC to DC convertor in the SelfControl register.
491 	 * Note: This is hooked up to a general purpose pin, might not
492 	 * always be a DC to DC convertor.
493 	 */
494 
495 	selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
496 	if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
497 		selfcontrol |= HCB1;
498 	else
499 		selfcontrol &= ~HCB1;
500 	writereg(dev, PP_SelfCTL, selfcontrol);
501 
502 	/* Wait for the DC/DC converter to power up - 500ms */
503 	while (jiffies - timenow < HZ)
504 		;
505 }
506 
507 /* send a test packet - return true if carrier bits are ok */
508 static int
509 send_test_pkt(struct net_device *dev)
510 {
511 	struct net_local *lp = netdev_priv(dev);
512 	char test_packet[] = {
513 		0, 0, 0, 0, 0, 0,  0, 0, 0, 0, 0, 0,
514 		0, 46,		/* A 46 in network order */
515 		0, 0,		/* DSAP=0 & SSAP=0 fields */
516 		0xf3, 0		/* Control (Test Req + P bit set) */
517 	};
518 	long timenow = jiffies;
519 
520 	writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
521 
522 	memcpy(test_packet,            dev->dev_addr, ETH_ALEN);
523 	memcpy(test_packet + ETH_ALEN, dev->dev_addr, ETH_ALEN);
524 
525 	iowrite16(TX_AFTER_ALL, lp->virt_addr + TX_CMD_PORT);
526 	iowrite16(ETH_ZLEN, lp->virt_addr + TX_LEN_PORT);
527 
528 	/* Test to see if the chip has allocated memory for the packet */
529 	while (jiffies - timenow < 5)
530 		if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
531 			break;
532 	if (jiffies - timenow >= 5)
533 		return 0;	/* this shouldn't happen */
534 
535 	/* Write the contents of the packet */
536 	writewords(lp, TX_FRAME_PORT, test_packet, (ETH_ZLEN + 1) >> 1);
537 
538 	cs89_dbg(1, debug, "Sending test packet ");
539 	/* wait a couple of jiffies for packet to be received */
540 	for (timenow = jiffies; jiffies - timenow < 3;)
541 		;
542 	if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
543 		cs89_dbg(1, cont, "succeeded\n");
544 		return 1;
545 	}
546 	cs89_dbg(1, cont, "failed\n");
547 	return 0;
548 }
549 
550 #define DETECTED_NONE  0
551 #define DETECTED_RJ45H 1
552 #define DETECTED_RJ45F 2
553 #define DETECTED_AUI   3
554 #define DETECTED_BNC   4
555 
556 static int
557 detect_tp(struct net_device *dev)
558 {
559 	struct net_local *lp = netdev_priv(dev);
560 	int timenow = jiffies;
561 	int fdx;
562 
563 	cs89_dbg(1, debug, "%s: Attempting TP\n", dev->name);
564 
565 	/* If connected to another full duplex capable 10-Base-T card
566 	 * the link pulses seem to be lost when the auto detect bit in
567 	 * the LineCTL is set.  To overcome this the auto detect bit will
568 	 * be cleared whilst testing the 10-Base-T interface.  This would
569 	 * not be necessary for the sparrow chip but is simpler to do it
570 	 * anyway.
571 	 */
572 	writereg(dev, PP_LineCTL, lp->linectl & ~AUI_ONLY);
573 	control_dc_dc(dev, 0);
574 
575 	/* Delay for the hardware to work out if the TP cable is present
576 	 * - 150ms
577 	 */
578 	for (timenow = jiffies; jiffies - timenow < 15;)
579 		;
580 	if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
581 		return DETECTED_NONE;
582 
583 	if (lp->chip_type == CS8900) {
584 		switch (lp->force & 0xf0) {
585 #if 0
586 		case FORCE_AUTO:
587 			pr_info("%s: cs8900 doesn't autonegotiate\n",
588 				dev->name);
589 			return DETECTED_NONE;
590 #endif
591 			/* CS8900 doesn't support AUTO, change to HALF*/
592 		case FORCE_AUTO:
593 			lp->force &= ~FORCE_AUTO;
594 			lp->force |= FORCE_HALF;
595 			break;
596 		case FORCE_HALF:
597 			break;
598 		case FORCE_FULL:
599 			writereg(dev, PP_TestCTL,
600 				 readreg(dev, PP_TestCTL) | FDX_8900);
601 			break;
602 		}
603 		fdx = readreg(dev, PP_TestCTL) & FDX_8900;
604 	} else {
605 		switch (lp->force & 0xf0) {
606 		case FORCE_AUTO:
607 			lp->auto_neg_cnf = AUTO_NEG_ENABLE;
608 			break;
609 		case FORCE_HALF:
610 			lp->auto_neg_cnf = 0;
611 			break;
612 		case FORCE_FULL:
613 			lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
614 			break;
615 		}
616 
617 		writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
618 
619 		if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
620 			pr_info("%s: negotiating duplex...\n", dev->name);
621 			while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
622 				if (jiffies - timenow > 4000) {
623 					pr_err("**** Full / half duplex auto-negotiation timed out ****\n");
624 					break;
625 				}
626 			}
627 		}
628 		fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
629 	}
630 	if (fdx)
631 		return DETECTED_RJ45F;
632 	else
633 		return DETECTED_RJ45H;
634 }
635 
636 static int
637 detect_bnc(struct net_device *dev)
638 {
639 	struct net_local *lp = netdev_priv(dev);
640 
641 	cs89_dbg(1, debug, "%s: Attempting BNC\n", dev->name);
642 	control_dc_dc(dev, 1);
643 
644 	writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
645 
646 	if (send_test_pkt(dev))
647 		return DETECTED_BNC;
648 	else
649 		return DETECTED_NONE;
650 }
651 
652 static int
653 detect_aui(struct net_device *dev)
654 {
655 	struct net_local *lp = netdev_priv(dev);
656 
657 	cs89_dbg(1, debug, "%s: Attempting AUI\n", dev->name);
658 	control_dc_dc(dev, 0);
659 
660 	writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
661 
662 	if (send_test_pkt(dev))
663 		return DETECTED_AUI;
664 	else
665 		return DETECTED_NONE;
666 }
667 
668 /* We have a good packet(s), get it/them out of the buffers. */
669 static void
670 net_rx(struct net_device *dev)
671 {
672 	struct net_local *lp = netdev_priv(dev);
673 	struct sk_buff *skb;
674 	int status, length;
675 
676 	status = ioread16(lp->virt_addr + RX_FRAME_PORT);
677 	length = ioread16(lp->virt_addr + RX_FRAME_PORT);
678 
679 	if ((status & RX_OK) == 0) {
680 		count_rx_errors(status, dev);
681 		return;
682 	}
683 
684 	/* Malloc up new buffer. */
685 	skb = netdev_alloc_skb(dev, length + 2);
686 	if (skb == NULL) {
687 		dev->stats.rx_dropped++;
688 		return;
689 	}
690 	skb_reserve(skb, 2);	/* longword align L3 header */
691 
692 	readwords(lp, RX_FRAME_PORT, skb_put(skb, length), length >> 1);
693 	if (length & 1)
694 		skb->data[length-1] = ioread16(lp->virt_addr + RX_FRAME_PORT);
695 
696 	cs89_dbg(3, debug, "%s: received %d byte packet of type %x\n",
697 		 dev->name, length,
698 		 (skb->data[ETH_ALEN + ETH_ALEN] << 8) |
699 		 skb->data[ETH_ALEN + ETH_ALEN + 1]);
700 
701 	skb->protocol = eth_type_trans(skb, dev);
702 	netif_rx(skb);
703 	dev->stats.rx_packets++;
704 	dev->stats.rx_bytes += length;
705 }
706 
707 /* The typical workload of the driver:
708  * Handle the network interface interrupts.
709  */
710 
711 static irqreturn_t net_interrupt(int irq, void *dev_id)
712 {
713 	struct net_device *dev = dev_id;
714 	struct net_local *lp;
715 	int status;
716 	int handled = 0;
717 
718 	lp = netdev_priv(dev);
719 
720 	/* we MUST read all the events out of the ISQ, otherwise we'll never
721 	 * get interrupted again.  As a consequence, we can't have any limit
722 	 * on the number of times we loop in the interrupt handler.  The
723 	 * hardware guarantees that eventually we'll run out of events.  Of
724 	 * course, if you're on a slow machine, and packets are arriving
725 	 * faster than you can read them off, you're screwed.  Hasta la
726 	 * vista, baby!
727 	 */
728 	while ((status = ioread16(lp->virt_addr + ISQ_PORT))) {
729 		cs89_dbg(4, debug, "%s: event=%04x\n", dev->name, status);
730 		handled = 1;
731 		switch (status & ISQ_EVENT_MASK) {
732 		case ISQ_RECEIVER_EVENT:
733 			/* Got a packet(s). */
734 			net_rx(dev);
735 			break;
736 		case ISQ_TRANSMITTER_EVENT:
737 			dev->stats.tx_packets++;
738 			netif_wake_queue(dev);	/* Inform upper layers. */
739 			if ((status & (TX_OK |
740 				       TX_LOST_CRS |
741 				       TX_SQE_ERROR |
742 				       TX_LATE_COL |
743 				       TX_16_COL)) != TX_OK) {
744 				if ((status & TX_OK) == 0)
745 					dev->stats.tx_errors++;
746 				if (status & TX_LOST_CRS)
747 					dev->stats.tx_carrier_errors++;
748 				if (status & TX_SQE_ERROR)
749 					dev->stats.tx_heartbeat_errors++;
750 				if (status & TX_LATE_COL)
751 					dev->stats.tx_window_errors++;
752 				if (status & TX_16_COL)
753 					dev->stats.tx_aborted_errors++;
754 			}
755 			break;
756 		case ISQ_BUFFER_EVENT:
757 			if (status & READY_FOR_TX) {
758 				/* we tried to transmit a packet earlier,
759 				 * but inexplicably ran out of buffers.
760 				 * That shouldn't happen since we only ever
761 				 * load one packet.  Shrug.  Do the right
762 				 * thing anyway.
763 				 */
764 				netif_wake_queue(dev);	/* Inform upper layers. */
765 			}
766 			if (status & TX_UNDERRUN) {
767 				cs89_dbg(0, err, "%s: transmit underrun\n",
768 					 dev->name);
769 				lp->send_underrun++;
770 				if (lp->send_underrun == 3)
771 					lp->send_cmd = TX_AFTER_381;
772 				else if (lp->send_underrun == 6)
773 					lp->send_cmd = TX_AFTER_ALL;
774 				/* transmit cycle is done, although
775 				 * frame wasn't transmitted - this
776 				 * avoids having to wait for the upper
777 				 * layers to timeout on us, in the
778 				 * event of a tx underrun
779 				 */
780 				netif_wake_queue(dev);	/* Inform upper layers. */
781 			}
782 #if ALLOW_DMA
783 			if (lp->use_dma && (status & RX_DMA)) {
784 				int count = readreg(dev, PP_DmaFrameCnt);
785 				while (count) {
786 					cs89_dbg(5, debug,
787 						 "%s: receiving %d DMA frames\n",
788 						 dev->name, count);
789 					if (count > 1)
790 						cs89_dbg(2, debug,
791 							 "%s: receiving %d DMA frames\n",
792 							 dev->name, count);
793 					dma_rx(dev);
794 					if (--count == 0)
795 						count = readreg(dev, PP_DmaFrameCnt);
796 					if (count > 0)
797 						cs89_dbg(2, debug,
798 							 "%s: continuing with %d DMA frames\n",
799 							 dev->name, count);
800 				}
801 			}
802 #endif
803 			break;
804 		case ISQ_RX_MISS_EVENT:
805 			dev->stats.rx_missed_errors += (status >> 6);
806 			break;
807 		case ISQ_TX_COL_EVENT:
808 			dev->stats.collisions += (status >> 6);
809 			break;
810 		}
811 	}
812 	return IRQ_RETVAL(handled);
813 }
814 
815 /* Open/initialize the board.  This is called (in the current kernel)
816    sometime after booting when the 'ifconfig' program is run.
817 
818    This routine should set everything up anew at each open, even
819    registers that "should" only need to be set once at boot, so that
820    there is non-reboot way to recover if something goes wrong.
821 */
822 
823 /* AKPM: do we need to do any locking here? */
824 
825 static int
826 net_open(struct net_device *dev)
827 {
828 	struct net_local *lp = netdev_priv(dev);
829 	int result = 0;
830 	int i;
831 	int ret;
832 
833 	if (dev->irq < 2) {
834 		/* Allow interrupts to be generated by the chip */
835 /* Cirrus' release had this: */
836 #if 0
837 		writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
838 #endif
839 /* And 2.3.47 had this: */
840 		writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
841 
842 		for (i = 2; i < CS8920_NO_INTS; i++) {
843 			if ((1 << i) & lp->irq_map) {
844 				if (request_irq(i, net_interrupt, 0, dev->name,
845 						dev) == 0) {
846 					dev->irq = i;
847 					write_irq(dev, lp->chip_type, i);
848 					/* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
849 					break;
850 				}
851 			}
852 		}
853 
854 		if (i >= CS8920_NO_INTS) {
855 			writereg(dev, PP_BusCTL, 0);	/* disable interrupts. */
856 			pr_err("can't get an interrupt\n");
857 			ret = -EAGAIN;
858 			goto bad_out;
859 		}
860 	} else {
861 #if !defined(CONFIG_CS89x0_PLATFORM)
862 		if (((1 << dev->irq) & lp->irq_map) == 0) {
863 			pr_err("%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
864 			       dev->name, dev->irq, lp->irq_map);
865 			ret = -EAGAIN;
866 			goto bad_out;
867 		}
868 #endif
869 /* FIXME: Cirrus' release had this: */
870 		writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ);
871 /* And 2.3.47 had this: */
872 #if 0
873 		writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
874 #endif
875 		write_irq(dev, lp->chip_type, dev->irq);
876 		ret = request_irq(dev->irq, net_interrupt, 0, dev->name, dev);
877 		if (ret) {
878 			pr_err("request_irq(%d) failed\n", dev->irq);
879 			goto bad_out;
880 		}
881 	}
882 
883 #if ALLOW_DMA
884 	if (lp->use_dma && (lp->isa_config & ANY_ISA_DMA)) {
885 		unsigned long flags;
886 		lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
887 								get_order(lp->dmasize * 1024));
888 		if (!lp->dma_buff) {
889 			pr_err("%s: cannot get %dK memory for DMA\n",
890 			       dev->name, lp->dmasize);
891 			goto release_irq;
892 		}
893 		cs89_dbg(1, debug, "%s: dma %lx %lx\n",
894 			 dev->name,
895 			 (unsigned long)lp->dma_buff,
896 			 (unsigned long)isa_virt_to_bus(lp->dma_buff));
897 		if ((unsigned long)lp->dma_buff >= MAX_DMA_ADDRESS ||
898 		    !dma_page_eq(lp->dma_buff,
899 				 lp->dma_buff + lp->dmasize * 1024 - 1)) {
900 			pr_err("%s: not usable as DMA buffer\n", dev->name);
901 			goto release_irq;
902 		}
903 		memset(lp->dma_buff, 0, lp->dmasize * 1024);	/* Why? */
904 		if (request_dma(dev->dma, dev->name)) {
905 			pr_err("%s: cannot get dma channel %d\n",
906 			       dev->name, dev->dma);
907 			goto release_irq;
908 		}
909 		write_dma(dev, lp->chip_type, dev->dma);
910 		lp->rx_dma_ptr = lp->dma_buff;
911 		lp->end_dma_buff = lp->dma_buff + lp->dmasize * 1024;
912 		spin_lock_irqsave(&lp->lock, flags);
913 		disable_dma(dev->dma);
914 		clear_dma_ff(dev->dma);
915 		set_dma_mode(dev->dma, DMA_RX_MODE); /* auto_init as well */
916 		set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
917 		set_dma_count(dev->dma, lp->dmasize * 1024);
918 		enable_dma(dev->dma);
919 		spin_unlock_irqrestore(&lp->lock, flags);
920 	}
921 #endif	/* ALLOW_DMA */
922 
923 	/* set the Ethernet address */
924 	for (i = 0; i < ETH_ALEN / 2; i++)
925 		writereg(dev, PP_IA + i * 2,
926 			 (dev->dev_addr[i * 2] |
927 			  (dev->dev_addr[i * 2 + 1] << 8)));
928 
929 	/* while we're testing the interface, leave interrupts disabled */
930 	writereg(dev, PP_BusCTL, MEMORY_ON);
931 
932 	/* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
933 	if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) &&
934 	    (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
935 		lp->linectl = LOW_RX_SQUELCH;
936 	else
937 		lp->linectl = 0;
938 
939 	/* check to make sure that they have the "right" hardware available */
940 	switch (lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
941 	case A_CNF_MEDIA_10B_T:
942 		result = lp->adapter_cnf & A_CNF_10B_T;
943 		break;
944 	case A_CNF_MEDIA_AUI:
945 		result = lp->adapter_cnf & A_CNF_AUI;
946 		break;
947 	case A_CNF_MEDIA_10B_2:
948 		result = lp->adapter_cnf & A_CNF_10B_2;
949 		break;
950 	default:
951 		result = lp->adapter_cnf & (A_CNF_10B_T |
952 					    A_CNF_AUI |
953 					    A_CNF_10B_2);
954 	}
955 	if (!result) {
956 		pr_err("%s: EEPROM is configured for unavailable media\n",
957 		       dev->name);
958 release_dma:
959 #if ALLOW_DMA
960 		free_dma(dev->dma);
961 release_irq:
962 		release_dma_buff(lp);
963 #endif
964 		writereg(dev, PP_LineCTL,
965 			 readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
966 		free_irq(dev->irq, dev);
967 		ret = -EAGAIN;
968 		goto bad_out;
969 	}
970 
971 	/* set the hardware to the configured choice */
972 	switch (lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
973 	case A_CNF_MEDIA_10B_T:
974 		result = detect_tp(dev);
975 		if (result == DETECTED_NONE) {
976 			pr_warn("%s: 10Base-T (RJ-45) has no cable\n",
977 				dev->name);
978 			if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
979 				result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
980 		}
981 		break;
982 	case A_CNF_MEDIA_AUI:
983 		result = detect_aui(dev);
984 		if (result == DETECTED_NONE) {
985 			pr_warn("%s: 10Base-5 (AUI) has no cable\n", dev->name);
986 			if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
987 				result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
988 		}
989 		break;
990 	case A_CNF_MEDIA_10B_2:
991 		result = detect_bnc(dev);
992 		if (result == DETECTED_NONE) {
993 			pr_warn("%s: 10Base-2 (BNC) has no cable\n", dev->name);
994 			if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
995 				result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
996 		}
997 		break;
998 	case A_CNF_MEDIA_AUTO:
999 		writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
1000 		if (lp->adapter_cnf & A_CNF_10B_T) {
1001 			result = detect_tp(dev);
1002 			if (result != DETECTED_NONE)
1003 				break;
1004 		}
1005 		if (lp->adapter_cnf & A_CNF_AUI) {
1006 			result = detect_aui(dev);
1007 			if (result != DETECTED_NONE)
1008 				break;
1009 		}
1010 		if (lp->adapter_cnf & A_CNF_10B_2) {
1011 			result = detect_bnc(dev);
1012 			if (result != DETECTED_NONE)
1013 				break;
1014 		}
1015 		pr_err("%s: no media detected\n", dev->name);
1016 		goto release_dma;
1017 	}
1018 	switch (result) {
1019 	case DETECTED_NONE:
1020 		pr_err("%s: no network cable attached to configured media\n",
1021 		       dev->name);
1022 		goto release_dma;
1023 	case DETECTED_RJ45H:
1024 		pr_info("%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
1025 		break;
1026 	case DETECTED_RJ45F:
1027 		pr_info("%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
1028 		break;
1029 	case DETECTED_AUI:
1030 		pr_info("%s: using 10Base-5 (AUI)\n", dev->name);
1031 		break;
1032 	case DETECTED_BNC:
1033 		pr_info("%s: using 10Base-2 (BNC)\n", dev->name);
1034 		break;
1035 	}
1036 
1037 	/* Turn on both receive and transmit operations */
1038 	writereg(dev, PP_LineCTL,
1039 		 readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1040 
1041 	/* Receive only error free packets addressed to this card */
1042 	lp->rx_mode = 0;
1043 	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
1044 
1045 	lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
1046 
1047 	if (lp->isa_config & STREAM_TRANSFER)
1048 		lp->curr_rx_cfg |= RX_STREAM_ENBL;
1049 #if ALLOW_DMA
1050 	set_dma_cfg(dev);
1051 #endif
1052 	writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
1053 
1054 	writereg(dev, PP_TxCFG, (TX_LOST_CRS_ENBL |
1055 				 TX_SQE_ERROR_ENBL |
1056 				 TX_OK_ENBL |
1057 				 TX_LATE_COL_ENBL |
1058 				 TX_JBR_ENBL |
1059 				 TX_ANY_COL_ENBL |
1060 				 TX_16_COL_ENBL));
1061 
1062 	writereg(dev, PP_BufCFG, (READY_FOR_TX_ENBL |
1063 				  RX_MISS_COUNT_OVRFLOW_ENBL |
1064 #if ALLOW_DMA
1065 				  dma_bufcfg(dev) |
1066 #endif
1067 				  TX_COL_COUNT_OVRFLOW_ENBL |
1068 				  TX_UNDERRUN_ENBL));
1069 
1070 	/* now that we've got our act together, enable everything */
1071 	writereg(dev, PP_BusCTL, (ENABLE_IRQ
1072 				  | (dev->mem_start ? MEMORY_ON : 0) /* turn memory on */
1073 #if ALLOW_DMA
1074 				  | dma_busctl(dev)
1075 #endif
1076 			 ));
1077 	netif_start_queue(dev);
1078 	cs89_dbg(1, debug, "net_open() succeeded\n");
1079 	return 0;
1080 bad_out:
1081 	return ret;
1082 }
1083 
1084 /* The inverse routine to net_open(). */
1085 static int
1086 net_close(struct net_device *dev)
1087 {
1088 #if ALLOW_DMA
1089 	struct net_local *lp = netdev_priv(dev);
1090 #endif
1091 
1092 	netif_stop_queue(dev);
1093 
1094 	writereg(dev, PP_RxCFG, 0);
1095 	writereg(dev, PP_TxCFG, 0);
1096 	writereg(dev, PP_BufCFG, 0);
1097 	writereg(dev, PP_BusCTL, 0);
1098 
1099 	free_irq(dev->irq, dev);
1100 
1101 #if ALLOW_DMA
1102 	if (lp->use_dma && lp->dma) {
1103 		free_dma(dev->dma);
1104 		release_dma_buff(lp);
1105 	}
1106 #endif
1107 
1108 	/* Update the statistics here. */
1109 	return 0;
1110 }
1111 
1112 /* Get the current statistics.
1113  * This may be called with the card open or closed.
1114  */
1115 static struct net_device_stats *
1116 net_get_stats(struct net_device *dev)
1117 {
1118 	struct net_local *lp = netdev_priv(dev);
1119 	unsigned long flags;
1120 
1121 	spin_lock_irqsave(&lp->lock, flags);
1122 	/* Update the statistics from the device registers. */
1123 	dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1124 	dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1125 	spin_unlock_irqrestore(&lp->lock, flags);
1126 
1127 	return &dev->stats;
1128 }
1129 
1130 static void net_timeout(struct net_device *dev)
1131 {
1132 	/* If we get here, some higher level has decided we are broken.
1133 	   There should really be a "kick me" function call instead. */
1134 	cs89_dbg(0, err, "%s: transmit timed out, %s?\n",
1135 		 dev->name,
1136 		 tx_done(dev) ? "IRQ conflict" : "network cable problem");
1137 	/* Try to restart the adaptor. */
1138 	netif_wake_queue(dev);
1139 }
1140 
1141 static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev)
1142 {
1143 	struct net_local *lp = netdev_priv(dev);
1144 	unsigned long flags;
1145 
1146 	cs89_dbg(3, debug, "%s: sent %d byte packet of type %x\n",
1147 		 dev->name, skb->len,
1148 		 ((skb->data[ETH_ALEN + ETH_ALEN] << 8) |
1149 		  skb->data[ETH_ALEN + ETH_ALEN + 1]));
1150 
1151 	/* keep the upload from being interrupted, since we
1152 	 * ask the chip to start transmitting before the
1153 	 * whole packet has been completely uploaded.
1154 	 */
1155 
1156 	spin_lock_irqsave(&lp->lock, flags);
1157 	netif_stop_queue(dev);
1158 
1159 	/* initiate a transmit sequence */
1160 	iowrite16(lp->send_cmd, lp->virt_addr + TX_CMD_PORT);
1161 	iowrite16(skb->len, lp->virt_addr + TX_LEN_PORT);
1162 
1163 	/* Test to see if the chip has allocated memory for the packet */
1164 	if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1165 		/* Gasp!  It hasn't.  But that shouldn't happen since
1166 		 * we're waiting for TxOk, so return 1 and requeue this packet.
1167 		 */
1168 
1169 		spin_unlock_irqrestore(&lp->lock, flags);
1170 		cs89_dbg(0, err, "Tx buffer not free!\n");
1171 		return NETDEV_TX_BUSY;
1172 	}
1173 	/* Write the contents of the packet */
1174 	writewords(lp, TX_FRAME_PORT, skb->data, (skb->len + 1) >> 1);
1175 	spin_unlock_irqrestore(&lp->lock, flags);
1176 	dev->stats.tx_bytes += skb->len;
1177 	dev_kfree_skb(skb);
1178 
1179 	/* We DO NOT call netif_wake_queue() here.
1180 	 * We also DO NOT call netif_start_queue().
1181 	 *
1182 	 * Either of these would cause another bottom half run through
1183 	 * net_send_packet() before this packet has fully gone out.
1184 	 * That causes us to hit the "Gasp!" above and the send is rescheduled.
1185 	 * it runs like a dog.  We just return and wait for the Tx completion
1186 	 * interrupt handler to restart the netdevice layer
1187 	 */
1188 
1189 	return NETDEV_TX_OK;
1190 }
1191 
1192 static void set_multicast_list(struct net_device *dev)
1193 {
1194 	struct net_local *lp = netdev_priv(dev);
1195 	unsigned long flags;
1196 	u16 cfg;
1197 
1198 	spin_lock_irqsave(&lp->lock, flags);
1199 	if (dev->flags & IFF_PROMISC)
1200 		lp->rx_mode = RX_ALL_ACCEPT;
1201 	else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev))
1202 		/* The multicast-accept list is initialized to accept-all,
1203 		 * and we rely on higher-level filtering for now.
1204 		 */
1205 		lp->rx_mode = RX_MULTCAST_ACCEPT;
1206 	else
1207 		lp->rx_mode = 0;
1208 
1209 	writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1210 
1211 	/* in promiscuous mode, we accept errored packets,
1212 	 * so we have to enable interrupts on them also
1213 	 */
1214 	cfg = lp->curr_rx_cfg;
1215 	if (lp->rx_mode == RX_ALL_ACCEPT)
1216 		cfg |= RX_CRC_ERROR_ENBL | RX_RUNT_ENBL | RX_EXTRA_DATA_ENBL;
1217 	writereg(dev, PP_RxCFG, cfg);
1218 	spin_unlock_irqrestore(&lp->lock, flags);
1219 }
1220 
1221 static int set_mac_address(struct net_device *dev, void *p)
1222 {
1223 	int i;
1224 	struct sockaddr *addr = p;
1225 
1226 	if (netif_running(dev))
1227 		return -EBUSY;
1228 
1229 	memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1230 
1231 	cs89_dbg(0, debug, "%s: Setting MAC address to %pM\n",
1232 		 dev->name, dev->dev_addr);
1233 
1234 	/* set the Ethernet address */
1235 	for (i = 0; i < ETH_ALEN / 2; i++)
1236 		writereg(dev, PP_IA + i * 2,
1237 			 (dev->dev_addr[i * 2] |
1238 			  (dev->dev_addr[i * 2 + 1] << 8)));
1239 
1240 	return 0;
1241 }
1242 
1243 #ifdef CONFIG_NET_POLL_CONTROLLER
1244 /*
1245  * Polling receive - used by netconsole and other diagnostic tools
1246  * to allow network i/o with interrupts disabled.
1247  */
1248 static void net_poll_controller(struct net_device *dev)
1249 {
1250 	disable_irq(dev->irq);
1251 	net_interrupt(dev->irq, dev);
1252 	enable_irq(dev->irq);
1253 }
1254 #endif
1255 
1256 static const struct net_device_ops net_ops = {
1257 	.ndo_open		= net_open,
1258 	.ndo_stop		= net_close,
1259 	.ndo_tx_timeout		= net_timeout,
1260 	.ndo_start_xmit		= net_send_packet,
1261 	.ndo_get_stats		= net_get_stats,
1262 	.ndo_set_rx_mode	= set_multicast_list,
1263 	.ndo_set_mac_address	= set_mac_address,
1264 #ifdef CONFIG_NET_POLL_CONTROLLER
1265 	.ndo_poll_controller	= net_poll_controller,
1266 #endif
1267 	.ndo_change_mtu		= eth_change_mtu,
1268 	.ndo_validate_addr	= eth_validate_addr,
1269 };
1270 
1271 static void __init reset_chip(struct net_device *dev)
1272 {
1273 #if !defined(CONFIG_MACH_MX31ADS)
1274 	struct net_local *lp = netdev_priv(dev);
1275 	int reset_start_time;
1276 
1277 	writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
1278 
1279 	/* wait 30 ms */
1280 	msleep(30);
1281 
1282 	if (lp->chip_type != CS8900) {
1283 		/* Hardware problem requires PNP registers to be reconfigured after a reset */
1284 		iowrite16(PP_CS8920_ISAINT, lp->virt_addr + ADD_PORT);
1285 		iowrite8(dev->irq, lp->virt_addr + DATA_PORT);
1286 		iowrite8(0, lp->virt_addr + DATA_PORT + 1);
1287 
1288 		iowrite16(PP_CS8920_ISAMemB, lp->virt_addr + ADD_PORT);
1289 		iowrite8((dev->mem_start >> 16) & 0xff,
1290 			 lp->virt_addr + DATA_PORT);
1291 		iowrite8((dev->mem_start >> 8) & 0xff,
1292 			 lp->virt_addr + DATA_PORT + 1);
1293 	}
1294 
1295 	/* Wait until the chip is reset */
1296 	reset_start_time = jiffies;
1297 	while ((readreg(dev, PP_SelfST) & INIT_DONE) == 0 &&
1298 	       jiffies - reset_start_time < 2)
1299 		;
1300 #endif /* !CONFIG_MACH_MX31ADS */
1301 }
1302 
1303 /* This is the real probe routine.
1304  * Linux has a history of friendly device probes on the ISA bus.
1305  * A good device probes avoids doing writes, and
1306  * verifies that the correct device exists and functions.
1307  * Return 0 on success.
1308  */
1309 static int __init
1310 cs89x0_probe1(struct net_device *dev, void __iomem *ioaddr, int modular)
1311 {
1312 	struct net_local *lp = netdev_priv(dev);
1313 	int i;
1314 	int tmp;
1315 	unsigned rev_type = 0;
1316 	int eeprom_buff[CHKSUM_LEN];
1317 	int retval;
1318 
1319 	/* Initialize the device structure. */
1320 	if (!modular) {
1321 		memset(lp, 0, sizeof(*lp));
1322 		spin_lock_init(&lp->lock);
1323 #ifndef MODULE
1324 #if ALLOW_DMA
1325 		if (g_cs89x0_dma) {
1326 			lp->use_dma = 1;
1327 			lp->dma = g_cs89x0_dma;
1328 			lp->dmasize = 16;	/* Could make this an option... */
1329 		}
1330 #endif
1331 		lp->force = g_cs89x0_media__force;
1332 #endif
1333 	}
1334 
1335 	pr_debug("PP_addr at %p[%x]: 0x%x\n",
1336 		 ioaddr, ADD_PORT, ioread16(ioaddr + ADD_PORT));
1337 	iowrite16(PP_ChipID, ioaddr + ADD_PORT);
1338 
1339 	tmp = ioread16(ioaddr + DATA_PORT);
1340 	if (tmp != CHIP_EISA_ID_SIG) {
1341 		pr_debug("%s: incorrect signature at %p[%x]: 0x%x!="
1342 			 CHIP_EISA_ID_SIG_STR "\n",
1343 			 dev->name, ioaddr, DATA_PORT, tmp);
1344 		retval = -ENODEV;
1345 		goto out1;
1346 	}
1347 
1348 	lp->virt_addr = ioaddr;
1349 
1350 	/* get the chip type */
1351 	rev_type = readreg(dev, PRODUCT_ID_ADD);
1352 	lp->chip_type = rev_type & ~REVISON_BITS;
1353 	lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
1354 
1355 	/* Check the chip type and revision in order to set the correct
1356 	 * send command.  CS8920 revision C and CS8900 revision F can use
1357 	 * the faster send.
1358 	 */
1359 	lp->send_cmd = TX_AFTER_381;
1360 	if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
1361 		lp->send_cmd = TX_NOW;
1362 	if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
1363 		lp->send_cmd = TX_NOW;
1364 
1365 	pr_info_once("%s\n", version);
1366 
1367 	pr_info("%s: cs89%c0%s rev %c found at %p ",
1368 		dev->name,
1369 		lp->chip_type == CS8900  ? '0' : '2',
1370 		lp->chip_type == CS8920M ? "M" : "",
1371 		lp->chip_revision,
1372 		lp->virt_addr);
1373 
1374 	reset_chip(dev);
1375 
1376 	/* Here we read the current configuration of the chip.
1377 	 * If there is no Extended EEPROM then the idea is to not disturb
1378 	 * the chip configuration, it should have been correctly setup by
1379 	 * automatic EEPROM read on reset. So, if the chip says it read
1380 	 * the EEPROM the driver will always do *something* instead of
1381 	 * complain that adapter_cnf is 0.
1382 	 */
1383 
1384 	if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
1385 	    (EEPROM_OK | EEPROM_PRESENT)) {
1386 		/* Load the MAC. */
1387 		for (i = 0; i < ETH_ALEN / 2; i++) {
1388 			unsigned int Addr;
1389 			Addr = readreg(dev, PP_IA + i * 2);
1390 			dev->dev_addr[i * 2] = Addr & 0xFF;
1391 			dev->dev_addr[i * 2 + 1] = Addr >> 8;
1392 		}
1393 
1394 		/* Load the Adapter Configuration.
1395 		 * Note:  Barring any more specific information from some
1396 		 * other source (ie EEPROM+Schematics), we would not know
1397 		 * how to operate a 10Base2 interface on the AUI port.
1398 		 * However, since we  do read the status of HCB1 and use
1399 		 * settings that always result in calls to control_dc_dc(dev,0)
1400 		 * a BNC interface should work if the enable pin
1401 		 * (dc/dc converter) is on HCB1.
1402 		 * It will be called AUI however.
1403 		 */
1404 
1405 		lp->adapter_cnf = 0;
1406 		i = readreg(dev, PP_LineCTL);
1407 		/* Preserve the setting of the HCB1 pin. */
1408 		if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
1409 			lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
1410 		/* Save the sqelch bit */
1411 		if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
1412 			lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
1413 		/* Check if the card is in 10Base-t only mode */
1414 		if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
1415 			lp->adapter_cnf |=  A_CNF_10B_T | A_CNF_MEDIA_10B_T;
1416 		/* Check if the card is in AUI only mode */
1417 		if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
1418 			lp->adapter_cnf |=  A_CNF_AUI | A_CNF_MEDIA_AUI;
1419 		/* Check if the card is in Auto mode. */
1420 		if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
1421 			lp->adapter_cnf |=  A_CNF_AUI | A_CNF_10B_T |
1422 				A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
1423 
1424 		cs89_dbg(1, info, "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
1425 			 dev->name, i, lp->adapter_cnf);
1426 
1427 		/* IRQ. Other chips already probe, see below. */
1428 		if (lp->chip_type == CS8900)
1429 			lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
1430 
1431 		pr_cont("[Cirrus EEPROM] ");
1432 	}
1433 
1434 	pr_cont("\n");
1435 
1436 	/* First check to see if an EEPROM is attached. */
1437 
1438 	if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
1439 		pr_warn("No EEPROM, relying on command line....\n");
1440 	else if (get_eeprom_data(dev, START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
1441 		pr_warn("EEPROM read failed, relying on command line\n");
1442 	} else if (get_eeprom_cksum(START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
1443 		/* Check if the chip was able to read its own configuration starting
1444 		   at 0 in the EEPROM*/
1445 		if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
1446 		    (EEPROM_OK | EEPROM_PRESENT))
1447 			pr_warn("Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
1448 
1449 	} else {
1450 		/* This reads an extended EEPROM that is not documented
1451 		 * in the CS8900 datasheet.
1452 		 */
1453 
1454 		/* get transmission control word  but keep the autonegotiation bits */
1455 		if (!lp->auto_neg_cnf)
1456 			lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET / 2];
1457 		/* Store adapter configuration */
1458 		if (!lp->adapter_cnf)
1459 			lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET / 2];
1460 		/* Store ISA configuration */
1461 		lp->isa_config = eeprom_buff[ISA_CNF_OFFSET / 2];
1462 		dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET / 2] << 8;
1463 
1464 		/* eeprom_buff has 32-bit ints, so we can't just memcpy it */
1465 		/* store the initial memory base address */
1466 		for (i = 0; i < ETH_ALEN / 2; i++) {
1467 			dev->dev_addr[i * 2] = eeprom_buff[i];
1468 			dev->dev_addr[i * 2 + 1] = eeprom_buff[i] >> 8;
1469 		}
1470 		cs89_dbg(1, debug, "%s: new adapter_cnf: 0x%x\n",
1471 			 dev->name, lp->adapter_cnf);
1472 	}
1473 
1474 	/* allow them to force multiple transceivers.  If they force multiple, autosense */
1475 	{
1476 		int count = 0;
1477 		if (lp->force & FORCE_RJ45) {
1478 			lp->adapter_cnf |= A_CNF_10B_T;
1479 			count++;
1480 		}
1481 		if (lp->force & FORCE_AUI) {
1482 			lp->adapter_cnf |= A_CNF_AUI;
1483 			count++;
1484 		}
1485 		if (lp->force & FORCE_BNC) {
1486 			lp->adapter_cnf |= A_CNF_10B_2;
1487 			count++;
1488 		}
1489 		if (count > 1)
1490 			lp->adapter_cnf |= A_CNF_MEDIA_AUTO;
1491 		else if (lp->force & FORCE_RJ45)
1492 			lp->adapter_cnf |= A_CNF_MEDIA_10B_T;
1493 		else if (lp->force & FORCE_AUI)
1494 			lp->adapter_cnf |= A_CNF_MEDIA_AUI;
1495 		else if (lp->force & FORCE_BNC)
1496 			lp->adapter_cnf |= A_CNF_MEDIA_10B_2;
1497 	}
1498 
1499 	cs89_dbg(1, debug, "%s: after force 0x%x, adapter_cnf=0x%x\n",
1500 		 dev->name, lp->force, lp->adapter_cnf);
1501 
1502 	/* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
1503 
1504 	/* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
1505 
1506 	/* FIXME: we don't set the Ethernet address on the command line.  Use
1507 	 * ifconfig IFACE hw ether AABBCCDDEEFF
1508 	 */
1509 
1510 	pr_info("media %s%s%s",
1511 		(lp->adapter_cnf & A_CNF_10B_T) ? "RJ-45," : "",
1512 		(lp->adapter_cnf & A_CNF_AUI) ? "AUI," : "",
1513 		(lp->adapter_cnf & A_CNF_10B_2) ? "BNC," : "");
1514 
1515 	lp->irq_map = 0xffff;
1516 
1517 	/* If this is a CS8900 then no pnp soft */
1518 	if (lp->chip_type != CS8900 &&
1519 	    /* Check if the ISA IRQ has been set  */
1520 	    (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
1521 	     (i != 0 && i < CS8920_NO_INTS))) {
1522 		if (!dev->irq)
1523 			dev->irq = i;
1524 	} else {
1525 		i = lp->isa_config & INT_NO_MASK;
1526 #ifndef CONFIG_CS89x0_PLATFORM
1527 		if (lp->chip_type == CS8900) {
1528 			/* Translate the IRQ using the IRQ mapping table. */
1529 			if (i >= ARRAY_SIZE(cs8900_irq_map))
1530 				pr_err("invalid ISA interrupt number %d\n", i);
1531 			else
1532 				i = cs8900_irq_map[i];
1533 
1534 			lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
1535 		} else {
1536 			int irq_map_buff[IRQ_MAP_LEN/2];
1537 
1538 			if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
1539 					    IRQ_MAP_LEN / 2,
1540 					    irq_map_buff) >= 0) {
1541 				if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
1542 					lp->irq_map = ((irq_map_buff[0] >> 8) |
1543 						       (irq_map_buff[1] << 8));
1544 			}
1545 		}
1546 #endif
1547 		if (!dev->irq)
1548 			dev->irq = i;
1549 	}
1550 
1551 	pr_cont(" IRQ %d", dev->irq);
1552 
1553 #if ALLOW_DMA
1554 	if (lp->use_dma) {
1555 		get_dma_channel(dev);
1556 		pr_cont(", DMA %d", dev->dma);
1557 	} else
1558 #endif
1559 		pr_cont(", programmed I/O");
1560 
1561 	/* print the ethernet address. */
1562 	pr_cont(", MAC %pM\n", dev->dev_addr);
1563 
1564 	dev->netdev_ops	= &net_ops;
1565 	dev->watchdog_timeo = HZ;
1566 
1567 	cs89_dbg(0, info, "cs89x0_probe1() successful\n");
1568 
1569 	retval = register_netdev(dev);
1570 	if (retval)
1571 		goto out2;
1572 	return 0;
1573 out2:
1574 	iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1575 out1:
1576 	return retval;
1577 }
1578 
1579 #ifndef CONFIG_CS89x0_PLATFORM
1580 /*
1581  * This function converts the I/O port addres used by the cs89x0_probe() and
1582  * init_module() functions to the I/O memory address used by the
1583  * cs89x0_probe1() function.
1584  */
1585 static int __init
1586 cs89x0_ioport_probe(struct net_device *dev, unsigned long ioport, int modular)
1587 {
1588 	struct net_local *lp = netdev_priv(dev);
1589 	int ret;
1590 	void __iomem *io_mem;
1591 
1592 	if (!lp)
1593 		return -ENOMEM;
1594 
1595 	dev->base_addr = ioport;
1596 
1597 	if (!request_region(ioport, NETCARD_IO_EXTENT, DRV_NAME)) {
1598 		ret = -EBUSY;
1599 		goto out;
1600 	}
1601 
1602 	io_mem = ioport_map(ioport & ~3, NETCARD_IO_EXTENT);
1603 	if (!io_mem) {
1604 		ret = -ENOMEM;
1605 		goto release;
1606 	}
1607 
1608 	/* if they give us an odd I/O address, then do ONE write to
1609 	 * the address port, to get it back to address zero, where we
1610 	 * expect to find the EISA signature word. An IO with a base of 0x3
1611 	 * will skip the test for the ADD_PORT.
1612 	 */
1613 	if (ioport & 1) {
1614 		cs89_dbg(1, info, "%s: odd ioaddr 0x%lx\n", dev->name, ioport);
1615 		if ((ioport & 2) != 2) {
1616 			if ((ioread16(io_mem + ADD_PORT) & ADD_MASK) !=
1617 			    ADD_SIG) {
1618 				pr_err("%s: bad signature 0x%x\n",
1619 				       dev->name, ioread16(io_mem + ADD_PORT));
1620 				ret = -ENODEV;
1621 				goto unmap;
1622 			}
1623 		}
1624 	}
1625 
1626 	ret = cs89x0_probe1(dev, io_mem, modular);
1627 	if (!ret)
1628 		goto out;
1629 unmap:
1630 	ioport_unmap(io_mem);
1631 release:
1632 	release_region(ioport, NETCARD_IO_EXTENT);
1633 out:
1634 	return ret;
1635 }
1636 
1637 #ifndef MODULE
1638 /* Check for a network adaptor of this type, and return '0' iff one exists.
1639  * If dev->base_addr == 0, probe all likely locations.
1640  * If dev->base_addr == 1, always return failure.
1641  * If dev->base_addr == 2, allocate space for the device and return success
1642  * (detachable devices only).
1643  * Return 0 on success.
1644  */
1645 
1646 struct net_device * __init cs89x0_probe(int unit)
1647 {
1648 	struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1649 	unsigned *port;
1650 	int err = 0;
1651 	int irq;
1652 	int io;
1653 
1654 	if (!dev)
1655 		return ERR_PTR(-ENODEV);
1656 
1657 	sprintf(dev->name, "eth%d", unit);
1658 	netdev_boot_setup_check(dev);
1659 	io = dev->base_addr;
1660 	irq = dev->irq;
1661 
1662 	cs89_dbg(0, info, "cs89x0_probe(0x%x)\n", io);
1663 
1664 	if (io > 0x1ff)	{	/* Check a single specified location. */
1665 		err = cs89x0_ioport_probe(dev, io, 0);
1666 	} else if (io != 0) {	/* Don't probe at all. */
1667 		err = -ENXIO;
1668 	} else {
1669 		for (port = netcard_portlist; *port; port++) {
1670 			if (cs89x0_ioport_probe(dev, *port, 0) == 0)
1671 				break;
1672 			dev->irq = irq;
1673 		}
1674 		if (!*port)
1675 			err = -ENODEV;
1676 	}
1677 	if (err)
1678 		goto out;
1679 	return dev;
1680 out:
1681 	free_netdev(dev);
1682 	pr_warn("no cs8900 or cs8920 detected.  Be sure to disable PnP with SETUP\n");
1683 	return ERR_PTR(err);
1684 }
1685 #endif
1686 #endif
1687 
1688 #if defined(MODULE) && !defined(CONFIG_CS89x0_PLATFORM)
1689 
1690 static struct net_device *dev_cs89x0;
1691 
1692 /* Support the 'debug' module parm even if we're compiled for non-debug to
1693  * avoid breaking someone's startup scripts
1694  */
1695 
1696 static int io;
1697 static int irq;
1698 static int debug;
1699 static char media[8];
1700 static int duplex = -1;
1701 
1702 static int use_dma;			/* These generate unused var warnings if ALLOW_DMA = 0 */
1703 static int dma;
1704 static int dmasize = 16;		/* or 64 */
1705 
1706 module_param(io, int, 0);
1707 module_param(irq, int, 0);
1708 module_param(debug, int, 0);
1709 module_param_string(media, media, sizeof(media), 0);
1710 module_param(duplex, int, 0);
1711 module_param(dma , int, 0);
1712 module_param(dmasize , int, 0);
1713 module_param(use_dma , int, 0);
1714 MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1715 MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1716 #if DEBUGGING
1717 MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1718 #else
1719 MODULE_PARM_DESC(debug, "(ignored)");
1720 #endif
1721 MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1722 /* No other value than -1 for duplex seems to be currently interpreted */
1723 MODULE_PARM_DESC(duplex, "(ignored)");
1724 #if ALLOW_DMA
1725 MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1726 MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1727 MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1728 #else
1729 MODULE_PARM_DESC(dma , "(ignored)");
1730 MODULE_PARM_DESC(dmasize , "(ignored)");
1731 MODULE_PARM_DESC(use_dma , "(ignored)");
1732 #endif
1733 
1734 MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
1735 MODULE_LICENSE("GPL");
1736 
1737 /*
1738  * media=t             - specify media type
1739  * or media=2
1740  * or media=aui
1741  * or medai=auto
1742  * duplex=0            - specify forced half/full/autonegotiate duplex
1743  * debug=#             - debug level
1744  *
1745  * Default Chip Configuration:
1746  * DMA Burst = enabled
1747  * IOCHRDY Enabled = enabled
1748  * UseSA = enabled
1749  * CS8900 defaults to half-duplex if not specified on command-line
1750  * CS8920 defaults to autoneg if not specified on command-line
1751  * Use reset defaults for other config parameters
1752  *
1753  * Assumptions:
1754  * media type specified is supported (circuitry is present)
1755  * if memory address is > 1MB, then required mem decode hw is present
1756  * if 10B-2, then agent other than driver will enable DC/DC converter
1757  * (hw or software util)
1758  */
1759 
1760 int __init init_module(void)
1761 {
1762 	struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1763 	struct net_local *lp;
1764 	int ret = 0;
1765 
1766 #if DEBUGGING
1767 	net_debug = debug;
1768 #else
1769 	debug = 0;
1770 #endif
1771 	if (!dev)
1772 		return -ENOMEM;
1773 
1774 	dev->irq = irq;
1775 	dev->base_addr = io;
1776 	lp = netdev_priv(dev);
1777 
1778 #if ALLOW_DMA
1779 	if (use_dma) {
1780 		lp->use_dma = use_dma;
1781 		lp->dma = dma;
1782 		lp->dmasize = dmasize;
1783 	}
1784 #endif
1785 
1786 	spin_lock_init(&lp->lock);
1787 
1788 	/* boy, they'd better get these right */
1789 	if (!strcmp(media, "rj45"))
1790 		lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1791 	else if (!strcmp(media, "aui"))
1792 		lp->adapter_cnf = A_CNF_MEDIA_AUI   | A_CNF_AUI;
1793 	else if (!strcmp(media, "bnc"))
1794 		lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1795 	else
1796 		lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1797 
1798 	if (duplex == -1)
1799 		lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1800 
1801 	if (io == 0) {
1802 		pr_err("Module autoprobing not allowed\n");
1803 		pr_err("Append io=0xNNN\n");
1804 		ret = -EPERM;
1805 		goto out;
1806 	} else if (io <= 0x1ff) {
1807 		ret = -ENXIO;
1808 		goto out;
1809 	}
1810 
1811 #if ALLOW_DMA
1812 	if (use_dma && dmasize != 16 && dmasize != 64) {
1813 		pr_err("dma size must be either 16K or 64K, not %dK\n",
1814 		       dmasize);
1815 		ret = -EPERM;
1816 		goto out;
1817 	}
1818 #endif
1819 	ret = cs89x0_ioport_probe(dev, io, 1);
1820 	if (ret)
1821 		goto out;
1822 
1823 	dev_cs89x0 = dev;
1824 	return 0;
1825 out:
1826 	free_netdev(dev);
1827 	return ret;
1828 }
1829 
1830 void __exit
1831 cleanup_module(void)
1832 {
1833 	struct net_local *lp = netdev_priv(dev_cs89x0);
1834 
1835 	unregister_netdev(dev_cs89x0);
1836 	iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1837 	ioport_unmap(lp->virt_addr);
1838 	release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1839 	free_netdev(dev_cs89x0);
1840 }
1841 #endif /* MODULE && !CONFIG_CS89x0_PLATFORM */
1842 
1843 #ifdef CONFIG_CS89x0_PLATFORM
1844 static int __init cs89x0_platform_probe(struct platform_device *pdev)
1845 {
1846 	struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1847 	struct net_local *lp;
1848 	struct resource *mem_res;
1849 	void __iomem *virt_addr;
1850 	int err;
1851 
1852 	if (!dev)
1853 		return -ENOMEM;
1854 
1855 	lp = netdev_priv(dev);
1856 
1857 	mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1858 	dev->irq = platform_get_irq(pdev, 0);
1859 	if (mem_res == NULL || dev->irq <= 0) {
1860 		dev_warn(&dev->dev, "memory/interrupt resource missing\n");
1861 		err = -ENXIO;
1862 		goto free;
1863 	}
1864 
1865 	lp->size = resource_size(mem_res);
1866 	if (!request_mem_region(mem_res->start, lp->size, DRV_NAME)) {
1867 		dev_warn(&dev->dev, "request_mem_region() failed\n");
1868 		err = -EBUSY;
1869 		goto free;
1870 	}
1871 
1872 	virt_addr = ioremap(mem_res->start, lp->size);
1873 	if (!virt_addr) {
1874 		dev_warn(&dev->dev, "ioremap() failed\n");
1875 		err = -ENOMEM;
1876 		goto release;
1877 	}
1878 
1879 	err = cs89x0_probe1(dev, virt_addr, 0);
1880 	if (err) {
1881 		dev_warn(&dev->dev, "no cs8900 or cs8920 detected\n");
1882 		goto unmap;
1883 	}
1884 
1885 	platform_set_drvdata(pdev, dev);
1886 	return 0;
1887 
1888 unmap:
1889 	iounmap(virt_addr);
1890 release:
1891 	release_mem_region(mem_res->start, lp->size);
1892 free:
1893 	free_netdev(dev);
1894 	return err;
1895 }
1896 
1897 static int cs89x0_platform_remove(struct platform_device *pdev)
1898 {
1899 	struct net_device *dev = platform_get_drvdata(pdev);
1900 	struct net_local *lp = netdev_priv(dev);
1901 	struct resource *mem_res;
1902 
1903 	/* This platform_get_resource() call will not return NULL, because
1904 	 * the same call in cs89x0_platform_probe() has returned a non NULL
1905 	 * value.
1906 	 */
1907 	mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1908 	unregister_netdev(dev);
1909 	iounmap(lp->virt_addr);
1910 	release_mem_region(mem_res->start, lp->size);
1911 	free_netdev(dev);
1912 	return 0;
1913 }
1914 
1915 static struct platform_driver cs89x0_driver = {
1916 	.driver	= {
1917 		.name	= DRV_NAME,
1918 		.owner	= THIS_MODULE,
1919 	},
1920 	.remove	= cs89x0_platform_remove,
1921 };
1922 
1923 module_platform_driver_probe(cs89x0_driver, cs89x0_platform_probe);
1924 
1925 #endif /* CONFIG_CS89x0_PLATFORM */
1926