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
dma_fn(char * str)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
media_fn(char * str)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
readwords(struct net_local * lp,int portno,void * buf,int length)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
writewords(struct net_local * lp,int portno,void * buf,int length)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
readreg(struct net_device * dev,u16 regno)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
writereg(struct net_device * dev,u16 regno,u16 value)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
wait_eeprom_ready(struct net_device * dev)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
get_eeprom_data(struct net_device * dev,int off,int len,int * buffer)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
get_eeprom_cksum(int off,int len,int * buffer)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
write_irq(struct net_device * dev,int chip_type,int irq)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
count_rx_errors(int status,struct net_device * dev)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
get_dma_channel(struct net_device * dev)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
write_dma(struct net_device * dev,int chip_type,int dma)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
set_dma_cfg(struct net_device * dev)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
dma_bufcfg(struct net_device * dev)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
dma_busctl(struct net_device * dev)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
dma_rx(struct net_device * dev)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
release_dma_buff(struct net_local * lp)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
control_dc_dc(struct net_device * dev,int on_not_off)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
send_test_pkt(struct net_device * dev)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
detect_tp(struct net_device * dev)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
detect_bnc(struct net_device * dev)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
detect_aui(struct net_device * dev)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
net_rx(struct net_device * dev)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
net_interrupt(int irq,void * dev_id)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
net_open(struct net_device * dev)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
net_close(struct net_device * dev)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 *
net_get_stats(struct net_device * dev)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
net_timeout(struct net_device * dev,unsigned int txqueue)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
net_send_packet(struct sk_buff * skb,struct net_device * dev)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
set_multicast_list(struct net_device * dev)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
set_mac_address(struct net_device * dev,void * p)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 */
net_poll_controller(struct net_device * dev)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
reset_chip(struct net_device * dev)1272 static void __init reset_chip(struct net_device *dev)
1273 {
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 }
1301
1302 /* This is the real probe routine.
1303 * Linux has a history of friendly device probes on the ISA bus.
1304 * A good device probes avoids doing writes, and
1305 * verifies that the correct device exists and functions.
1306 * Return 0 on success.
1307 */
1308 static int __init
cs89x0_probe1(struct net_device * dev,void __iomem * ioaddr,int modular)1309 cs89x0_probe1(struct net_device *dev, void __iomem *ioaddr, int modular)
1310 {
1311 struct net_local *lp = netdev_priv(dev);
1312 int i;
1313 int tmp;
1314 unsigned rev_type = 0;
1315 int eeprom_buff[CHKSUM_LEN];
1316 u8 addr[ETH_ALEN];
1317 int retval;
1318
1319 /* Initialize the device structure. */
1320 if (!modular) {
1321 memset(lp, 0, sizeof(*lp));
1322 spin_lock_init(&lp->lock);
1323 #ifndef MODULE
1324 #if ALLOW_DMA
1325 if (g_cs89x0_dma) {
1326 lp->use_dma = 1;
1327 lp->dma = g_cs89x0_dma;
1328 lp->dmasize = 16; /* Could make this an option... */
1329 }
1330 #endif
1331 lp->force = g_cs89x0_media__force;
1332 #endif
1333 }
1334
1335 pr_debug("PP_addr at %p[%x]: 0x%x\n",
1336 ioaddr, ADD_PORT, ioread16(ioaddr + ADD_PORT));
1337 iowrite16(PP_ChipID, ioaddr + ADD_PORT);
1338
1339 tmp = ioread16(ioaddr + DATA_PORT);
1340 if (tmp != CHIP_EISA_ID_SIG) {
1341 pr_debug("%s: incorrect signature at %p[%x]: 0x%x!="
1342 CHIP_EISA_ID_SIG_STR "\n",
1343 dev->name, ioaddr, DATA_PORT, tmp);
1344 retval = -ENODEV;
1345 goto out1;
1346 }
1347
1348 lp->virt_addr = ioaddr;
1349
1350 /* get the chip type */
1351 rev_type = readreg(dev, PRODUCT_ID_ADD);
1352 lp->chip_type = rev_type & ~REVISON_BITS;
1353 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
1354
1355 /* Check the chip type and revision in order to set the correct
1356 * send command. CS8920 revision C and CS8900 revision F can use
1357 * the faster send.
1358 */
1359 lp->send_cmd = TX_AFTER_381;
1360 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
1361 lp->send_cmd = TX_NOW;
1362 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
1363 lp->send_cmd = TX_NOW;
1364
1365 pr_info_once("%s\n", version);
1366
1367 pr_info("%s: cs89%c0%s rev %c found at %p ",
1368 dev->name,
1369 lp->chip_type == CS8900 ? '0' : '2',
1370 lp->chip_type == CS8920M ? "M" : "",
1371 lp->chip_revision,
1372 lp->virt_addr);
1373
1374 reset_chip(dev);
1375
1376 /* Here we read the current configuration of the chip.
1377 * If there is no Extended EEPROM then the idea is to not disturb
1378 * the chip configuration, it should have been correctly setup by
1379 * automatic EEPROM read on reset. So, if the chip says it read
1380 * the EEPROM the driver will always do *something* instead of
1381 * complain that adapter_cnf is 0.
1382 */
1383
1384 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
1385 (EEPROM_OK | EEPROM_PRESENT)) {
1386 /* Load the MAC. */
1387 for (i = 0; i < ETH_ALEN / 2; i++) {
1388 unsigned int Addr;
1389 Addr = readreg(dev, PP_IA + i * 2);
1390 addr[i * 2] = Addr & 0xFF;
1391 addr[i * 2 + 1] = Addr >> 8;
1392 }
1393 eth_hw_addr_set(dev, addr);
1394
1395 /* Load the Adapter Configuration.
1396 * Note: Barring any more specific information from some
1397 * other source (ie EEPROM+Schematics), we would not know
1398 * how to operate a 10Base2 interface on the AUI port.
1399 * However, since we do read the status of HCB1 and use
1400 * settings that always result in calls to control_dc_dc(dev,0)
1401 * a BNC interface should work if the enable pin
1402 * (dc/dc converter) is on HCB1.
1403 * It will be called AUI however.
1404 */
1405
1406 lp->adapter_cnf = 0;
1407 i = readreg(dev, PP_LineCTL);
1408 /* Preserve the setting of the HCB1 pin. */
1409 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
1410 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
1411 /* Save the sqelch bit */
1412 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
1413 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
1414 /* Check if the card is in 10Base-t only mode */
1415 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
1416 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
1417 /* Check if the card is in AUI only mode */
1418 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
1419 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
1420 /* Check if the card is in Auto mode. */
1421 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
1422 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
1423 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
1424
1425 cs89_dbg(1, info, "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
1426 dev->name, i, lp->adapter_cnf);
1427
1428 /* IRQ. Other chips already probe, see below. */
1429 if (lp->chip_type == CS8900)
1430 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
1431
1432 pr_cont("[Cirrus EEPROM] ");
1433 }
1434
1435 pr_cont("\n");
1436
1437 /* First check to see if an EEPROM is attached. */
1438
1439 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
1440 pr_warn("No EEPROM, relying on command line....\n");
1441 else if (get_eeprom_data(dev, START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
1442 pr_warn("EEPROM read failed, relying on command line\n");
1443 } else if (get_eeprom_cksum(START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
1444 /* Check if the chip was able to read its own configuration starting
1445 at 0 in the EEPROM*/
1446 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
1447 (EEPROM_OK | EEPROM_PRESENT))
1448 pr_warn("Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
1449
1450 } else {
1451 /* This reads an extended EEPROM that is not documented
1452 * in the CS8900 datasheet.
1453 */
1454
1455 /* get transmission control word but keep the autonegotiation bits */
1456 if (!lp->auto_neg_cnf)
1457 lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET / 2];
1458 /* Store adapter configuration */
1459 if (!lp->adapter_cnf)
1460 lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET / 2];
1461 /* Store ISA configuration */
1462 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET / 2];
1463 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET / 2] << 8;
1464
1465 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */
1466 /* store the initial memory base address */
1467 for (i = 0; i < ETH_ALEN / 2; i++) {
1468 addr[i * 2] = eeprom_buff[i];
1469 addr[i * 2 + 1] = eeprom_buff[i] >> 8;
1470 }
1471 eth_hw_addr_set(dev, addr);
1472 cs89_dbg(1, debug, "%s: new adapter_cnf: 0x%x\n",
1473 dev->name, lp->adapter_cnf);
1474 }
1475
1476 /* allow them to force multiple transceivers. If they force multiple, autosense */
1477 {
1478 int count = 0;
1479 if (lp->force & FORCE_RJ45) {
1480 lp->adapter_cnf |= A_CNF_10B_T;
1481 count++;
1482 }
1483 if (lp->force & FORCE_AUI) {
1484 lp->adapter_cnf |= A_CNF_AUI;
1485 count++;
1486 }
1487 if (lp->force & FORCE_BNC) {
1488 lp->adapter_cnf |= A_CNF_10B_2;
1489 count++;
1490 }
1491 if (count > 1)
1492 lp->adapter_cnf |= A_CNF_MEDIA_AUTO;
1493 else if (lp->force & FORCE_RJ45)
1494 lp->adapter_cnf |= A_CNF_MEDIA_10B_T;
1495 else if (lp->force & FORCE_AUI)
1496 lp->adapter_cnf |= A_CNF_MEDIA_AUI;
1497 else if (lp->force & FORCE_BNC)
1498 lp->adapter_cnf |= A_CNF_MEDIA_10B_2;
1499 }
1500
1501 cs89_dbg(1, debug, "%s: after force 0x%x, adapter_cnf=0x%x\n",
1502 dev->name, lp->force, lp->adapter_cnf);
1503
1504 /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
1505
1506 /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
1507
1508 /* FIXME: we don't set the Ethernet address on the command line. Use
1509 * ifconfig IFACE hw ether AABBCCDDEEFF
1510 */
1511
1512 pr_info("media %s%s%s",
1513 (lp->adapter_cnf & A_CNF_10B_T) ? "RJ-45," : "",
1514 (lp->adapter_cnf & A_CNF_AUI) ? "AUI," : "",
1515 (lp->adapter_cnf & A_CNF_10B_2) ? "BNC," : "");
1516
1517 lp->irq_map = 0xffff;
1518
1519 /* If this is a CS8900 then no pnp soft */
1520 if (lp->chip_type != CS8900 &&
1521 /* Check if the ISA IRQ has been set */
1522 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
1523 (i != 0 && i < CS8920_NO_INTS))) {
1524 if (!dev->irq)
1525 dev->irq = i;
1526 } else {
1527 i = lp->isa_config & INT_NO_MASK;
1528 #if IS_ENABLED(CONFIG_CS89x0_ISA)
1529 if (lp->chip_type == CS8900) {
1530 /* Translate the IRQ using the IRQ mapping table. */
1531 if (i >= ARRAY_SIZE(cs8900_irq_map))
1532 pr_err("invalid ISA interrupt number %d\n", i);
1533 else
1534 i = cs8900_irq_map[i];
1535
1536 lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
1537 } else {
1538 int irq_map_buff[IRQ_MAP_LEN/2];
1539
1540 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
1541 IRQ_MAP_LEN / 2,
1542 irq_map_buff) >= 0) {
1543 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
1544 lp->irq_map = ((irq_map_buff[0] >> 8) |
1545 (irq_map_buff[1] << 8));
1546 }
1547 }
1548 #endif
1549 if (!dev->irq)
1550 dev->irq = i;
1551 }
1552
1553 pr_cont(" IRQ %d", dev->irq);
1554
1555 #if ALLOW_DMA
1556 if (lp->use_dma) {
1557 get_dma_channel(dev);
1558 pr_cont(", DMA %d", dev->dma);
1559 } else
1560 #endif
1561 pr_cont(", programmed I/O");
1562
1563 /* print the ethernet address. */
1564 pr_cont(", MAC %pM\n", dev->dev_addr);
1565
1566 dev->netdev_ops = &net_ops;
1567 dev->watchdog_timeo = HZ;
1568
1569 cs89_dbg(0, info, "cs89x0_probe1() successful\n");
1570
1571 retval = register_netdev(dev);
1572 if (retval)
1573 goto out2;
1574 return 0;
1575 out2:
1576 iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1577 out1:
1578 return retval;
1579 }
1580
1581 #if IS_ENABLED(CONFIG_CS89x0_ISA)
1582 /*
1583 * This function converts the I/O port address used by the cs89x0_probe() and
1584 * init_module() functions to the I/O memory address used by the
1585 * cs89x0_probe1() function.
1586 */
1587 static int __init
cs89x0_ioport_probe(struct net_device * dev,unsigned long ioport,int modular)1588 cs89x0_ioport_probe(struct net_device *dev, unsigned long ioport, int modular)
1589 {
1590 struct net_local *lp = netdev_priv(dev);
1591 int ret;
1592 void __iomem *io_mem;
1593
1594 if (!lp)
1595 return -ENOMEM;
1596
1597 dev->base_addr = ioport;
1598
1599 if (!request_region(ioport, NETCARD_IO_EXTENT, DRV_NAME)) {
1600 ret = -EBUSY;
1601 goto out;
1602 }
1603
1604 io_mem = ioport_map(ioport & ~3, NETCARD_IO_EXTENT);
1605 if (!io_mem) {
1606 ret = -ENOMEM;
1607 goto release;
1608 }
1609
1610 /* if they give us an odd I/O address, then do ONE write to
1611 * the address port, to get it back to address zero, where we
1612 * expect to find the EISA signature word. An IO with a base of 0x3
1613 * will skip the test for the ADD_PORT.
1614 */
1615 if (ioport & 1) {
1616 cs89_dbg(1, info, "%s: odd ioaddr 0x%lx\n", dev->name, ioport);
1617 if ((ioport & 2) != 2) {
1618 if ((ioread16(io_mem + ADD_PORT) & ADD_MASK) !=
1619 ADD_SIG) {
1620 pr_err("%s: bad signature 0x%x\n",
1621 dev->name, ioread16(io_mem + ADD_PORT));
1622 ret = -ENODEV;
1623 goto unmap;
1624 }
1625 }
1626 }
1627
1628 ret = cs89x0_probe1(dev, io_mem, modular);
1629 if (!ret)
1630 goto out;
1631 unmap:
1632 ioport_unmap(io_mem);
1633 release:
1634 release_region(ioport, NETCARD_IO_EXTENT);
1635 out:
1636 return ret;
1637 }
1638
1639 #ifndef MODULE
1640 /* Check for a network adaptor of this type, and return '0' iff one exists.
1641 * If dev->base_addr == 0, probe all likely locations.
1642 * If dev->base_addr == 1, always return failure.
1643 * If dev->base_addr == 2, allocate space for the device and return success
1644 * (detachable devices only).
1645 * Return 0 on success.
1646 */
1647
cs89x0_probe(int unit)1648 struct net_device * __init cs89x0_probe(int unit)
1649 {
1650 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1651 unsigned *port;
1652 int err = 0;
1653 int irq;
1654 int io;
1655
1656 if (!dev)
1657 return ERR_PTR(-ENODEV);
1658
1659 sprintf(dev->name, "eth%d", unit);
1660 netdev_boot_setup_check(dev);
1661 io = dev->base_addr;
1662 irq = dev->irq;
1663
1664 cs89_dbg(0, info, "cs89x0_probe(0x%x)\n", io);
1665
1666 if (io > 0x1ff) { /* Check a single specified location. */
1667 err = cs89x0_ioport_probe(dev, io, 0);
1668 } else if (io != 0) { /* Don't probe at all. */
1669 err = -ENXIO;
1670 } else {
1671 for (port = netcard_portlist; *port; port++) {
1672 if (cs89x0_ioport_probe(dev, *port, 0) == 0)
1673 break;
1674 dev->irq = irq;
1675 }
1676 if (!*port)
1677 err = -ENODEV;
1678 }
1679 if (err)
1680 goto out;
1681 return dev;
1682 out:
1683 free_netdev(dev);
1684 pr_warn("no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
1685 return ERR_PTR(err);
1686 }
1687 #else
1688 static struct net_device *dev_cs89x0;
1689
1690 /* Support the 'debug' module parm even if we're compiled for non-debug to
1691 * avoid breaking someone's startup scripts
1692 */
1693
1694 static int io;
1695 static int irq;
1696 static int debug;
1697 static char media[8];
1698 static int duplex = -1;
1699
1700 static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
1701 static int dma;
1702 static int dmasize = 16; /* or 64 */
1703
1704 module_param_hw(io, int, ioport, 0);
1705 module_param_hw(irq, int, irq, 0);
1706 module_param(debug, int, 0);
1707 module_param_string(media, media, sizeof(media), 0);
1708 module_param(duplex, int, 0);
1709 module_param_hw(dma , int, dma, 0);
1710 module_param(dmasize , int, 0);
1711 module_param(use_dma , int, 0);
1712 MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1713 MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1714 #if DEBUGGING
1715 MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1716 #else
1717 MODULE_PARM_DESC(debug, "(ignored)");
1718 #endif
1719 MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1720 /* No other value than -1 for duplex seems to be currently interpreted */
1721 MODULE_PARM_DESC(duplex, "(ignored)");
1722 #if ALLOW_DMA
1723 MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1724 MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1725 MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1726 #else
1727 MODULE_PARM_DESC(dma , "(ignored)");
1728 MODULE_PARM_DESC(dmasize , "(ignored)");
1729 MODULE_PARM_DESC(use_dma , "(ignored)");
1730 #endif
1731
1732 MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
1733 MODULE_LICENSE("GPL");
1734
1735 /*
1736 * media=t - specify media type
1737 * or media=2
1738 * or media=aui
1739 * or medai=auto
1740 * duplex=0 - specify forced half/full/autonegotiate duplex
1741 * debug=# - debug level
1742 *
1743 * Default Chip Configuration:
1744 * DMA Burst = enabled
1745 * IOCHRDY Enabled = enabled
1746 * UseSA = enabled
1747 * CS8900 defaults to half-duplex if not specified on command-line
1748 * CS8920 defaults to autoneg if not specified on command-line
1749 * Use reset defaults for other config parameters
1750 *
1751 * Assumptions:
1752 * media type specified is supported (circuitry is present)
1753 * if memory address is > 1MB, then required mem decode hw is present
1754 * if 10B-2, then agent other than driver will enable DC/DC converter
1755 * (hw or software util)
1756 */
1757
cs89x0_isa_init_module(void)1758 static int __init cs89x0_isa_init_module(void)
1759 {
1760 struct net_device *dev;
1761 struct net_local *lp;
1762 int ret = 0;
1763
1764 #if DEBUGGING
1765 net_debug = debug;
1766 #else
1767 debug = 0;
1768 #endif
1769 dev = alloc_etherdev(sizeof(struct net_local));
1770 if (!dev)
1771 return -ENOMEM;
1772
1773 dev->irq = irq;
1774 dev->base_addr = io;
1775 lp = netdev_priv(dev);
1776
1777 #if ALLOW_DMA
1778 if (use_dma) {
1779 lp->use_dma = use_dma;
1780 lp->dma = dma;
1781 lp->dmasize = dmasize;
1782 }
1783 #endif
1784
1785 spin_lock_init(&lp->lock);
1786
1787 /* boy, they'd better get these right */
1788 if (!strcmp(media, "rj45"))
1789 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1790 else if (!strcmp(media, "aui"))
1791 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1792 else if (!strcmp(media, "bnc"))
1793 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1794 else
1795 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1796
1797 if (duplex == -1)
1798 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1799
1800 if (io == 0) {
1801 pr_err("Module autoprobing not allowed\n");
1802 pr_err("Append io=0xNNN\n");
1803 ret = -EPERM;
1804 goto out;
1805 } else if (io <= 0x1ff) {
1806 ret = -ENXIO;
1807 goto out;
1808 }
1809
1810 #if ALLOW_DMA
1811 if (use_dma && dmasize != 16 && dmasize != 64) {
1812 pr_err("dma size must be either 16K or 64K, not %dK\n",
1813 dmasize);
1814 ret = -EPERM;
1815 goto out;
1816 }
1817 #endif
1818 ret = cs89x0_ioport_probe(dev, io, 1);
1819 if (ret)
1820 goto out;
1821
1822 dev_cs89x0 = dev;
1823 return 0;
1824 out:
1825 free_netdev(dev);
1826 return ret;
1827 }
1828 module_init(cs89x0_isa_init_module);
1829
cs89x0_isa_cleanup_module(void)1830 static void __exit cs89x0_isa_cleanup_module(void)
1831 {
1832 struct net_local *lp = netdev_priv(dev_cs89x0);
1833
1834 unregister_netdev(dev_cs89x0);
1835 iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1836 ioport_unmap(lp->virt_addr);
1837 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1838 free_netdev(dev_cs89x0);
1839 }
1840 module_exit(cs89x0_isa_cleanup_module);
1841 #endif /* MODULE */
1842 #endif /* CONFIG_CS89x0_ISA */
1843
1844 #if IS_ENABLED(CONFIG_CS89x0_PLATFORM)
cs89x0_platform_probe(struct platform_device * pdev)1845 static int __init cs89x0_platform_probe(struct platform_device *pdev)
1846 {
1847 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1848 void __iomem *virt_addr;
1849 int err;
1850
1851 if (!dev)
1852 return -ENOMEM;
1853
1854 dev->irq = platform_get_irq(pdev, 0);
1855 if (dev->irq < 0) {
1856 err = dev->irq;
1857 goto free;
1858 }
1859
1860 virt_addr = devm_platform_ioremap_resource(pdev, 0);
1861 if (IS_ERR(virt_addr)) {
1862 err = PTR_ERR(virt_addr);
1863 goto free;
1864 }
1865
1866 err = cs89x0_probe1(dev, virt_addr, 0);
1867 if (err) {
1868 dev_warn(&dev->dev, "no cs8900 or cs8920 detected\n");
1869 goto free;
1870 }
1871
1872 platform_set_drvdata(pdev, dev);
1873 return 0;
1874
1875 free:
1876 free_netdev(dev);
1877 return err;
1878 }
1879
cs89x0_platform_remove(struct platform_device * pdev)1880 static void cs89x0_platform_remove(struct platform_device *pdev)
1881 {
1882 struct net_device *dev = platform_get_drvdata(pdev);
1883
1884 /* This platform_get_resource() call will not return NULL, because
1885 * the same call in cs89x0_platform_probe() has returned a non NULL
1886 * value.
1887 */
1888 unregister_netdev(dev);
1889 free_netdev(dev);
1890 }
1891
1892 static const struct of_device_id __maybe_unused cs89x0_match[] = {
1893 { .compatible = "cirrus,cs8900", },
1894 { .compatible = "cirrus,cs8920", },
1895 { },
1896 };
1897 MODULE_DEVICE_TABLE(of, cs89x0_match);
1898
1899 static struct platform_driver cs89x0_driver = {
1900 .driver = {
1901 .name = DRV_NAME,
1902 .of_match_table = of_match_ptr(cs89x0_match),
1903 },
1904 .remove = cs89x0_platform_remove,
1905 };
1906
1907 module_platform_driver_probe(cs89x0_driver, cs89x0_platform_probe);
1908
1909 #endif /* CONFIG_CS89x0_PLATFORM */
1910
1911 MODULE_LICENSE("GPL");
1912 MODULE_DESCRIPTION("Crystal Semiconductor (Now Cirrus Logic) CS89[02]0 network driver");
1913 MODULE_AUTHOR("Russell Nelson <nelson@crynwr.com>");
1914