Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 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

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

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