Version:  2.0.40 2.2.26 2.4.37 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16

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

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