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