1 /* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0
3 * Written 1996 by Russell Nelson, with reference to skeleton.c
4 * written 1993-1994 by Donald Becker.
6 * This software may be used and distributed according to the terms
7 * of the GNU General Public License, incorporated herein by reference.
9 * The author may be reached at nelson@crynwr.com, Crynwr
10 * Software, 521 Pleasant Valley Rd., Potsdam, NY 13676
13 * Mike Cruse : mcruse@cti-ltd.com
15 * Melody Lee : ethernet@crystal.cirrus.com
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
27 * Set this to zero to disable DMA code
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.
32 #ifndef CONFIG_ISA_DMA_API
39 * Set this to zero to remove all the debug statements via
40 * dead code elimination
45 * Crynwr packet driver epktisa.
46 * Crystal Semiconductor data sheets.
49 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
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>
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>
73 #include <linux/atomic.h>
80 #define cs89_dbg(val, level, fmt, ...) \
82 if (val <= net_debug) \
83 pr_##level(fmt, ##__VA_ARGS__); \
86 static char version[] __initdata =
87 "v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton";
89 #define DRV_NAME "cs89x0"
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
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.
104 #if defined(CONFIG_MACH_IXDP2351)
105 #define CS89x0_NONISA_IRQ
106 static unsigned int netcard_portlist[] __used __initdata = {
107 IXDP2351_VIRT_CS8900_BASE, 0
109 static unsigned int cs8900_irq_map[] = {
110 IRQ_IXDP2351_CS8900, 0, 0, 0
112 #elif defined(CONFIG_ARCH_IXDP2X01)
113 #define CS89x0_NONISA_IRQ
114 static unsigned int netcard_portlist[] __used __initdata = {
115 IXDP2X01_CS8900_VIRT_BASE, 0
117 static unsigned int cs8900_irq_map[] = {
118 IRQ_IXDP2X01_CS8900, 0, 0, 0
121 #ifndef CONFIG_CS89x0_PLATFORM
122 static unsigned int netcard_portlist[] __used __initdata = {
123 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240,
124 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0
126 static unsigned int cs8900_irq_map[] = {
133 static unsigned int net_debug = DEBUGGING;
135 #define net_debug 0 /* gcc will remove all the debug code for us */
138 /* The number of low I/O ports used by the ethercard. */
139 #define NETCARD_IO_EXTENT 16
141 /* we allow the user to override various values normally set in the EEPROM */
142 #define FORCE_RJ45 0x0001 /* pick one of these three */
143 #define FORCE_AUI 0x0002
144 #define FORCE_BNC 0x0004
146 #define FORCE_AUTO 0x0010 /* pick one of these three */
147 #define FORCE_HALF 0x0020
148 #define FORCE_FULL 0x0030
150 /* Information that need to be kept for each board. */
152 int chip_type; /* one of: CS8900, CS8920, CS8920M */
153 char chip_revision; /* revision letter of the chip ('A'...) */
154 int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
155 int auto_neg_cnf; /* auto-negotiation word from EEPROM */
156 int adapter_cnf; /* adapter configuration from EEPROM */
157 int isa_config; /* ISA configuration from EEPROM */
158 int irq_map; /* IRQ map from EEPROM */
159 int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
160 int curr_rx_cfg; /* a copy of PP_RxCFG */
161 int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
162 int send_underrun; /* keep track of how many underruns in a row we get */
163 int force; /* force various values; see FORCE* above. */
165 void __iomem *virt_addr;/* CS89x0 virtual address. */
166 unsigned long size; /* Length of CS89x0 memory region. */
168 int use_dma; /* Flag: we're using dma */
169 int dma; /* DMA channel */
170 int dmasize; /* 16 or 64 */
171 unsigned char *dma_buff; /* points to the beginning of the buffer */
172 unsigned char *end_dma_buff; /* points to the end of the buffer */
173 unsigned char *rx_dma_ptr; /* points to the next packet */
177 /* Example routines you must write ;->. */
178 #define tx_done(dev) 1
181 * Permit 'cs89x0_dma=N' in the kernel boot environment
185 static int g_cs89x0_dma;
187 static int __init dma_fn(char *str)
189 g_cs89x0_dma = simple_strtol(str, NULL, 0);
193 __setup("cs89x0_dma=", dma_fn);
194 #endif /* ALLOW_DMA */
196 static int g_cs89x0_media__force;
198 static int __init media_fn(char *str)
200 if (!strcmp(str, "rj45"))
201 g_cs89x0_media__force = FORCE_RJ45;
202 else if (!strcmp(str, "aui"))
203 g_cs89x0_media__force = FORCE_AUI;
204 else if (!strcmp(str, "bnc"))
205 g_cs89x0_media__force = FORCE_BNC;
210 __setup("cs89x0_media=", media_fn);
213 #if defined(CONFIG_MACH_IXDP2351)
215 readword(unsigned long base_addr, int portno)
217 return __raw_readw(base_addr + (portno << 1));
221 writeword(unsigned long base_addr, int portno, u16 value)
223 __raw_writew(value, base_addr + (portno << 1));
225 #elif defined(CONFIG_ARCH_IXDP2X01)
227 readword(unsigned long base_addr, int portno)
229 return __raw_readl(base_addr + (portno << 1));
233 writeword(unsigned long base_addr, int portno, u16 value)
235 __raw_writel(value, base_addr + (portno << 1));
239 static void readwords(struct net_local *lp, int portno, void *buf, int length)
241 u8 *buf8 = (u8 *)buf;
246 tmp16 = ioread16(lp->virt_addr + portno);
248 *buf8++ = (u8)(tmp16 >> 8);
252 static void writewords(struct net_local *lp, int portno, void *buf, int length)
254 u8 *buf8 = (u8 *)buf;
260 tmp16 |= (*buf8++) << 8;
261 iowrite16(tmp16, lp->virt_addr + portno);
266 readreg(struct net_device *dev, u16 regno)
268 struct net_local *lp = netdev_priv(dev);
270 iowrite16(regno, lp->virt_addr + ADD_PORT);
271 return ioread16(lp->virt_addr + DATA_PORT);
275 writereg(struct net_device *dev, u16 regno, u16 value)
277 struct net_local *lp = netdev_priv(dev);
279 iowrite16(regno, lp->virt_addr + ADD_PORT);
280 iowrite16(value, lp->virt_addr + DATA_PORT);
284 wait_eeprom_ready(struct net_device *dev)
286 int timeout = jiffies;
287 /* check to see if the EEPROM is ready,
288 * a timeout is used just in case EEPROM is ready when
289 * SI_BUSY in the PP_SelfST is clear
291 while (readreg(dev, PP_SelfST) & SI_BUSY)
292 if (jiffies - timeout >= 40)
298 get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
302 cs89_dbg(3, info, "EEPROM data from %x for %x:", off, len);
303 for (i = 0; i < len; i++) {
304 if (wait_eeprom_ready(dev) < 0)
306 /* Now send the EEPROM read command and EEPROM location to read */
307 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
308 if (wait_eeprom_ready(dev) < 0)
310 buffer[i] = readreg(dev, PP_EEData);
311 cs89_dbg(3, cont, " %04x", buffer[i]);
313 cs89_dbg(3, cont, "\n");
318 get_eeprom_cksum(int off, int len, int *buffer)
323 for (i = 0; i < len; i++)
332 write_irq(struct net_device *dev, int chip_type, int irq)
336 if (chip_type == CS8900) {
337 #ifndef CONFIG_CS89x0_PLATFORM
338 /* Search the mapping table for the corresponding IRQ pin. */
339 for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
340 if (cs8900_irq_map[i] == irq)
343 if (i == ARRAY_SIZE(cs8900_irq_map))
346 /* INTRQ0 pin is used for interrupt generation. */
349 writereg(dev, PP_CS8900_ISAINT, i);
351 writereg(dev, PP_CS8920_ISAINT, irq);
356 count_rx_errors(int status, struct net_device *dev)
358 dev->stats.rx_errors++;
359 if (status & RX_RUNT)
360 dev->stats.rx_length_errors++;
361 if (status & RX_EXTRA_DATA)
362 dev->stats.rx_length_errors++;
363 if ((status & RX_CRC_ERROR) && !(status & (RX_EXTRA_DATA | RX_RUNT)))
365 dev->stats.rx_crc_errors++;
366 if (status & RX_DRIBBLE)
367 dev->stats.rx_frame_errors++;
370 /*********************************
371 * This page contains DMA routines
372 *********************************/
376 #define dma_page_eq(ptr1, ptr2) ((long)(ptr1) >> 17 == (long)(ptr2) >> 17)
379 get_dma_channel(struct net_device *dev)
381 struct net_local *lp = netdev_priv(dev);
385 lp->isa_config |= ISA_RxDMA;
387 if ((lp->isa_config & ANY_ISA_DMA) == 0)
389 dev->dma = lp->isa_config & DMA_NO_MASK;
390 if (lp->chip_type == CS8900)
392 if (dev->dma < 5 || dev->dma > 7) {
393 lp->isa_config &= ~ANY_ISA_DMA;
400 write_dma(struct net_device *dev, int chip_type, int dma)
402 struct net_local *lp = netdev_priv(dev);
403 if ((lp->isa_config & ANY_ISA_DMA) == 0)
405 if (chip_type == CS8900)
406 writereg(dev, PP_CS8900_ISADMA, dma - 5);
408 writereg(dev, PP_CS8920_ISADMA, dma);
412 set_dma_cfg(struct net_device *dev)
414 struct net_local *lp = netdev_priv(dev);
417 if ((lp->isa_config & ANY_ISA_DMA) == 0) {
418 cs89_dbg(3, err, "set_dma_cfg(): no DMA\n");
421 if (lp->isa_config & ISA_RxDMA) {
422 lp->curr_rx_cfg |= RX_DMA_ONLY;
423 cs89_dbg(3, info, "set_dma_cfg(): RX_DMA_ONLY\n");
425 lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
426 cs89_dbg(3, info, "set_dma_cfg(): AUTO_RX_DMA\n");
432 dma_bufcfg(struct net_device *dev)
434 struct net_local *lp = netdev_priv(dev);
436 return (lp->isa_config & ANY_ISA_DMA) ? RX_DMA_ENBL : 0;
442 dma_busctl(struct net_device *dev)
445 struct net_local *lp = netdev_priv(dev);
447 if (lp->isa_config & ANY_ISA_DMA)
448 retval |= RESET_RX_DMA; /* Reset the DMA pointer */
449 if (lp->isa_config & DMA_BURST)
450 retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
451 if (lp->dmasize == 64)
452 retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
453 retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
459 dma_rx(struct net_device *dev)
461 struct net_local *lp = netdev_priv(dev);
464 unsigned char *bp = lp->rx_dma_ptr;
466 status = bp[0] + (bp[1] << 8);
467 length = bp[2] + (bp[3] << 8);
470 cs89_dbg(5, debug, "%s: receiving DMA packet at %lx, status %x, length %x\n",
471 dev->name, (unsigned long)bp, status, length);
473 if ((status & RX_OK) == 0) {
474 count_rx_errors(status, dev);
475 goto skip_this_frame;
478 /* Malloc up new buffer. */
479 skb = netdev_alloc_skb(dev, length + 2);
481 dev->stats.rx_dropped++;
483 /* AKPM: advance bp to the next frame */
485 bp += (length + 3) & ~3;
486 if (bp >= lp->end_dma_buff)
487 bp -= lp->dmasize * 1024;
491 skb_reserve(skb, 2); /* longword align L3 header */
493 if (bp + length > lp->end_dma_buff) {
494 int semi_cnt = lp->end_dma_buff - bp;
495 memcpy(skb_put(skb, semi_cnt), bp, semi_cnt);
496 memcpy(skb_put(skb, length - semi_cnt), lp->dma_buff,
499 memcpy(skb_put(skb, length), bp, length);
501 bp += (length + 3) & ~3;
502 if (bp >= lp->end_dma_buff)
503 bp -= lp->dmasize*1024;
506 cs89_dbg(3, info, "%s: received %d byte DMA packet of type %x\n",
508 ((skb->data[ETH_ALEN + ETH_ALEN] << 8) |
509 skb->data[ETH_ALEN + ETH_ALEN + 1]));
511 skb->protocol = eth_type_trans(skb, dev);
513 dev->stats.rx_packets++;
514 dev->stats.rx_bytes += length;
517 static void release_dma_buff(struct net_local *lp)
520 free_pages((unsigned long)(lp->dma_buff),
521 get_order(lp->dmasize * 1024));
526 #endif /* ALLOW_DMA */
529 control_dc_dc(struct net_device *dev, int on_not_off)
531 struct net_local *lp = netdev_priv(dev);
532 unsigned int selfcontrol;
533 int timenow = jiffies;
534 /* control the DC to DC convertor in the SelfControl register.
535 * Note: This is hooked up to a general purpose pin, might not
536 * always be a DC to DC convertor.
539 selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
540 if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
543 selfcontrol &= ~HCB1;
544 writereg(dev, PP_SelfCTL, selfcontrol);
546 /* Wait for the DC/DC converter to power up - 500ms */
547 while (jiffies - timenow < HZ)
551 /* send a test packet - return true if carrier bits are ok */
553 send_test_pkt(struct net_device *dev)
555 struct net_local *lp = netdev_priv(dev);
556 char test_packet[] = {
557 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
558 0, 46, /* A 46 in network order */
559 0, 0, /* DSAP=0 & SSAP=0 fields */
560 0xf3, 0 /* Control (Test Req + P bit set) */
562 long timenow = jiffies;
564 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
566 memcpy(test_packet, dev->dev_addr, ETH_ALEN);
567 memcpy(test_packet + ETH_ALEN, dev->dev_addr, ETH_ALEN);
569 iowrite16(TX_AFTER_ALL, lp->virt_addr + TX_CMD_PORT);
570 iowrite16(ETH_ZLEN, lp->virt_addr + TX_LEN_PORT);
572 /* Test to see if the chip has allocated memory for the packet */
573 while (jiffies - timenow < 5)
574 if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
576 if (jiffies - timenow >= 5)
577 return 0; /* this shouldn't happen */
579 /* Write the contents of the packet */
580 writewords(lp, TX_FRAME_PORT, test_packet, (ETH_ZLEN + 1) >> 1);
582 cs89_dbg(1, debug, "Sending test packet ");
583 /* wait a couple of jiffies for packet to be received */
584 for (timenow = jiffies; jiffies - timenow < 3;)
586 if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
587 cs89_dbg(1, cont, "succeeded\n");
590 cs89_dbg(1, cont, "failed\n");
594 #define DETECTED_NONE 0
595 #define DETECTED_RJ45H 1
596 #define DETECTED_RJ45F 2
597 #define DETECTED_AUI 3
598 #define DETECTED_BNC 4
601 detect_tp(struct net_device *dev)
603 struct net_local *lp = netdev_priv(dev);
604 int timenow = jiffies;
607 cs89_dbg(1, debug, "%s: Attempting TP\n", dev->name);
609 /* If connected to another full duplex capable 10-Base-T card
610 * the link pulses seem to be lost when the auto detect bit in
611 * the LineCTL is set. To overcome this the auto detect bit will
612 * be cleared whilst testing the 10-Base-T interface. This would
613 * not be necessary for the sparrow chip but is simpler to do it
616 writereg(dev, PP_LineCTL, lp->linectl & ~AUI_ONLY);
617 control_dc_dc(dev, 0);
619 /* Delay for the hardware to work out if the TP cable is present
622 for (timenow = jiffies; jiffies - timenow < 15;)
624 if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
625 return DETECTED_NONE;
627 if (lp->chip_type == CS8900) {
628 switch (lp->force & 0xf0) {
631 pr_info("%s: cs8900 doesn't autonegotiate\n",
633 return DETECTED_NONE;
635 /* CS8900 doesn't support AUTO, change to HALF*/
637 lp->force &= ~FORCE_AUTO;
638 lp->force |= FORCE_HALF;
643 writereg(dev, PP_TestCTL,
644 readreg(dev, PP_TestCTL) | FDX_8900);
647 fdx = readreg(dev, PP_TestCTL) & FDX_8900;
649 switch (lp->force & 0xf0) {
651 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
654 lp->auto_neg_cnf = 0;
657 lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
661 writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
663 if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
664 pr_info("%s: negotiating duplex...\n", dev->name);
665 while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
666 if (jiffies - timenow > 4000) {
667 pr_err("**** Full / half duplex auto-negotiation timed out ****\n");
672 fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
675 return DETECTED_RJ45F;
677 return DETECTED_RJ45H;
681 detect_bnc(struct net_device *dev)
683 struct net_local *lp = netdev_priv(dev);
685 cs89_dbg(1, debug, "%s: Attempting BNC\n", dev->name);
686 control_dc_dc(dev, 1);
688 writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
690 if (send_test_pkt(dev))
693 return DETECTED_NONE;
697 detect_aui(struct net_device *dev)
699 struct net_local *lp = netdev_priv(dev);
701 cs89_dbg(1, debug, "%s: Attempting AUI\n", dev->name);
702 control_dc_dc(dev, 0);
704 writereg(dev, PP_LineCTL, (lp->linectl & ~AUTO_AUI_10BASET) | AUI_ONLY);
706 if (send_test_pkt(dev))
709 return DETECTED_NONE;
712 /* We have a good packet(s), get it/them out of the buffers. */
714 net_rx(struct net_device *dev)
716 struct net_local *lp = netdev_priv(dev);
720 status = ioread16(lp->virt_addr + RX_FRAME_PORT);
721 length = ioread16(lp->virt_addr + RX_FRAME_PORT);
723 if ((status & RX_OK) == 0) {
724 count_rx_errors(status, dev);
728 /* Malloc up new buffer. */
729 skb = netdev_alloc_skb(dev, length + 2);
731 dev->stats.rx_dropped++;
734 skb_reserve(skb, 2); /* longword align L3 header */
736 readwords(lp, RX_FRAME_PORT, skb_put(skb, length), length >> 1);
738 skb->data[length-1] = ioread16(lp->virt_addr + RX_FRAME_PORT);
740 cs89_dbg(3, debug, "%s: received %d byte packet of type %x\n",
742 (skb->data[ETH_ALEN + ETH_ALEN] << 8) |
743 skb->data[ETH_ALEN + ETH_ALEN + 1]);
745 skb->protocol = eth_type_trans(skb, dev);
747 dev->stats.rx_packets++;
748 dev->stats.rx_bytes += length;
751 /* The typical workload of the driver:
752 * Handle the network interface interrupts.
755 static irqreturn_t net_interrupt(int irq, void *dev_id)
757 struct net_device *dev = dev_id;
758 struct net_local *lp;
762 lp = netdev_priv(dev);
764 /* we MUST read all the events out of the ISQ, otherwise we'll never
765 * get interrupted again. As a consequence, we can't have any limit
766 * on the number of times we loop in the interrupt handler. The
767 * hardware guarantees that eventually we'll run out of events. Of
768 * course, if you're on a slow machine, and packets are arriving
769 * faster than you can read them off, you're screwed. Hasta la
772 while ((status = ioread16(lp->virt_addr + ISQ_PORT))) {
773 cs89_dbg(4, debug, "%s: event=%04x\n", dev->name, status);
775 switch (status & ISQ_EVENT_MASK) {
776 case ISQ_RECEIVER_EVENT:
777 /* Got a packet(s). */
780 case ISQ_TRANSMITTER_EVENT:
781 dev->stats.tx_packets++;
782 netif_wake_queue(dev); /* Inform upper layers. */
783 if ((status & (TX_OK |
787 TX_16_COL)) != TX_OK) {
788 if ((status & TX_OK) == 0)
789 dev->stats.tx_errors++;
790 if (status & TX_LOST_CRS)
791 dev->stats.tx_carrier_errors++;
792 if (status & TX_SQE_ERROR)
793 dev->stats.tx_heartbeat_errors++;
794 if (status & TX_LATE_COL)
795 dev->stats.tx_window_errors++;
796 if (status & TX_16_COL)
797 dev->stats.tx_aborted_errors++;
800 case ISQ_BUFFER_EVENT:
801 if (status & READY_FOR_TX) {
802 /* we tried to transmit a packet earlier,
803 * but inexplicably ran out of buffers.
804 * That shouldn't happen since we only ever
805 * load one packet. Shrug. Do the right
808 netif_wake_queue(dev); /* Inform upper layers. */
810 if (status & TX_UNDERRUN) {
811 cs89_dbg(0, err, "%s: transmit underrun\n",
814 if (lp->send_underrun == 3)
815 lp->send_cmd = TX_AFTER_381;
816 else if (lp->send_underrun == 6)
817 lp->send_cmd = TX_AFTER_ALL;
818 /* transmit cycle is done, although
819 * frame wasn't transmitted - this
820 * avoids having to wait for the upper
821 * layers to timeout on us, in the
822 * event of a tx underrun
824 netif_wake_queue(dev); /* Inform upper layers. */
827 if (lp->use_dma && (status & RX_DMA)) {
828 int count = readreg(dev, PP_DmaFrameCnt);
831 "%s: receiving %d DMA frames\n",
835 "%s: receiving %d DMA frames\n",
839 count = readreg(dev, PP_DmaFrameCnt);
842 "%s: continuing with %d DMA frames\n",
848 case ISQ_RX_MISS_EVENT:
849 dev->stats.rx_missed_errors += (status >> 6);
851 case ISQ_TX_COL_EVENT:
852 dev->stats.collisions += (status >> 6);
856 return IRQ_RETVAL(handled);
859 /* Open/initialize the board. This is called (in the current kernel)
860 sometime after booting when the 'ifconfig' program is run.
862 This routine should set everything up anew at each open, even
863 registers that "should" only need to be set once at boot, so that
864 there is non-reboot way to recover if something goes wrong.
867 /* AKPM: do we need to do any locking here? */
870 net_open(struct net_device *dev)
872 struct net_local *lp = netdev_priv(dev);
878 /* Allow interrupts to be generated by the chip */
879 /* Cirrus' release had this: */
881 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL) | ENABLE_IRQ);
883 /* And 2.3.47 had this: */
884 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
886 for (i = 2; i < CS8920_NO_INTS; i++) {
887 if ((1 << i) & lp->irq_map) {
888 if (request_irq(i, net_interrupt, 0, dev->name,
891 write_irq(dev, lp->chip_type, i);
892 /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
898 if (i >= CS8920_NO_INTS) {
899 writereg(dev, PP_BusCTL, 0); /* disable interrupts. */
900 pr_err("can't get an interrupt\n");
905 #if !defined(CS89x0_NONISA_IRQ) && !defined(CONFIG_CS89x0_PLATFORM)
906 if (((1 << dev->irq) & lp->irq_map) == 0) {
907 pr_err("%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
908 dev->name, dev->irq, lp->irq_map);
913 /* FIXME: Cirrus' release had this: */
914 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ);
915 /* And 2.3.47 had this: */
917 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
919 write_irq(dev, lp->chip_type, dev->irq);
920 ret = request_irq(dev->irq, net_interrupt, 0, dev->name, dev);
922 pr_err("request_irq(%d) failed\n", dev->irq);
928 if (lp->use_dma && (lp->isa_config & ANY_ISA_DMA)) {
930 lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
931 get_order(lp->dmasize * 1024));
933 pr_err("%s: cannot get %dK memory for DMA\n",
934 dev->name, lp->dmasize);
937 cs89_dbg(1, debug, "%s: dma %lx %lx\n",
939 (unsigned long)lp->dma_buff,
940 (unsigned long)isa_virt_to_bus(lp->dma_buff));
941 if ((unsigned long)lp->dma_buff >= MAX_DMA_ADDRESS ||
942 !dma_page_eq(lp->dma_buff,
943 lp->dma_buff + lp->dmasize * 1024 - 1)) {
944 pr_err("%s: not usable as DMA buffer\n", dev->name);
947 memset(lp->dma_buff, 0, lp->dmasize * 1024); /* Why? */
948 if (request_dma(dev->dma, dev->name)) {
949 pr_err("%s: cannot get dma channel %d\n",
950 dev->name, dev->dma);
953 write_dma(dev, lp->chip_type, dev->dma);
954 lp->rx_dma_ptr = lp->dma_buff;
955 lp->end_dma_buff = lp->dma_buff + lp->dmasize * 1024;
956 spin_lock_irqsave(&lp->lock, flags);
957 disable_dma(dev->dma);
958 clear_dma_ff(dev->dma);
959 set_dma_mode(dev->dma, DMA_RX_MODE); /* auto_init as well */
960 set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
961 set_dma_count(dev->dma, lp->dmasize * 1024);
962 enable_dma(dev->dma);
963 spin_unlock_irqrestore(&lp->lock, flags);
965 #endif /* ALLOW_DMA */
967 /* set the Ethernet address */
968 for (i = 0; i < ETH_ALEN / 2; i++)
969 writereg(dev, PP_IA + i * 2,
970 (dev->dev_addr[i * 2] |
971 (dev->dev_addr[i * 2 + 1] << 8)));
973 /* while we're testing the interface, leave interrupts disabled */
974 writereg(dev, PP_BusCTL, MEMORY_ON);
976 /* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
977 if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) &&
978 (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
979 lp->linectl = LOW_RX_SQUELCH;
983 /* check to make sure that they have the "right" hardware available */
984 switch (lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
985 case A_CNF_MEDIA_10B_T:
986 result = lp->adapter_cnf & A_CNF_10B_T;
988 case A_CNF_MEDIA_AUI:
989 result = lp->adapter_cnf & A_CNF_AUI;
991 case A_CNF_MEDIA_10B_2:
992 result = lp->adapter_cnf & A_CNF_10B_2;
995 result = lp->adapter_cnf & (A_CNF_10B_T |
1000 pr_err("%s: EEPROM is configured for unavailable media\n",
1006 release_dma_buff(lp);
1008 writereg(dev, PP_LineCTL,
1009 readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
1010 free_irq(dev->irq, dev);
1015 /* set the hardware to the configured choice */
1016 switch (lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1017 case A_CNF_MEDIA_10B_T:
1018 result = detect_tp(dev);
1019 if (result == DETECTED_NONE) {
1020 pr_warn("%s: 10Base-T (RJ-45) has no cable\n",
1022 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1023 result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
1026 case A_CNF_MEDIA_AUI:
1027 result = detect_aui(dev);
1028 if (result == DETECTED_NONE) {
1029 pr_warn("%s: 10Base-5 (AUI) has no cable\n", dev->name);
1030 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1031 result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
1034 case A_CNF_MEDIA_10B_2:
1035 result = detect_bnc(dev);
1036 if (result == DETECTED_NONE) {
1037 pr_warn("%s: 10Base-2 (BNC) has no cable\n", dev->name);
1038 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1039 result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
1042 case A_CNF_MEDIA_AUTO:
1043 writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
1044 if (lp->adapter_cnf & A_CNF_10B_T) {
1045 result = detect_tp(dev);
1046 if (result != DETECTED_NONE)
1049 if (lp->adapter_cnf & A_CNF_AUI) {
1050 result = detect_aui(dev);
1051 if (result != DETECTED_NONE)
1054 if (lp->adapter_cnf & A_CNF_10B_2) {
1055 result = detect_bnc(dev);
1056 if (result != DETECTED_NONE)
1059 pr_err("%s: no media detected\n", dev->name);
1064 pr_err("%s: no network cable attached to configured media\n",
1067 case DETECTED_RJ45H:
1068 pr_info("%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
1070 case DETECTED_RJ45F:
1071 pr_info("%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
1074 pr_info("%s: using 10Base-5 (AUI)\n", dev->name);
1077 pr_info("%s: using 10Base-2 (BNC)\n", dev->name);
1081 /* Turn on both receive and transmit operations */
1082 writereg(dev, PP_LineCTL,
1083 readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1085 /* Receive only error free packets addressed to this card */
1087 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
1089 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
1091 if (lp->isa_config & STREAM_TRANSFER)
1092 lp->curr_rx_cfg |= RX_STREAM_ENBL;
1096 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
1098 writereg(dev, PP_TxCFG, (TX_LOST_CRS_ENBL |
1106 writereg(dev, PP_BufCFG, (READY_FOR_TX_ENBL |
1107 RX_MISS_COUNT_OVRFLOW_ENBL |
1111 TX_COL_COUNT_OVRFLOW_ENBL |
1114 /* now that we've got our act together, enable everything */
1115 writereg(dev, PP_BusCTL, (ENABLE_IRQ
1116 | (dev->mem_start ? MEMORY_ON : 0) /* turn memory on */
1121 netif_start_queue(dev);
1122 cs89_dbg(1, debug, "net_open() succeeded\n");
1128 /* The inverse routine to net_open(). */
1130 net_close(struct net_device *dev)
1133 struct net_local *lp = netdev_priv(dev);
1136 netif_stop_queue(dev);
1138 writereg(dev, PP_RxCFG, 0);
1139 writereg(dev, PP_TxCFG, 0);
1140 writereg(dev, PP_BufCFG, 0);
1141 writereg(dev, PP_BusCTL, 0);
1143 free_irq(dev->irq, dev);
1146 if (lp->use_dma && lp->dma) {
1148 release_dma_buff(lp);
1152 /* Update the statistics here. */
1156 /* Get the current statistics.
1157 * This may be called with the card open or closed.
1159 static struct net_device_stats *
1160 net_get_stats(struct net_device *dev)
1162 struct net_local *lp = netdev_priv(dev);
1163 unsigned long flags;
1165 spin_lock_irqsave(&lp->lock, flags);
1166 /* Update the statistics from the device registers. */
1167 dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1168 dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1169 spin_unlock_irqrestore(&lp->lock, flags);
1174 static void net_timeout(struct net_device *dev)
1176 /* If we get here, some higher level has decided we are broken.
1177 There should really be a "kick me" function call instead. */
1178 cs89_dbg(0, err, "%s: transmit timed out, %s?\n",
1180 tx_done(dev) ? "IRQ conflict" : "network cable problem");
1181 /* Try to restart the adaptor. */
1182 netif_wake_queue(dev);
1185 static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev)
1187 struct net_local *lp = netdev_priv(dev);
1188 unsigned long flags;
1190 cs89_dbg(3, debug, "%s: sent %d byte packet of type %x\n",
1191 dev->name, skb->len,
1192 ((skb->data[ETH_ALEN + ETH_ALEN] << 8) |
1193 skb->data[ETH_ALEN + ETH_ALEN + 1]));
1195 /* keep the upload from being interrupted, since we
1196 * ask the chip to start transmitting before the
1197 * whole packet has been completely uploaded.
1200 spin_lock_irqsave(&lp->lock, flags);
1201 netif_stop_queue(dev);
1203 /* initiate a transmit sequence */
1204 iowrite16(lp->send_cmd, lp->virt_addr + TX_CMD_PORT);
1205 iowrite16(skb->len, lp->virt_addr + TX_LEN_PORT);
1207 /* Test to see if the chip has allocated memory for the packet */
1208 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1209 /* Gasp! It hasn't. But that shouldn't happen since
1210 * we're waiting for TxOk, so return 1 and requeue this packet.
1213 spin_unlock_irqrestore(&lp->lock, flags);
1214 cs89_dbg(0, err, "Tx buffer not free!\n");
1215 return NETDEV_TX_BUSY;
1217 /* Write the contents of the packet */
1218 writewords(lp, TX_FRAME_PORT, skb->data, (skb->len + 1) >> 1);
1219 spin_unlock_irqrestore(&lp->lock, flags);
1220 dev->stats.tx_bytes += skb->len;
1223 /* We DO NOT call netif_wake_queue() here.
1224 * We also DO NOT call netif_start_queue().
1226 * Either of these would cause another bottom half run through
1227 * net_send_packet() before this packet has fully gone out.
1228 * That causes us to hit the "Gasp!" above and the send is rescheduled.
1229 * it runs like a dog. We just return and wait for the Tx completion
1230 * interrupt handler to restart the netdevice layer
1233 return NETDEV_TX_OK;
1236 static void set_multicast_list(struct net_device *dev)
1238 struct net_local *lp = netdev_priv(dev);
1239 unsigned long flags;
1242 spin_lock_irqsave(&lp->lock, flags);
1243 if (dev->flags & IFF_PROMISC)
1244 lp->rx_mode = RX_ALL_ACCEPT;
1245 else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev))
1246 /* The multicast-accept list is initialized to accept-all,
1247 * and we rely on higher-level filtering for now.
1249 lp->rx_mode = RX_MULTCAST_ACCEPT;
1253 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1255 /* in promiscuous mode, we accept errored packets,
1256 * so we have to enable interrupts on them also
1258 cfg = lp->curr_rx_cfg;
1259 if (lp->rx_mode == RX_ALL_ACCEPT)
1260 cfg |= RX_CRC_ERROR_ENBL | RX_RUNT_ENBL | RX_EXTRA_DATA_ENBL;
1261 writereg(dev, PP_RxCFG, cfg);
1262 spin_unlock_irqrestore(&lp->lock, flags);
1265 static int set_mac_address(struct net_device *dev, void *p)
1268 struct sockaddr *addr = p;
1270 if (netif_running(dev))
1273 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1275 cs89_dbg(0, debug, "%s: Setting MAC address to %pM\n",
1276 dev->name, dev->dev_addr);
1278 /* set the Ethernet address */
1279 for (i = 0; i < ETH_ALEN / 2; i++)
1280 writereg(dev, PP_IA + i * 2,
1281 (dev->dev_addr[i * 2] |
1282 (dev->dev_addr[i * 2 + 1] << 8)));
1287 #ifdef CONFIG_NET_POLL_CONTROLLER
1289 * Polling receive - used by netconsole and other diagnostic tools
1290 * to allow network i/o with interrupts disabled.
1292 static void net_poll_controller(struct net_device *dev)
1294 disable_irq(dev->irq);
1295 net_interrupt(dev->irq, dev);
1296 enable_irq(dev->irq);
1300 static const struct net_device_ops net_ops = {
1301 .ndo_open = net_open,
1302 .ndo_stop = net_close,
1303 .ndo_tx_timeout = net_timeout,
1304 .ndo_start_xmit = net_send_packet,
1305 .ndo_get_stats = net_get_stats,
1306 .ndo_set_rx_mode = set_multicast_list,
1307 .ndo_set_mac_address = set_mac_address,
1308 #ifdef CONFIG_NET_POLL_CONTROLLER
1309 .ndo_poll_controller = net_poll_controller,
1311 .ndo_change_mtu = eth_change_mtu,
1312 .ndo_validate_addr = eth_validate_addr,
1315 static void __init reset_chip(struct net_device *dev)
1317 #if !defined(CONFIG_MACH_MX31ADS)
1318 #if !defined(CS89x0_NONISA_IRQ)
1319 struct net_local *lp = netdev_priv(dev);
1320 #endif /* CS89x0_NONISA_IRQ */
1321 int reset_start_time;
1323 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
1328 #if !defined(CS89x0_NONISA_IRQ)
1329 if (lp->chip_type != CS8900) {
1330 /* Hardware problem requires PNP registers to be reconfigured after a reset */
1331 iowrite16(PP_CS8920_ISAINT, lp->virt_addr + ADD_PORT);
1332 iowrite8(dev->irq, lp->virt_addr + DATA_PORT);
1333 iowrite8(0, lp->virt_addr + DATA_PORT + 1);
1335 iowrite16(PP_CS8920_ISAMemB, lp->virt_addr + ADD_PORT);
1336 iowrite8((dev->mem_start >> 16) & 0xff,
1337 lp->virt_addr + DATA_PORT);
1338 iowrite8((dev->mem_start >> 8) & 0xff,
1339 lp->virt_addr + DATA_PORT + 1);
1341 #endif /* CS89x0_NONISA_IRQ */
1343 /* Wait until the chip is reset */
1344 reset_start_time = jiffies;
1345 while ((readreg(dev, PP_SelfST) & INIT_DONE) == 0 &&
1346 jiffies - reset_start_time < 2)
1348 #endif /* !CONFIG_MACH_MX31ADS */
1351 /* This is the real probe routine.
1352 * Linux has a history of friendly device probes on the ISA bus.
1353 * A good device probes avoids doing writes, and
1354 * verifies that the correct device exists and functions.
1355 * Return 0 on success.
1358 cs89x0_probe1(struct net_device *dev, void __iomem *ioaddr, int modular)
1360 struct net_local *lp = netdev_priv(dev);
1363 unsigned rev_type = 0;
1364 int eeprom_buff[CHKSUM_LEN];
1367 /* Initialize the device structure. */
1369 memset(lp, 0, sizeof(*lp));
1370 spin_lock_init(&lp->lock);
1375 lp->dma = g_cs89x0_dma;
1376 lp->dmasize = 16; /* Could make this an option... */
1379 lp->force = g_cs89x0_media__force;
1383 pr_debug("PP_addr at %p[%x]: 0x%x\n",
1384 ioaddr, ADD_PORT, ioread16(ioaddr + ADD_PORT));
1385 iowrite16(PP_ChipID, ioaddr + ADD_PORT);
1387 tmp = ioread16(ioaddr + DATA_PORT);
1388 if (tmp != CHIP_EISA_ID_SIG) {
1389 pr_debug("%s: incorrect signature at %p[%x]: 0x%x!="
1390 CHIP_EISA_ID_SIG_STR "\n",
1391 dev->name, ioaddr, DATA_PORT, tmp);
1396 lp->virt_addr = ioaddr;
1398 /* get the chip type */
1399 rev_type = readreg(dev, PRODUCT_ID_ADD);
1400 lp->chip_type = rev_type & ~REVISON_BITS;
1401 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
1403 /* Check the chip type and revision in order to set the correct
1404 * send command. CS8920 revision C and CS8900 revision F can use
1407 lp->send_cmd = TX_AFTER_381;
1408 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
1409 lp->send_cmd = TX_NOW;
1410 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
1411 lp->send_cmd = TX_NOW;
1413 pr_info_once("%s\n", version);
1415 pr_info("%s: cs89%c0%s rev %c found at %p ",
1417 lp->chip_type == CS8900 ? '0' : '2',
1418 lp->chip_type == CS8920M ? "M" : "",
1424 /* Here we read the current configuration of the chip.
1425 * If there is no Extended EEPROM then the idea is to not disturb
1426 * the chip configuration, it should have been correctly setup by
1427 * automatic EEPROM read on reset. So, if the chip says it read
1428 * the EEPROM the driver will always do *something* instead of
1429 * complain that adapter_cnf is 0.
1432 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
1433 (EEPROM_OK | EEPROM_PRESENT)) {
1435 for (i = 0; i < ETH_ALEN / 2; i++) {
1437 Addr = readreg(dev, PP_IA + i * 2);
1438 dev->dev_addr[i * 2] = Addr & 0xFF;
1439 dev->dev_addr[i * 2 + 1] = Addr >> 8;
1442 /* Load the Adapter Configuration.
1443 * Note: Barring any more specific information from some
1444 * other source (ie EEPROM+Schematics), we would not know
1445 * how to operate a 10Base2 interface on the AUI port.
1446 * However, since we do read the status of HCB1 and use
1447 * settings that always result in calls to control_dc_dc(dev,0)
1448 * a BNC interface should work if the enable pin
1449 * (dc/dc converter) is on HCB1.
1450 * It will be called AUI however.
1453 lp->adapter_cnf = 0;
1454 i = readreg(dev, PP_LineCTL);
1455 /* Preserve the setting of the HCB1 pin. */
1456 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
1457 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
1458 /* Save the sqelch bit */
1459 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
1460 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
1461 /* Check if the card is in 10Base-t only mode */
1462 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
1463 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
1464 /* Check if the card is in AUI only mode */
1465 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
1466 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
1467 /* Check if the card is in Auto mode. */
1468 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
1469 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
1470 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
1472 cs89_dbg(1, info, "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
1473 dev->name, i, lp->adapter_cnf);
1475 /* IRQ. Other chips already probe, see below. */
1476 if (lp->chip_type == CS8900)
1477 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
1479 pr_cont("[Cirrus EEPROM] ");
1484 /* First check to see if an EEPROM is attached. */
1486 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
1487 pr_warn("No EEPROM, relying on command line....\n");
1488 else if (get_eeprom_data(dev, START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
1489 pr_warn("EEPROM read failed, relying on command line\n");
1490 } else if (get_eeprom_cksum(START_EEPROM_DATA, CHKSUM_LEN, eeprom_buff) < 0) {
1491 /* Check if the chip was able to read its own configuration starting
1492 at 0 in the EEPROM*/
1493 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
1494 (EEPROM_OK | EEPROM_PRESENT))
1495 pr_warn("Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
1498 /* This reads an extended EEPROM that is not documented
1499 * in the CS8900 datasheet.
1502 /* get transmission control word but keep the autonegotiation bits */
1503 if (!lp->auto_neg_cnf)
1504 lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET / 2];
1505 /* Store adapter configuration */
1506 if (!lp->adapter_cnf)
1507 lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET / 2];
1508 /* Store ISA configuration */
1509 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET / 2];
1510 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET / 2] << 8;
1512 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */
1513 /* store the initial memory base address */
1514 for (i = 0; i < ETH_ALEN / 2; i++) {
1515 dev->dev_addr[i * 2] = eeprom_buff[i];
1516 dev->dev_addr[i * 2 + 1] = eeprom_buff[i] >> 8;
1518 cs89_dbg(1, debug, "%s: new adapter_cnf: 0x%x\n",
1519 dev->name, lp->adapter_cnf);
1522 /* allow them to force multiple transceivers. If they force multiple, autosense */
1525 if (lp->force & FORCE_RJ45) {
1526 lp->adapter_cnf |= A_CNF_10B_T;
1529 if (lp->force & FORCE_AUI) {
1530 lp->adapter_cnf |= A_CNF_AUI;
1533 if (lp->force & FORCE_BNC) {
1534 lp->adapter_cnf |= A_CNF_10B_2;
1538 lp->adapter_cnf |= A_CNF_MEDIA_AUTO;
1539 else if (lp->force & FORCE_RJ45)
1540 lp->adapter_cnf |= A_CNF_MEDIA_10B_T;
1541 else if (lp->force & FORCE_AUI)
1542 lp->adapter_cnf |= A_CNF_MEDIA_AUI;
1543 else if (lp->force & FORCE_BNC)
1544 lp->adapter_cnf |= A_CNF_MEDIA_10B_2;
1547 cs89_dbg(1, debug, "%s: after force 0x%x, adapter_cnf=0x%x\n",
1548 dev->name, lp->force, lp->adapter_cnf);
1550 /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
1552 /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
1554 /* FIXME: we don't set the Ethernet address on the command line. Use
1555 * ifconfig IFACE hw ether AABBCCDDEEFF
1558 pr_info("media %s%s%s",
1559 (lp->adapter_cnf & A_CNF_10B_T) ? "RJ-45," : "",
1560 (lp->adapter_cnf & A_CNF_AUI) ? "AUI," : "",
1561 (lp->adapter_cnf & A_CNF_10B_2) ? "BNC," : "");
1563 lp->irq_map = 0xffff;
1565 /* If this is a CS8900 then no pnp soft */
1566 if (lp->chip_type != CS8900 &&
1567 /* Check if the ISA IRQ has been set */
1568 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
1569 (i != 0 && i < CS8920_NO_INTS))) {
1573 i = lp->isa_config & INT_NO_MASK;
1574 #ifndef CONFIG_CS89x0_PLATFORM
1575 if (lp->chip_type == CS8900) {
1576 #ifdef CS89x0_NONISA_IRQ
1577 i = cs8900_irq_map[0];
1579 /* Translate the IRQ using the IRQ mapping table. */
1580 if (i >= ARRAY_SIZE(cs8900_irq_map))
1581 pr_err("invalid ISA interrupt number %d\n", i);
1583 i = cs8900_irq_map[i];
1585 lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
1587 int irq_map_buff[IRQ_MAP_LEN/2];
1589 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
1591 irq_map_buff) >= 0) {
1592 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
1593 lp->irq_map = ((irq_map_buff[0] >> 8) |
1594 (irq_map_buff[1] << 8));
1603 pr_cont(" IRQ %d", dev->irq);
1607 get_dma_channel(dev);
1608 pr_cont(", DMA %d", dev->dma);
1611 pr_cont(", programmed I/O");
1613 /* print the ethernet address. */
1614 pr_cont(", MAC %pM\n", dev->dev_addr);
1616 dev->netdev_ops = &net_ops;
1617 dev->watchdog_timeo = HZ;
1619 cs89_dbg(0, info, "cs89x0_probe1() successful\n");
1621 retval = register_netdev(dev);
1626 iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1631 #ifndef CONFIG_CS89x0_PLATFORM
1633 * This function converts the I/O port addres used by the cs89x0_probe() and
1634 * init_module() functions to the I/O memory address used by the
1635 * cs89x0_probe1() function.
1638 cs89x0_ioport_probe(struct net_device *dev, unsigned long ioport, int modular)
1640 struct net_local *lp = netdev_priv(dev);
1642 void __iomem *io_mem;
1647 dev->base_addr = ioport;
1649 if (!request_region(ioport, NETCARD_IO_EXTENT, DRV_NAME)) {
1654 io_mem = ioport_map(ioport & ~3, NETCARD_IO_EXTENT);
1660 /* if they give us an odd I/O address, then do ONE write to
1661 * the address port, to get it back to address zero, where we
1662 * expect to find the EISA signature word. An IO with a base of 0x3
1663 * will skip the test for the ADD_PORT.
1666 cs89_dbg(1, info, "%s: odd ioaddr 0x%lx\n", dev->name, ioport);
1667 if ((ioport & 2) != 2) {
1668 if ((ioread16(io_mem + ADD_PORT) & ADD_MASK) !=
1670 pr_err("%s: bad signature 0x%x\n",
1671 dev->name, ioread16(io_mem + ADD_PORT));
1678 ret = cs89x0_probe1(dev, io_mem, modular);
1682 ioport_unmap(io_mem);
1684 release_region(ioport, NETCARD_IO_EXTENT);
1690 /* Check for a network adaptor of this type, and return '0' iff one exists.
1691 * If dev->base_addr == 0, probe all likely locations.
1692 * If dev->base_addr == 1, always return failure.
1693 * If dev->base_addr == 2, allocate space for the device and return success
1694 * (detachable devices only).
1695 * Return 0 on success.
1698 struct net_device * __init cs89x0_probe(int unit)
1700 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1707 return ERR_PTR(-ENODEV);
1709 sprintf(dev->name, "eth%d", unit);
1710 netdev_boot_setup_check(dev);
1711 io = dev->base_addr;
1714 cs89_dbg(0, info, "cs89x0_probe(0x%x)\n", io);
1716 if (io > 0x1ff) { /* Check a single specified location. */
1717 err = cs89x0_ioport_probe(dev, io, 0);
1718 } else if (io != 0) { /* Don't probe at all. */
1721 for (port = netcard_portlist; *port; port++) {
1722 if (cs89x0_ioport_probe(dev, *port, 0) == 0)
1734 pr_warn("no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
1735 return ERR_PTR(err);
1740 #if defined(MODULE) && !defined(CONFIG_CS89x0_PLATFORM)
1742 static struct net_device *dev_cs89x0;
1744 /* Support the 'debug' module parm even if we're compiled for non-debug to
1745 * avoid breaking someone's startup scripts
1751 static char media[8];
1752 static int duplex = -1;
1754 static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
1756 static int dmasize = 16; /* or 64 */
1758 module_param(io, int, 0);
1759 module_param(irq, int, 0);
1760 module_param(debug, int, 0);
1761 module_param_string(media, media, sizeof(media), 0);
1762 module_param(duplex, int, 0);
1763 module_param(dma , int, 0);
1764 module_param(dmasize , int, 0);
1765 module_param(use_dma , int, 0);
1766 MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1767 MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1769 MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1771 MODULE_PARM_DESC(debug, "(ignored)");
1773 MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1774 /* No other value than -1 for duplex seems to be currently interpreted */
1775 MODULE_PARM_DESC(duplex, "(ignored)");
1777 MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1778 MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1779 MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1781 MODULE_PARM_DESC(dma , "(ignored)");
1782 MODULE_PARM_DESC(dmasize , "(ignored)");
1783 MODULE_PARM_DESC(use_dma , "(ignored)");
1786 MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
1787 MODULE_LICENSE("GPL");
1790 * media=t - specify media type
1794 * duplex=0 - specify forced half/full/autonegotiate duplex
1795 * debug=# - debug level
1797 * Default Chip Configuration:
1798 * DMA Burst = enabled
1799 * IOCHRDY Enabled = enabled
1801 * CS8900 defaults to half-duplex if not specified on command-line
1802 * CS8920 defaults to autoneg if not specified on command-line
1803 * Use reset defaults for other config parameters
1806 * media type specified is supported (circuitry is present)
1807 * if memory address is > 1MB, then required mem decode hw is present
1808 * if 10B-2, then agent other than driver will enable DC/DC converter
1809 * (hw or software util)
1812 int __init init_module(void)
1814 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1815 struct net_local *lp;
1827 dev->base_addr = io;
1828 lp = netdev_priv(dev);
1832 lp->use_dma = use_dma;
1834 lp->dmasize = dmasize;
1838 spin_lock_init(&lp->lock);
1840 /* boy, they'd better get these right */
1841 if (!strcmp(media, "rj45"))
1842 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1843 else if (!strcmp(media, "aui"))
1844 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1845 else if (!strcmp(media, "bnc"))
1846 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1848 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1851 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1854 pr_err("Module autoprobing not allowed\n");
1855 pr_err("Append io=0xNNN\n");
1858 } else if (io <= 0x1ff) {
1864 if (use_dma && dmasize != 16 && dmasize != 64) {
1865 pr_err("dma size must be either 16K or 64K, not %dK\n",
1871 ret = cs89x0_ioport_probe(dev, io, 1);
1883 cleanup_module(void)
1885 struct net_local *lp = netdev_priv(dev_cs89x0);
1887 unregister_netdev(dev_cs89x0);
1888 iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1889 ioport_unmap(lp->virt_addr);
1890 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1891 free_netdev(dev_cs89x0);
1893 #endif /* MODULE && !CONFIG_CS89x0_PLATFORM */
1895 #ifdef CONFIG_CS89x0_PLATFORM
1896 static int __init cs89x0_platform_probe(struct platform_device *pdev)
1898 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1899 struct net_local *lp;
1900 struct resource *mem_res;
1901 void __iomem *virt_addr;
1907 lp = netdev_priv(dev);
1909 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1910 dev->irq = platform_get_irq(pdev, 0);
1911 if (mem_res == NULL || dev->irq <= 0) {
1912 dev_warn(&dev->dev, "memory/interrupt resource missing\n");
1917 lp->size = resource_size(mem_res);
1918 if (!request_mem_region(mem_res->start, lp->size, DRV_NAME)) {
1919 dev_warn(&dev->dev, "request_mem_region() failed\n");
1924 virt_addr = ioremap(mem_res->start, lp->size);
1926 dev_warn(&dev->dev, "ioremap() failed\n");
1931 err = cs89x0_probe1(dev, virt_addr, 0);
1933 dev_warn(&dev->dev, "no cs8900 or cs8920 detected\n");
1937 platform_set_drvdata(pdev, dev);
1943 release_mem_region(mem_res->start, lp->size);
1949 static int cs89x0_platform_remove(struct platform_device *pdev)
1951 struct net_device *dev = platform_get_drvdata(pdev);
1952 struct net_local *lp = netdev_priv(dev);
1953 struct resource *mem_res;
1955 /* This platform_get_resource() call will not return NULL, because
1956 * the same call in cs89x0_platform_probe() has returned a non NULL
1959 mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1960 unregister_netdev(dev);
1961 iounmap(lp->virt_addr);
1962 release_mem_region(mem_res->start, lp->size);
1967 static struct platform_driver cs89x0_driver = {
1970 .owner = THIS_MODULE,
1972 .remove = cs89x0_platform_remove,
1975 module_platform_driver_probe(cs89x0_driver, cs89x0_platform_probe);
1977 #endif /* CONFIG_CS89x0_PLATFORM */