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