1 /* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0
6 Written 1996 by Russell Nelson, with reference to skeleton.c
7 written 1993-1994 by Donald Becker.
9 This software may be used and distributed according to the terms
10 of the GNU General Public License, incorporated herein by reference.
12 The author may be reached at nelson@crynwr.com, Crynwr
13 Software, 521 Pleasant Valley Rd., Potsdam, NY 13676
17 Mike Cruse : mcruse@cti-ltd.com
18 : Changes for Linux 2.0 compatibility.
19 : Added dev_id parameter in net_interrupt(),
20 : request_irq() and free_irq(). Just NULL for now.
22 Mike Cruse : Added MOD_INC_USE_COUNT and MOD_DEC_USE_COUNT macros
23 : in net_open() and net_close() so kerneld would know
24 : that the module is in use and wouldn't eject the
27 Mike Cruse : Rewrote init_module() and cleanup_module using 8390.c
28 : as an example. Disabled autoprobing in init_module(),
29 : not a good thing to do to other devices while Linux
30 : is running from all accounts.
32 Russ Nelson : Jul 13 1998. Added RxOnly DMA support.
34 Melody Lee : Aug 10 1999. Changes for Linux 2.2.5 compatibility.
35 : email: ethernet@crystal.cirrus.com
37 Alan Cox : Removed 1.2 support, added 2.1 extra counters.
39 Andrew Morton : andrewm@uow.edu.au
41 : Handle kmalloc() failures
42 : Other resource allocation fixes
44 : Integrate Russ Nelson's ALLOW_DMA functionality back in.
45 : If ALLOW_DMA is true, make DMA runtime selectable
46 : Folded in changes from Cirrus (Melody Lee
47 : <klee@crystal.cirrus.com>)
48 : Don't call netif_wake_queue() in net_send_packet()
49 : Fixed an out-of-mem bug in dma_rx()
50 : Updated Documentation/networking/cs89x0.txt
52 Andrew Morton : andrewm@uow.edu.au / Kernel 2.3.99-pre1
53 : Use skb_reserve to longword align IP header (two places)
54 : Remove a delay loop from dma_rx()
55 : Replace '100' with HZ
56 : Clean up a couple of skb API abuses
57 : Added 'cs89x0_dma=N' kernel boot option
58 : Correctly initialise lp->lock in non-module compile
60 Andrew Morton : andrewm@uow.edu.au / Kernel 2.3.99-pre4-1
61 : MOD_INC/DEC race fix (see
62 : http://www.uwsg.indiana.edu/hypermail/linux/kernel/0003.3/1532.html)
64 Andrew Morton : andrewm@uow.edu.au / Kernel 2.4.0-test7-pre2
65 : Enhanced EEPROM support to cover more devices,
66 : abstracted IRQ mapping to support CONFIG_ARCH_CLPS7500 arch
67 : (Jason Gunthorpe <jgg@ualberta.ca>)
69 Andrew Morton : Kernel 2.4.0-test11-pre4
70 : Use dev->name in request_*() (Andrey Panin)
71 : Fix an error-path memleak in init_module()
72 : Preserve return value from request_irq()
73 : Fix type of `media' module parm (Keith Owens)
74 : Use SET_MODULE_OWNER()
75 : Tidied up strange request_irq() abuse in net_open().
77 Andrew Morton : Kernel 2.4.3-pre1
78 : Request correct number of pages for DMA (Hugh Dickens)
79 : Select PP_ChipID _after_ unregister_netdev in cleanup_module()
80 : because unregister_netdev() calls get_stats.
81 : Make `version[]' __initdata
82 : Uninlined the read/write reg/word functions.
84 Oskar Schirmer : oskar@scara.com
85 : HiCO.SH4 (superh) support added (irq#1, cs89x0_media=)
87 Deepak Saxena : dsaxena@plexity.net
88 : Intel IXDP2x01 (XScale ixp2x00 NPU) platform support
92 /* Always include 'config.h' first in case the user wants to turn on
93 or override something. */
94 #include <linux/config.h>
95 #include <linux/module.h>
98 * Set this to zero to disable DMA code
100 * Note that even if DMA is turned off we still support the 'dma' and 'use_dma'
101 * module options so we don't break any startup scripts.
103 #ifndef CONFIG_ARCH_IXDP2X01
110 * Set this to zero to remove all the debug statements via
111 * dead code elimination
118 Crynwr packet driver epktisa.
120 Crystal Semiconductor data sheets.
124 #include <linux/errno.h>
125 #include <linux/netdevice.h>
126 #include <linux/etherdevice.h>
127 #include <linux/kernel.h>
128 #include <linux/types.h>
129 #include <linux/fcntl.h>
130 #include <linux/interrupt.h>
131 #include <linux/ioport.h>
132 #include <linux/in.h>
133 #include <linux/skbuff.h>
134 #include <linux/slab.h>
135 #include <linux/spinlock.h>
136 #include <linux/string.h>
137 #include <linux/init.h>
138 #include <linux/bitops.h>
140 #include <asm/system.h>
148 static char version[] __initdata =
149 "cs89x0.c: v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton <andrewm@uow.edu.au>\n";
151 #define DRV_NAME "cs89x0"
153 /* First, a few definitions that the brave might change.
154 A zero-terminated list of I/O addresses to be probed. Some special flags..
155 Addr & 1 = Read back the address port, look for signature and reset
156 the page window before probing
157 Addr & 3 = Reset the page window and probe
158 The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,
159 but it is possible that a Cirrus board could be plugged into the ISA
161 /* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
162 them to system IRQ numbers. This mapping is card specific and is set to
163 the configuration of the Cirrus Eval board for this chip. */
164 #ifdef CONFIG_ARCH_CLPS7500
165 static unsigned int netcard_portlist[] __initdata =
166 { 0x80090303, 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
167 static unsigned int cs8900_irq_map[] = {12,0,0,0};
168 #elif defined(CONFIG_SH_HICOSH4)
169 static unsigned int netcard_portlist[] __initdata =
171 static unsigned int cs8900_irq_map[] = {1,0,0,0};
172 #elif defined(CONFIG_ARCH_IXDP2X01)
174 static unsigned int netcard_portlist[] __initdata = {IXDP2X01_CS8900_VIRT_BASE, 0};
175 static unsigned int cs8900_irq_map[] = {IRQ_IXDP2X01_CS8900, 0, 0, 0};
177 static unsigned int netcard_portlist[] __initdata =
178 { 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
179 static unsigned int cs8900_irq_map[] = {10,11,12,5};
183 static unsigned int net_debug = DEBUGGING;
185 #define net_debug 0 /* gcc will remove all the debug code for us */
188 /* The number of low I/O ports used by the ethercard. */
189 #define NETCARD_IO_EXTENT 16
191 /* we allow the user to override various values normally set in the EEPROM */
192 #define FORCE_RJ45 0x0001 /* pick one of these three */
193 #define FORCE_AUI 0x0002
194 #define FORCE_BNC 0x0004
196 #define FORCE_AUTO 0x0010 /* pick one of these three */
197 #define FORCE_HALF 0x0020
198 #define FORCE_FULL 0x0030
200 /* Information that need to be kept for each board. */
202 struct net_device_stats stats;
203 int chip_type; /* one of: CS8900, CS8920, CS8920M */
204 char chip_revision; /* revision letter of the chip ('A'...) */
205 int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
206 int auto_neg_cnf; /* auto-negotiation word from EEPROM */
207 int adapter_cnf; /* adapter configuration from EEPROM */
208 int isa_config; /* ISA configuration from EEPROM */
209 int irq_map; /* IRQ map from EEPROM */
210 int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
211 int curr_rx_cfg; /* a copy of PP_RxCFG */
212 int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
213 int send_underrun; /* keep track of how many underruns in a row we get */
214 int force; /* force various values; see FORCE* above. */
217 int use_dma; /* Flag: we're using dma */
218 int dma; /* DMA channel */
219 int dmasize; /* 16 or 64 */
220 unsigned char *dma_buff; /* points to the beginning of the buffer */
221 unsigned char *end_dma_buff; /* points to the end of the buffer */
222 unsigned char *rx_dma_ptr; /* points to the next packet */
226 /* Index to functions, as function prototypes. */
228 static int cs89x0_probe1(struct net_device *dev, int ioaddr, int modular);
229 static int net_open(struct net_device *dev);
230 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
231 static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs *regs);
232 static void set_multicast_list(struct net_device *dev);
233 static void net_timeout(struct net_device *dev);
234 static void net_rx(struct net_device *dev);
235 static int net_close(struct net_device *dev);
236 static struct net_device_stats *net_get_stats(struct net_device *dev);
237 static void reset_chip(struct net_device *dev);
238 static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer);
239 static int get_eeprom_cksum(int off, int len, int *buffer);
240 static int set_mac_address(struct net_device *dev, void *addr);
241 static void count_rx_errors(int status, struct net_local *lp);
243 static void get_dma_channel(struct net_device *dev);
244 static void release_dma_buff(struct net_local *lp);
247 /* Example routines you must write ;->. */
248 #define tx_done(dev) 1
251 * Permit 'cs89x0_dma=N' in the kernel boot environment
253 #if !defined(MODULE) && (ALLOW_DMA != 0)
254 static int g_cs89x0_dma;
256 static int __init dma_fn(char *str)
258 g_cs89x0_dma = simple_strtol(str,NULL,0);
262 __setup("cs89x0_dma=", dma_fn);
263 #endif /* !defined(MODULE) && (ALLOW_DMA != 0) */
266 static int g_cs89x0_media__force;
268 static int __init media_fn(char *str)
270 if (!strcmp(str, "rj45")) g_cs89x0_media__force = FORCE_RJ45;
271 else if (!strcmp(str, "aui")) g_cs89x0_media__force = FORCE_AUI;
272 else if (!strcmp(str, "bnc")) g_cs89x0_media__force = FORCE_BNC;
276 __setup("cs89x0_media=", media_fn);
279 /* Check for a network adaptor of this type, and return '0' iff one exists.
280 If dev->base_addr == 0, probe all likely locations.
281 If dev->base_addr == 1, always return failure.
282 If dev->base_addr == 2, allocate space for the device and return success
283 (detachable devices only).
287 struct net_device * __init cs89x0_probe(int unit)
289 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
296 return ERR_PTR(-ENODEV);
298 sprintf(dev->name, "eth%d", unit);
299 netdev_boot_setup_check(dev);
304 printk("cs89x0:cs89x0_probe(0x%x)\n", io);
306 if (io > 0x1ff) { /* Check a single specified location. */
307 err = cs89x0_probe1(dev, io, 0);
308 } else if (io != 0) { /* Don't probe at all. */
311 for (port = netcard_portlist; *port; port++) {
312 if (cs89x0_probe1(dev, *port, 0) == 0)
321 err = register_netdev(dev);
326 outw(PP_ChipID, dev->base_addr + ADD_PORT);
327 release_region(dev->base_addr, NETCARD_IO_EXTENT);
330 printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
336 readreg(struct net_device *dev, int portno)
338 outw(portno, dev->base_addr + ADD_PORT);
339 return inw(dev->base_addr + DATA_PORT);
343 writereg(struct net_device *dev, int portno, int value)
345 outw(portno, dev->base_addr + ADD_PORT);
346 outw(value, dev->base_addr + DATA_PORT);
350 readword(struct net_device *dev, int portno)
352 return inw(dev->base_addr + portno);
356 writeword(struct net_device *dev, int portno, int value)
358 outw(value, dev->base_addr + portno);
362 wait_eeprom_ready(struct net_device *dev)
364 int timeout = jiffies;
365 /* check to see if the EEPROM is ready, a timeout is used -
366 just in case EEPROM is ready when SI_BUSY in the
367 PP_SelfST is clear */
368 while(readreg(dev, PP_SelfST) & SI_BUSY)
369 if (jiffies - timeout >= 40)
375 get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
379 if (net_debug > 3) printk("EEPROM data from %x for %x:\n",off,len);
380 for (i = 0; i < len; i++) {
381 if (wait_eeprom_ready(dev) < 0) return -1;
382 /* Now send the EEPROM read command and EEPROM location to read */
383 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
384 if (wait_eeprom_ready(dev) < 0) return -1;
385 buffer[i] = readreg(dev, PP_EEData);
386 if (net_debug > 3) printk("%04x ", buffer[i]);
388 if (net_debug > 3) printk("\n");
393 get_eeprom_cksum(int off, int len, int *buffer)
398 for (i = 0; i < len; i++)
406 /* This is the real probe routine. Linux has a history of friendly device
407 probes on the ISA bus. A good device probes avoids doing writes, and
408 verifies that the correct device exists and functions.
413 cs89x0_probe1(struct net_device *dev, int ioaddr, int modular)
415 struct net_local *lp = netdev_priv(dev);
416 static unsigned version_printed;
418 unsigned rev_type = 0;
419 int eeprom_buff[CHKSUM_LEN];
422 SET_MODULE_OWNER(dev);
423 /* Initialize the device structure. */
425 memset(lp, 0, sizeof(*lp));
426 spin_lock_init(&lp->lock);
431 lp->dma = g_cs89x0_dma;
432 lp->dmasize = 16; /* Could make this an option... */
435 lp->force = g_cs89x0_media__force;
439 /* Grab the region so we can find another board if autoIRQ fails. */
440 /* WTF is going on here? */
441 if (!request_region(ioaddr & ~3, NETCARD_IO_EXTENT, DRV_NAME)) {
442 printk(KERN_ERR "%s: request_region(0x%x, 0x%x) failed\n",
443 DRV_NAME, ioaddr, NETCARD_IO_EXTENT);
448 #ifdef CONFIG_SH_HICOSH4
449 /* truely reset the chip */
450 outw(0x0114, ioaddr + ADD_PORT);
451 outw(0x0040, ioaddr + DATA_PORT);
454 /* if they give us an odd I/O address, then do ONE write to
455 the address port, to get it back to address zero, where we
456 expect to find the EISA signature word. An IO with a base of 0x3
457 will skip the test for the ADD_PORT. */
460 printk(KERN_INFO "%s: odd ioaddr 0x%x\n", dev->name, ioaddr);
461 if ((ioaddr & 2) != 2)
462 if ((inw((ioaddr & ~3)+ ADD_PORT) & ADD_MASK) != ADD_SIG) {
463 printk(KERN_ERR "%s: bad signature 0x%x\n",
464 dev->name, inw((ioaddr & ~3)+ ADD_PORT));
469 printk("PP_addr=0x%x\n", inw(ioaddr + ADD_PORT));
472 outw(PP_ChipID, ioaddr + ADD_PORT);
474 if (inw(ioaddr + DATA_PORT) != CHIP_EISA_ID_SIG) {
475 printk(KERN_ERR "%s: incorrect signature 0x%x\n",
476 dev->name, inw(ioaddr + DATA_PORT));
481 /* Fill in the 'dev' fields. */
482 dev->base_addr = ioaddr;
484 /* get the chip type */
485 rev_type = readreg(dev, PRODUCT_ID_ADD);
486 lp->chip_type = rev_type &~ REVISON_BITS;
487 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
489 /* Check the chip type and revision in order to set the correct send command
490 CS8920 revision C and CS8900 revision F can use the faster send. */
491 lp->send_cmd = TX_AFTER_381;
492 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
493 lp->send_cmd = TX_NOW;
494 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
495 lp->send_cmd = TX_NOW;
497 if (net_debug && version_printed++ == 0)
500 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#3lx ",
502 lp->chip_type==CS8900?'0':'2',
503 lp->chip_type==CS8920M?"M":"",
509 /* Here we read the current configuration of the chip. If there
510 is no Extended EEPROM then the idea is to not disturb the chip
511 configuration, it should have been correctly setup by automatic
512 EEPROM read on reset. So, if the chip says it read the EEPROM
513 the driver will always do *something* instead of complain that
516 #ifdef CONFIG_SH_HICOSH4
518 /* For the HiCO.SH4 board, things are different: we don't
519 have EEPROM, but there is some data in flash, so we go
520 get it there directly (MAC). */
523 if (((* (volatile __u32 *) 0xa0013ff0) & 0x00ffffff)
525 confd = (__u16*) 0xa0013fc0;
527 confd = (__u16*) 0xa001ffc0;
529 cnt = (*confd++ & 0x00ff) >> 1;
533 switch (j & 0x0fff) {
535 for (i = 0; i < ETH_ALEN/2; i++) {
536 dev->dev_addr[i*2] = confd[i] & 0xFF;
537 dev->dev_addr[i*2+1] = confd[i] >> 8;
548 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
549 (EEPROM_OK|EEPROM_PRESENT)) {
551 for (i=0; i < ETH_ALEN/2; i++) {
553 Addr = readreg(dev, PP_IA+i*2);
554 dev->dev_addr[i*2] = Addr & 0xFF;
555 dev->dev_addr[i*2+1] = Addr >> 8;
558 /* Load the Adapter Configuration.
559 Note: Barring any more specific information from some
560 other source (ie EEPROM+Schematics), we would not know
561 how to operate a 10Base2 interface on the AUI port.
562 However, since we do read the status of HCB1 and use
563 settings that always result in calls to control_dc_dc(dev,0)
564 a BNC interface should work if the enable pin
565 (dc/dc converter) is on HCB1. It will be called AUI
569 i = readreg(dev, PP_LineCTL);
570 /* Preserve the setting of the HCB1 pin. */
571 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
572 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
573 /* Save the sqelch bit */
574 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
575 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
576 /* Check if the card is in 10Base-t only mode */
577 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
578 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
579 /* Check if the card is in AUI only mode */
580 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
581 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
582 /* Check if the card is in Auto mode. */
583 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
584 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
585 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
588 printk(KERN_INFO "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
589 dev->name, i, lp->adapter_cnf);
591 /* IRQ. Other chips already probe, see below. */
592 if (lp->chip_type == CS8900)
593 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
595 printk( "[Cirrus EEPROM] ");
600 /* First check to see if an EEPROM is attached. */
601 #ifdef CONFIG_SH_HICOSH4 /* no EEPROM on HiCO, don't hazzle with it here */
603 printk(KERN_NOTICE "cs89x0: No EEPROM on HiCO.SH4\n");
606 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
607 printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....\n");
608 else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
609 printk(KERN_WARNING "\ncs89x0: EEPROM read failed, relying on command line.\n");
610 } else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
611 /* Check if the chip was able to read its own configuration starting
613 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
614 (EEPROM_OK|EEPROM_PRESENT))
615 printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
618 /* This reads an extended EEPROM that is not documented
619 in the CS8900 datasheet. */
621 /* get transmission control word but keep the autonegotiation bits */
622 if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];
623 /* Store adapter configuration */
624 if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];
625 /* Store ISA configuration */
626 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2];
627 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;
629 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */
630 /* store the initial memory base address */
631 for (i = 0; i < ETH_ALEN/2; i++) {
632 dev->dev_addr[i*2] = eeprom_buff[i];
633 dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8;
636 printk(KERN_DEBUG "%s: new adapter_cnf: 0x%x\n",
637 dev->name, lp->adapter_cnf);
640 /* allow them to force multiple transceivers. If they force multiple, autosense */
643 if (lp->force & FORCE_RJ45) {lp->adapter_cnf |= A_CNF_10B_T; count++; }
644 if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_AUI; count++; }
645 if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_10B_2; count++; }
646 if (count > 1) {lp->adapter_cnf |= A_CNF_MEDIA_AUTO; }
647 else if (lp->force & FORCE_RJ45){lp->adapter_cnf |= A_CNF_MEDIA_10B_T; }
648 else if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_MEDIA_AUI; }
649 else if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_MEDIA_10B_2; }
653 printk(KERN_DEBUG "%s: after force 0x%x, adapter_cnf=0x%x\n",
654 dev->name, lp->force, lp->adapter_cnf);
656 /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
658 /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
660 /* FIXME: we don't set the Ethernet address on the command line. Use
661 ifconfig IFACE hw ether AABBCCDDEEFF */
663 printk(KERN_INFO "cs89x0 media %s%s%s",
664 (lp->adapter_cnf & A_CNF_10B_T)?"RJ-45,":"",
665 (lp->adapter_cnf & A_CNF_AUI)?"AUI,":"",
666 (lp->adapter_cnf & A_CNF_10B_2)?"BNC,":"");
668 lp->irq_map = 0xffff;
670 /* If this is a CS8900 then no pnp soft */
671 if (lp->chip_type != CS8900 &&
672 /* Check if the ISA IRQ has been set */
673 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
674 (i != 0 && i < CS8920_NO_INTS))) {
678 i = lp->isa_config & INT_NO_MASK;
679 if (lp->chip_type == CS8900) {
680 #ifdef CONFIG_ARCH_IXDP2X01
681 i = cs8900_irq_map[0];
683 /* Translate the IRQ using the IRQ mapping table. */
684 if (i >= sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]))
685 printk("\ncs89x0: invalid ISA interrupt number %d\n", i);
687 i = cs8900_irq_map[i];
689 lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
691 int irq_map_buff[IRQ_MAP_LEN/2];
693 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
695 irq_map_buff) >= 0) {
696 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
697 lp->irq_map = (irq_map_buff[0]>>8) | (irq_map_buff[1] << 8);
705 printk(" IRQ %d", dev->irq);
709 get_dma_channel(dev);
710 printk(", DMA %d", dev->dma);
715 printk(", programmed I/O");
718 /* print the ethernet address. */
720 for (i = 0; i < ETH_ALEN; i++)
722 printk("%c%02x", i ? ':' : ' ', dev->dev_addr[i]);
725 dev->open = net_open;
726 dev->stop = net_close;
727 dev->tx_timeout = net_timeout;
728 dev->watchdog_timeo = HZ;
729 dev->hard_start_xmit = net_send_packet;
730 dev->get_stats = net_get_stats;
731 dev->set_multicast_list = set_multicast_list;
732 dev->set_mac_address = set_mac_address;
736 printk("cs89x0_probe1() successful\n");
739 release_region(ioaddr & ~3, NETCARD_IO_EXTENT);
745 /*********************************
746 * This page contains DMA routines
747 **********************************/
751 #define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
754 get_dma_channel(struct net_device *dev)
756 struct net_local *lp = netdev_priv(dev);
760 lp->isa_config |= ISA_RxDMA;
762 if ((lp->isa_config & ANY_ISA_DMA) == 0)
764 dev->dma = lp->isa_config & DMA_NO_MASK;
765 if (lp->chip_type == CS8900)
767 if (dev->dma < 5 || dev->dma > 7) {
768 lp->isa_config &= ~ANY_ISA_DMA;
776 write_dma(struct net_device *dev, int chip_type, int dma)
778 struct net_local *lp = netdev_priv(dev);
779 if ((lp->isa_config & ANY_ISA_DMA) == 0)
781 if (chip_type == CS8900) {
782 writereg(dev, PP_CS8900_ISADMA, dma-5);
784 writereg(dev, PP_CS8920_ISADMA, dma);
789 set_dma_cfg(struct net_device *dev)
791 struct net_local *lp = netdev_priv(dev);
794 if ((lp->isa_config & ANY_ISA_DMA) == 0) {
796 printk("set_dma_cfg(): no DMA\n");
799 if (lp->isa_config & ISA_RxDMA) {
800 lp->curr_rx_cfg |= RX_DMA_ONLY;
802 printk("set_dma_cfg(): RX_DMA_ONLY\n");
804 lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
806 printk("set_dma_cfg(): AUTO_RX_DMA\n");
812 dma_bufcfg(struct net_device *dev)
814 struct net_local *lp = netdev_priv(dev);
816 return (lp->isa_config & ANY_ISA_DMA)? RX_DMA_ENBL : 0;
822 dma_busctl(struct net_device *dev)
825 struct net_local *lp = netdev_priv(dev);
827 if (lp->isa_config & ANY_ISA_DMA)
828 retval |= RESET_RX_DMA; /* Reset the DMA pointer */
829 if (lp->isa_config & DMA_BURST)
830 retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
831 if (lp->dmasize == 64)
832 retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
833 retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
839 dma_rx(struct net_device *dev)
841 struct net_local *lp = netdev_priv(dev);
844 unsigned char *bp = lp->rx_dma_ptr;
846 status = bp[0] + (bp[1]<<8);
847 length = bp[2] + (bp[3]<<8);
850 printk( "%s: receiving DMA packet at %lx, status %x, length %x\n",
851 dev->name, (unsigned long)bp, status, length);
853 if ((status & RX_OK) == 0) {
854 count_rx_errors(status, lp);
855 goto skip_this_frame;
858 /* Malloc up new buffer. */
859 skb = dev_alloc_skb(length + 2);
861 if (net_debug) /* I don't think we want to do this to a stressed system */
862 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
863 lp->stats.rx_dropped++;
865 /* AKPM: advance bp to the next frame */
867 bp += (length + 3) & ~3;
868 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
872 skb_reserve(skb, 2); /* longword align L3 header */
875 if (bp + length > lp->end_dma_buff) {
876 int semi_cnt = lp->end_dma_buff - bp;
877 memcpy(skb_put(skb,semi_cnt), bp, semi_cnt);
878 memcpy(skb_put(skb,length - semi_cnt), lp->dma_buff,
881 memcpy(skb_put(skb,length), bp, length);
883 bp += (length + 3) & ~3;
884 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
888 printk( "%s: received %d byte DMA packet of type %x\n",
890 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
892 skb->protocol=eth_type_trans(skb,dev);
894 dev->last_rx = jiffies;
895 lp->stats.rx_packets++;
896 lp->stats.rx_bytes += length;
899 #endif /* ALLOW_DMA */
901 void __init reset_chip(struct net_device *dev)
903 #ifndef CONFIG_ARCH_IXDP2X01
904 struct net_local *lp = netdev_priv(dev);
905 int ioaddr = dev->base_addr;
907 int reset_start_time;
909 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
912 current->state = TASK_INTERRUPTIBLE;
913 schedule_timeout(30*HZ/1000);
915 #ifndef CONFIG_ARCH_IXDP2X01
916 if (lp->chip_type != CS8900) {
917 /* Hardware problem requires PNP registers to be reconfigured after a reset */
918 outw(PP_CS8920_ISAINT, ioaddr + ADD_PORT);
919 outb(dev->irq, ioaddr + DATA_PORT);
920 outb(0, ioaddr + DATA_PORT + 1);
922 outw(PP_CS8920_ISAMemB, ioaddr + ADD_PORT);
923 outb((dev->mem_start >> 16) & 0xff, ioaddr + DATA_PORT);
924 outb((dev->mem_start >> 8) & 0xff, ioaddr + DATA_PORT + 1);
926 #endif /* IXDP2x01 */
928 /* Wait until the chip is reset */
929 reset_start_time = jiffies;
930 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
936 control_dc_dc(struct net_device *dev, int on_not_off)
938 struct net_local *lp = netdev_priv(dev);
939 unsigned int selfcontrol;
940 int timenow = jiffies;
941 /* control the DC to DC convertor in the SelfControl register.
942 Note: This is hooked up to a general purpose pin, might not
943 always be a DC to DC convertor. */
945 selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
946 if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
949 selfcontrol &= ~HCB1;
950 writereg(dev, PP_SelfCTL, selfcontrol);
952 /* Wait for the DC/DC converter to power up - 500ms */
953 while (jiffies - timenow < HZ)
957 #define DETECTED_NONE 0
958 #define DETECTED_RJ45H 1
959 #define DETECTED_RJ45F 2
960 #define DETECTED_AUI 3
961 #define DETECTED_BNC 4
964 detect_tp(struct net_device *dev)
966 struct net_local *lp = netdev_priv(dev);
967 int timenow = jiffies;
970 if (net_debug > 1) printk("%s: Attempting TP\n", dev->name);
972 /* If connected to another full duplex capable 10-Base-T card the link pulses
973 seem to be lost when the auto detect bit in the LineCTL is set.
974 To overcome this the auto detect bit will be cleared whilst testing the
975 10-Base-T interface. This would not be necessary for the sparrow chip but
976 is simpler to do it anyway. */
977 writereg(dev, PP_LineCTL, lp->linectl &~ AUI_ONLY);
978 control_dc_dc(dev, 0);
980 /* Delay for the hardware to work out if the TP cable is present - 150ms */
981 for (timenow = jiffies; jiffies - timenow < 15; )
983 if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
984 return DETECTED_NONE;
986 if (lp->chip_type == CS8900) {
987 switch (lp->force & 0xf0) {
990 printk("%s: cs8900 doesn't autonegotiate\n",dev->name);
991 return DETECTED_NONE;
993 /* CS8900 doesn't support AUTO, change to HALF*/
995 lp->force &= ~FORCE_AUTO;
996 lp->force |= FORCE_HALF;
1001 writereg(dev, PP_TestCTL, readreg(dev, PP_TestCTL) | FDX_8900);
1004 fdx = readreg(dev, PP_TestCTL) & FDX_8900;
1006 switch (lp->force & 0xf0) {
1008 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1011 lp->auto_neg_cnf = 0;
1014 lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
1018 writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
1020 if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
1021 printk(KERN_INFO "%s: negotiating duplex...\n",dev->name);
1022 while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
1023 if (jiffies - timenow > 4000) {
1024 printk(KERN_ERR "**** Full / half duplex auto-negotiation timed out ****\n");
1029 fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
1032 return DETECTED_RJ45F;
1034 return DETECTED_RJ45H;
1037 /* send a test packet - return true if carrier bits are ok */
1039 send_test_pkt(struct net_device *dev)
1041 char test_packet[] = { 0,0,0,0,0,0, 0,0,0,0,0,0,
1042 0, 46, /* A 46 in network order */
1043 0, 0, /* DSAP=0 & SSAP=0 fields */
1044 0xf3, 0 /* Control (Test Req + P bit set) */ };
1045 long timenow = jiffies;
1047 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
1049 memcpy(test_packet, dev->dev_addr, ETH_ALEN);
1050 memcpy(test_packet+ETH_ALEN, dev->dev_addr, ETH_ALEN);
1052 writeword(dev, TX_CMD_PORT, TX_AFTER_ALL);
1053 writeword(dev, TX_LEN_PORT, ETH_ZLEN);
1055 /* Test to see if the chip has allocated memory for the packet */
1056 while (jiffies - timenow < 5)
1057 if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
1059 if (jiffies - timenow >= 5)
1060 return 0; /* this shouldn't happen */
1062 /* Write the contents of the packet */
1063 outsw(dev->base_addr + TX_FRAME_PORT,test_packet,(ETH_ZLEN+1) >>1);
1065 if (net_debug > 1) printk("Sending test packet ");
1066 /* wait a couple of jiffies for packet to be received */
1067 for (timenow = jiffies; jiffies - timenow < 3; )
1069 if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
1070 if (net_debug > 1) printk("succeeded\n");
1073 if (net_debug > 1) printk("failed\n");
1079 detect_aui(struct net_device *dev)
1081 struct net_local *lp = netdev_priv(dev);
1083 if (net_debug > 1) printk("%s: Attempting AUI\n", dev->name);
1084 control_dc_dc(dev, 0);
1086 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1088 if (send_test_pkt(dev))
1089 return DETECTED_AUI;
1091 return DETECTED_NONE;
1095 detect_bnc(struct net_device *dev)
1097 struct net_local *lp = netdev_priv(dev);
1099 if (net_debug > 1) printk("%s: Attempting BNC\n", dev->name);
1100 control_dc_dc(dev, 1);
1102 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1104 if (send_test_pkt(dev))
1105 return DETECTED_BNC;
1107 return DETECTED_NONE;
1112 write_irq(struct net_device *dev, int chip_type, int irq)
1116 if (chip_type == CS8900) {
1117 /* Search the mapping table for the corresponding IRQ pin. */
1118 for (i = 0; i != sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]); i++)
1119 if (cs8900_irq_map[i] == irq)
1122 if (i == sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]))
1124 writereg(dev, PP_CS8900_ISAINT, i);
1126 writereg(dev, PP_CS8920_ISAINT, irq);
1130 /* Open/initialize the board. This is called (in the current kernel)
1131 sometime after booting when the 'ifconfig' program is run.
1133 This routine should set everything up anew at each open, even
1134 registers that "should" only need to be set once at boot, so that
1135 there is non-reboot way to recover if something goes wrong.
1138 /* AKPM: do we need to do any locking here? */
1141 net_open(struct net_device *dev)
1143 struct net_local *lp = netdev_priv(dev);
1148 #ifndef CONFIG_SH_HICOSH4 /* uses irq#1, so this won't work */
1150 /* Allow interrupts to be generated by the chip */
1151 /* Cirrus' release had this: */
1153 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1155 /* And 2.3.47 had this: */
1156 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1158 for (i = 2; i < CS8920_NO_INTS; i++) {
1159 if ((1 << i) & lp->irq_map) {
1160 if (request_irq(i, net_interrupt, 0, dev->name, dev) == 0) {
1162 write_irq(dev, lp->chip_type, i);
1163 /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
1169 if (i >= CS8920_NO_INTS) {
1170 writereg(dev, PP_BusCTL, 0); /* disable interrupts. */
1171 printk(KERN_ERR "cs89x0: can't get an interrupt\n");
1179 #ifndef CONFIG_ARCH_IXDP2X01
1180 if (((1 << dev->irq) & lp->irq_map) == 0) {
1181 printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
1182 dev->name, dev->irq, lp->irq_map);
1187 /* FIXME: Cirrus' release had this: */
1188 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1189 /* And 2.3.47 had this: */
1191 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1193 write_irq(dev, lp->chip_type, dev->irq);
1194 ret = request_irq(dev->irq, &net_interrupt, 0, dev->name, dev);
1197 printk(KERN_DEBUG "cs89x0: request_irq(%d) failed\n", dev->irq);
1204 if (lp->isa_config & ANY_ISA_DMA) {
1205 unsigned long flags;
1206 lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
1207 get_order(lp->dmasize * 1024));
1209 if (!lp->dma_buff) {
1210 printk(KERN_ERR "%s: cannot get %dK memory for DMA\n", dev->name, lp->dmasize);
1213 if (net_debug > 1) {
1214 printk( "%s: dma %lx %lx\n",
1216 (unsigned long)lp->dma_buff,
1217 (unsigned long)isa_virt_to_bus(lp->dma_buff));
1219 if ((unsigned long) lp->dma_buff >= MAX_DMA_ADDRESS ||
1220 !dma_page_eq(lp->dma_buff, lp->dma_buff+lp->dmasize*1024-1)) {
1221 printk(KERN_ERR "%s: not usable as DMA buffer\n", dev->name);
1224 memset(lp->dma_buff, 0, lp->dmasize * 1024); /* Why? */
1225 if (request_dma(dev->dma, dev->name)) {
1226 printk(KERN_ERR "%s: cannot get dma channel %d\n", dev->name, dev->dma);
1229 write_dma(dev, lp->chip_type, dev->dma);
1230 lp->rx_dma_ptr = lp->dma_buff;
1231 lp->end_dma_buff = lp->dma_buff + lp->dmasize*1024;
1232 spin_lock_irqsave(&lp->lock, flags);
1233 disable_dma(dev->dma);
1234 clear_dma_ff(dev->dma);
1235 set_dma_mode(dev->dma, 0x14); /* auto_init as well */
1236 set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
1237 set_dma_count(dev->dma, lp->dmasize*1024);
1238 enable_dma(dev->dma);
1239 spin_unlock_irqrestore(&lp->lock, flags);
1242 #endif /* ALLOW_DMA */
1244 /* set the Ethernet address */
1245 for (i=0; i < ETH_ALEN/2; i++)
1246 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1248 /* while we're testing the interface, leave interrupts disabled */
1249 writereg(dev, PP_BusCTL, MEMORY_ON);
1251 /* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
1252 if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) && (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
1253 lp->linectl = LOW_RX_SQUELCH;
1257 /* check to make sure that they have the "right" hardware available */
1258 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1259 case A_CNF_MEDIA_10B_T: result = lp->adapter_cnf & A_CNF_10B_T; break;
1260 case A_CNF_MEDIA_AUI: result = lp->adapter_cnf & A_CNF_AUI; break;
1261 case A_CNF_MEDIA_10B_2: result = lp->adapter_cnf & A_CNF_10B_2; break;
1262 default: result = lp->adapter_cnf & (A_CNF_10B_T | A_CNF_AUI | A_CNF_10B_2);
1265 printk(KERN_ERR "%s: EEPROM is configured for unavailable media\n", dev->name);
1268 release_dma_buff(lp);
1270 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
1271 free_irq(dev->irq, dev);
1276 /* set the hardware to the configured choice */
1277 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1278 case A_CNF_MEDIA_10B_T:
1279 result = detect_tp(dev);
1280 if (result==DETECTED_NONE) {
1281 printk(KERN_WARNING "%s: 10Base-T (RJ-45) has no cable\n", dev->name);
1282 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1283 result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
1286 case A_CNF_MEDIA_AUI:
1287 result = detect_aui(dev);
1288 if (result==DETECTED_NONE) {
1289 printk(KERN_WARNING "%s: 10Base-5 (AUI) has no cable\n", dev->name);
1290 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1291 result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
1294 case A_CNF_MEDIA_10B_2:
1295 result = detect_bnc(dev);
1296 if (result==DETECTED_NONE) {
1297 printk(KERN_WARNING "%s: 10Base-2 (BNC) has no cable\n", dev->name);
1298 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1299 result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
1302 case A_CNF_MEDIA_AUTO:
1303 writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
1304 if (lp->adapter_cnf & A_CNF_10B_T)
1305 if ((result = detect_tp(dev)) != DETECTED_NONE)
1307 if (lp->adapter_cnf & A_CNF_AUI)
1308 if ((result = detect_aui(dev)) != DETECTED_NONE)
1310 if (lp->adapter_cnf & A_CNF_10B_2)
1311 if ((result = detect_bnc(dev)) != DETECTED_NONE)
1313 printk(KERN_ERR "%s: no media detected\n", dev->name);
1318 printk(KERN_ERR "%s: no network cable attached to configured media\n", dev->name);
1320 case DETECTED_RJ45H:
1321 printk(KERN_INFO "%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
1323 case DETECTED_RJ45F:
1324 printk(KERN_INFO "%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
1327 printk(KERN_INFO "%s: using 10Base-5 (AUI)\n", dev->name);
1330 printk(KERN_INFO "%s: using 10Base-2 (BNC)\n", dev->name);
1334 /* Turn on both receive and transmit operations */
1335 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1337 /* Receive only error free packets addressed to this card */
1339 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
1341 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
1343 if (lp->isa_config & STREAM_TRANSFER)
1344 lp->curr_rx_cfg |= RX_STREAM_ENBL;
1348 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
1350 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
1351 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
1353 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
1357 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
1359 /* now that we've got our act together, enable everything */
1360 writereg(dev, PP_BusCTL, ENABLE_IRQ
1361 | (dev->mem_start?MEMORY_ON : 0) /* turn memory on */
1366 netif_start_queue(dev);
1368 printk("cs89x0: net_open() succeeded\n");
1374 static void net_timeout(struct net_device *dev)
1376 /* If we get here, some higher level has decided we are broken.
1377 There should really be a "kick me" function call instead. */
1378 if (net_debug > 0) printk("%s: transmit timed out, %s?\n", dev->name,
1379 tx_done(dev) ? "IRQ conflict ?" : "network cable problem");
1380 /* Try to restart the adaptor. */
1381 netif_wake_queue(dev);
1384 static int net_send_packet(struct sk_buff *skb, struct net_device *dev)
1386 struct net_local *lp = netdev_priv(dev);
1388 if (net_debug > 3) {
1389 printk("%s: sent %d byte packet of type %x\n",
1390 dev->name, skb->len,
1391 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1394 /* keep the upload from being interrupted, since we
1395 ask the chip to start transmitting before the
1396 whole packet has been completely uploaded. */
1398 spin_lock_irq(&lp->lock);
1399 netif_stop_queue(dev);
1401 /* initiate a transmit sequence */
1402 writeword(dev, TX_CMD_PORT, lp->send_cmd);
1403 writeword(dev, TX_LEN_PORT, skb->len);
1405 /* Test to see if the chip has allocated memory for the packet */
1406 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1408 * Gasp! It hasn't. But that shouldn't happen since
1409 * we're waiting for TxOk, so return 1 and requeue this packet.
1412 spin_unlock_irq(&lp->lock);
1413 if (net_debug) printk("cs89x0: Tx buffer not free!\n");
1416 /* Write the contents of the packet */
1417 outsw(dev->base_addr + TX_FRAME_PORT,skb->data,(skb->len+1) >>1);
1418 spin_unlock_irq(&lp->lock);
1419 dev->trans_start = jiffies;
1420 dev_kfree_skb (skb);
1423 * We DO NOT call netif_wake_queue() here.
1424 * We also DO NOT call netif_start_queue().
1426 * Either of these would cause another bottom half run through
1427 * net_send_packet() before this packet has fully gone out. That causes
1428 * us to hit the "Gasp!" above and the send is rescheduled. it runs like
1429 * a dog. We just return and wait for the Tx completion interrupt handler
1430 * to restart the netdevice layer
1436 /* The typical workload of the driver:
1437 Handle the network interface interrupts. */
1439 static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1441 struct net_device *dev = dev_id;
1442 struct net_local *lp;
1446 ioaddr = dev->base_addr;
1447 lp = netdev_priv(dev);
1449 /* we MUST read all the events out of the ISQ, otherwise we'll never
1450 get interrupted again. As a consequence, we can't have any limit
1451 on the number of times we loop in the interrupt handler. The
1452 hardware guarantees that eventually we'll run out of events. Of
1453 course, if you're on a slow machine, and packets are arriving
1454 faster than you can read them off, you're screwed. Hasta la
1456 while ((status = readword(dev, ISQ_PORT))) {
1457 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
1459 switch(status & ISQ_EVENT_MASK) {
1460 case ISQ_RECEIVER_EVENT:
1461 /* Got a packet(s). */
1464 case ISQ_TRANSMITTER_EVENT:
1465 lp->stats.tx_packets++;
1466 netif_wake_queue(dev); /* Inform upper layers. */
1467 if ((status & ( TX_OK |
1471 TX_16_COL)) != TX_OK) {
1472 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
1473 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
1474 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
1475 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
1476 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
1479 case ISQ_BUFFER_EVENT:
1480 if (status & READY_FOR_TX) {
1481 /* we tried to transmit a packet earlier,
1482 but inexplicably ran out of buffers.
1483 That shouldn't happen since we only ever
1484 load one packet. Shrug. Do the right
1486 netif_wake_queue(dev); /* Inform upper layers. */
1488 if (status & TX_UNDERRUN) {
1489 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
1490 lp->send_underrun++;
1491 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
1492 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
1493 /* transmit cycle is done, although
1494 frame wasn't transmitted - this
1495 avoids having to wait for the upper
1496 layers to timeout on us, in the
1497 event of a tx underrun */
1498 netif_wake_queue(dev); /* Inform upper layers. */
1501 if (lp->use_dma && (status & RX_DMA)) {
1502 int count = readreg(dev, PP_DmaFrameCnt);
1505 printk("%s: receiving %d DMA frames\n", dev->name, count);
1506 if (net_debug > 2 && count >1)
1507 printk("%s: receiving %d DMA frames\n", dev->name, count);
1510 count = readreg(dev, PP_DmaFrameCnt);
1511 if (net_debug > 2 && count > 0)
1512 printk("%s: continuing with %d DMA frames\n", dev->name, count);
1517 case ISQ_RX_MISS_EVENT:
1518 lp->stats.rx_missed_errors += (status >>6);
1520 case ISQ_TX_COL_EVENT:
1521 lp->stats.collisions += (status >>6);
1525 return IRQ_RETVAL(handled);
1529 count_rx_errors(int status, struct net_local *lp)
1531 lp->stats.rx_errors++;
1532 if (status & RX_RUNT) lp->stats.rx_length_errors++;
1533 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
1534 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
1536 lp->stats.rx_crc_errors++;
1537 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
1541 /* We have a good packet(s), get it/them out of the buffers. */
1543 net_rx(struct net_device *dev)
1545 struct net_local *lp = netdev_priv(dev);
1546 struct sk_buff *skb;
1549 int ioaddr = dev->base_addr;
1550 status = inw(ioaddr + RX_FRAME_PORT);
1551 length = inw(ioaddr + RX_FRAME_PORT);
1553 if ((status & RX_OK) == 0) {
1554 count_rx_errors(status, lp);
1558 /* Malloc up new buffer. */
1559 skb = dev_alloc_skb(length + 2);
1561 #if 0 /* Again, this seems a cruel thing to do */
1562 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1564 lp->stats.rx_dropped++;
1567 skb_reserve(skb, 2); /* longword align L3 header */
1570 insw(ioaddr + RX_FRAME_PORT, skb_put(skb, length), length >> 1);
1572 skb->data[length-1] = inw(ioaddr + RX_FRAME_PORT);
1574 if (net_debug > 3) {
1575 printk( "%s: received %d byte packet of type %x\n",
1577 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1580 skb->protocol=eth_type_trans(skb,dev);
1582 dev->last_rx = jiffies;
1583 lp->stats.rx_packets++;
1584 lp->stats.rx_bytes += length;
1588 static void release_dma_buff(struct net_local *lp)
1591 free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024));
1592 lp->dma_buff = NULL;
1597 /* The inverse routine to net_open(). */
1599 net_close(struct net_device *dev)
1602 struct net_local *lp = netdev_priv(dev);
1605 netif_stop_queue(dev);
1607 writereg(dev, PP_RxCFG, 0);
1608 writereg(dev, PP_TxCFG, 0);
1609 writereg(dev, PP_BufCFG, 0);
1610 writereg(dev, PP_BusCTL, 0);
1612 free_irq(dev->irq, dev);
1615 if (lp->use_dma && lp->dma) {
1617 release_dma_buff(lp);
1621 /* Update the statistics here. */
1625 /* Get the current statistics. This may be called with the card open or
1627 static struct net_device_stats *
1628 net_get_stats(struct net_device *dev)
1630 struct net_local *lp = netdev_priv(dev);
1631 unsigned long flags;
1633 spin_lock_irqsave(&lp->lock, flags);
1634 /* Update the statistics from the device registers. */
1635 lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1636 lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1637 spin_unlock_irqrestore(&lp->lock, flags);
1642 static void set_multicast_list(struct net_device *dev)
1644 struct net_local *lp = netdev_priv(dev);
1645 unsigned long flags;
1647 spin_lock_irqsave(&lp->lock, flags);
1648 if(dev->flags&IFF_PROMISC)
1650 lp->rx_mode = RX_ALL_ACCEPT;
1652 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
1654 /* The multicast-accept list is initialized to accept-all, and we
1655 rely on higher-level filtering for now. */
1656 lp->rx_mode = RX_MULTCAST_ACCEPT;
1661 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1663 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
1664 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
1665 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
1666 spin_unlock_irqrestore(&lp->lock, flags);
1670 static int set_mac_address(struct net_device *dev, void *p)
1673 struct sockaddr *addr = p;
1676 if (netif_running(dev))
1679 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1682 printk("%s: Setting MAC address to ", dev->name);
1683 for (i = 0; i < dev->addr_len; i++)
1684 printk(" %2.2x", dev->dev_addr[i]);
1687 /* set the Ethernet address */
1688 for (i=0; i < ETH_ALEN/2; i++)
1689 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1696 static struct net_device *dev_cs89x0;
1699 * Support the 'debug' module parm even if we're compiled for non-debug to
1700 * avoid breaking someone's startup scripts
1706 static char media[8];
1707 static int duplex=-1;
1709 static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
1711 static int dmasize=16; /* or 64 */
1713 MODULE_PARM(io, "i");
1714 MODULE_PARM(irq, "i");
1715 MODULE_PARM(debug, "i");
1716 MODULE_PARM(media, "c8");
1717 MODULE_PARM(duplex, "i");
1718 MODULE_PARM(dma , "i");
1719 MODULE_PARM(dmasize , "i");
1720 MODULE_PARM(use_dma , "i");
1721 MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1722 MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1724 MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1726 MODULE_PARM_DESC(debug, "(ignored)");
1728 MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1729 /* No other value than -1 for duplex seems to be currently interpreted */
1730 MODULE_PARM_DESC(duplex, "(ignored)");
1732 MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1733 MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1734 MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1736 MODULE_PARM_DESC(dma , "(ignored)");
1737 MODULE_PARM_DESC(dmasize , "(ignored)");
1738 MODULE_PARM_DESC(use_dma , "(ignored)");
1741 MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton <andrewm@uow.edu.au>");
1742 MODULE_LICENSE("GPL");
1746 * media=t - specify media type
1750 * duplex=0 - specify forced half/full/autonegotiate duplex
1751 * debug=# - debug level
1754 * Default Chip Configuration:
1755 * DMA Burst = enabled
1756 * IOCHRDY Enabled = enabled
1758 * CS8900 defaults to half-duplex if not specified on command-line
1759 * CS8920 defaults to autoneg if not specified on command-line
1760 * Use reset defaults for other config parameters
1763 * media type specified is supported (circuitry is present)
1764 * if memory address is > 1MB, then required mem decode hw is present
1765 * if 10B-2, then agent other than driver will enable DC/DC converter
1766 (hw or software util)
1774 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1775 struct net_local *lp;
1787 dev->base_addr = io;
1788 lp = netdev_priv(dev);
1792 lp->use_dma = use_dma;
1794 lp->dmasize = dmasize;
1798 spin_lock_init(&lp->lock);
1800 /* boy, they'd better get these right */
1801 if (!strcmp(media, "rj45"))
1802 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1803 else if (!strcmp(media, "aui"))
1804 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1805 else if (!strcmp(media, "bnc"))
1806 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1808 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1811 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1814 printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n");
1815 printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n");
1818 } else if (io <= 0x1ff) {
1824 if (use_dma && dmasize != 16 && dmasize != 64) {
1825 printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize);
1830 ret = cs89x0_probe1(dev, io, 1);
1834 if (register_netdev(dev) != 0) {
1835 printk(KERN_ERR "cs89x0.c: No card found at 0x%x\n", io);
1837 outw(PP_ChipID, dev->base_addr + ADD_PORT);
1838 release_region(dev->base_addr, NETCARD_IO_EXTENT);
1849 cleanup_module(void)
1851 unregister_netdev(dev_cs89x0);
1852 outw(PP_ChipID, dev_cs89x0->base_addr + ADD_PORT);
1853 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1854 free_netdev(dev_cs89x0);
1860 * version-control: t
1861 * kept-new-versions: 5