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