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