Version:  2.0.40 2.2.26 2.4.37 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8 4.9 4.10

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us