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=)
89 /* Always include 'config.h' first in case the user wants to turn on
90 or override something. */
91 #include <linux/config.h>
92 #include <linux/module.h>
95 * Set this to zero to disable DMA code
97 * Note that even if DMA is turned off we still support the 'dma' and 'use_dma'
98 * module options so we don't break any startup scripts.
103 * Set this to zero to remove all the debug statements via
104 * dead code elimination
111 Crynwr packet driver epktisa.
113 Crystal Semiconductor data sheets.
117 #include <linux/errno.h>
118 #include <linux/netdevice.h>
119 #include <linux/etherdevice.h>
120 #include <linux/kernel.h>
121 #include <linux/types.h>
122 #include <linux/fcntl.h>
123 #include <linux/interrupt.h>
124 #include <linux/ioport.h>
125 #include <linux/in.h>
126 #include <linux/skbuff.h>
127 #include <linux/slab.h>
128 #include <linux/spinlock.h>
129 #include <linux/string.h>
130 #include <linux/init.h>
132 #include <asm/system.h>
133 #include <asm/bitops.h>
141 static char version[] __initdata =
142 "cs89x0.c: v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton <andrewm@uow.edu.au>\n";
144 /* First, a few definitions that the brave might change.
145 A zero-terminated list of I/O addresses to be probed. Some special flags..
146 Addr & 1 = Read back the address port, look for signature and reset
147 the page window before probing
148 Addr & 3 = Reset the page window and probe
149 The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,
150 but it is possible that a Cirrus board could be plugged into the ISA
152 /* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
153 them to system IRQ numbers. This mapping is card specific and is set to
154 the configuration of the Cirrus Eval board for this chip. */
155 #ifdef CONFIG_ARCH_CLPS7500
156 static unsigned int netcard_portlist[] __initdata =
157 { 0x80090303, 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
158 static unsigned int cs8900_irq_map[] = {12,0,0,0};
159 #elif defined(CONFIG_SH_HICOSH4)
160 static unsigned int netcard_portlist[] __initdata =
162 static unsigned int cs8900_irq_map[] = {1,0,0,0};
164 static unsigned int netcard_portlist[] __initdata =
165 { 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
166 static unsigned int cs8900_irq_map[] = {10,11,12,5};
170 static unsigned int net_debug = DEBUGGING;
172 #define net_debug 0 /* gcc will remove all the debug code for us */
175 /* The number of low I/O ports used by the ethercard. */
176 #define NETCARD_IO_EXTENT 16
178 /* we allow the user to override various values normally set in the EEPROM */
179 #define FORCE_RJ45 0x0001 /* pick one of these three */
180 #define FORCE_AUI 0x0002
181 #define FORCE_BNC 0x0004
183 #define FORCE_AUTO 0x0010 /* pick one of these three */
184 #define FORCE_HALF 0x0020
185 #define FORCE_FULL 0x0030
187 /* Information that need to be kept for each board. */
189 struct net_device_stats stats;
190 int chip_type; /* one of: CS8900, CS8920, CS8920M */
191 char chip_revision; /* revision letter of the chip ('A'...) */
192 int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
193 int auto_neg_cnf; /* auto-negotiation word from EEPROM */
194 int adapter_cnf; /* adapter configuration from EEPROM */
195 int isa_config; /* ISA configuration from EEPROM */
196 int irq_map; /* IRQ map from EEPROM */
197 int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
198 int curr_rx_cfg; /* a copy of PP_RxCFG */
199 int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
200 int send_underrun; /* keep track of how many underruns in a row we get */
201 int force; /* force various values; see FORCE* above. */
204 int use_dma; /* Flag: we're using dma */
205 int dma; /* DMA channel */
206 int dmasize; /* 16 or 64 */
207 unsigned char *dma_buff; /* points to the beginning of the buffer */
208 unsigned char *end_dma_buff; /* points to the end of the buffer */
209 unsigned char *rx_dma_ptr; /* points to the next packet */
213 /* Index to functions, as function prototypes. */
215 static int cs89x0_probe1(struct net_device *dev, int ioaddr, int modular);
216 static int net_open(struct net_device *dev);
217 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
218 static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs *regs);
219 static void set_multicast_list(struct net_device *dev);
220 static void net_timeout(struct net_device *dev);
221 static void net_rx(struct net_device *dev);
222 static int net_close(struct net_device *dev);
223 static struct net_device_stats *net_get_stats(struct net_device *dev);
224 static void reset_chip(struct net_device *dev);
225 static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer);
226 static int get_eeprom_cksum(int off, int len, int *buffer);
227 static int set_mac_address(struct net_device *dev, void *addr);
228 static void count_rx_errors(int status, struct net_local *lp);
230 static void get_dma_channel(struct net_device *dev);
231 static void release_dma_buff(struct net_local *lp);
234 /* Example routines you must write ;->. */
235 #define tx_done(dev) 1
238 * Permit 'cs89x0_dma=N' in the kernel boot environment
240 #if !defined(MODULE) && (ALLOW_DMA != 0)
241 static int g_cs89x0_dma;
243 static int __init dma_fn(char *str)
245 g_cs89x0_dma = simple_strtol(str,NULL,0);
249 __setup("cs89x0_dma=", dma_fn);
250 #endif /* !defined(MODULE) && (ALLOW_DMA != 0) */
253 static int g_cs89x0_media__force;
255 static int __init media_fn(char *str)
257 if (!strcmp(str, "rj45")) g_cs89x0_media__force = FORCE_RJ45;
258 else if (!strcmp(str, "aui")) g_cs89x0_media__force = FORCE_AUI;
259 else if (!strcmp(str, "bnc")) g_cs89x0_media__force = FORCE_BNC;
263 __setup("cs89x0_media=", media_fn);
267 /* Check for a network adaptor of this type, and return '0' iff one exists.
268 If dev->base_addr == 0, probe all likely locations.
269 If dev->base_addr == 1, always return failure.
270 If dev->base_addr == 2, allocate space for the device and return success
271 (detachable devices only).
275 struct net_device * __init cs89x0_probe(int unit)
277 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
284 return ERR_PTR(-ENODEV);
286 sprintf(dev->name, "eth%d", unit);
287 netdev_boot_setup_check(dev);
292 printk("cs89x0:cs89x0_probe(0x%x)\n", io);
294 if (io > 0x1ff) { /* Check a single specified location. */
295 err = cs89x0_probe1(dev, io, 0);
296 } else if (io != 0) { /* Don't probe at all. */
299 for (port = netcard_portlist; *port; port++) {
300 if (cs89x0_probe1(dev, *port, 0) == 0)
309 err = register_netdev(dev);
314 outw(PP_ChipID, dev->base_addr + ADD_PORT);
315 release_region(dev->base_addr, NETCARD_IO_EXTENT);
318 printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
323 readreg(struct net_device *dev, int portno)
325 outw(portno, dev->base_addr + ADD_PORT);
326 return inw(dev->base_addr + DATA_PORT);
330 writereg(struct net_device *dev, int portno, int value)
332 outw(portno, dev->base_addr + ADD_PORT);
333 outw(value, dev->base_addr + DATA_PORT);
337 readword(struct net_device *dev, int portno)
339 return inw(dev->base_addr + portno);
343 writeword(struct net_device *dev, int portno, int value)
345 outw(value, dev->base_addr + portno);
349 wait_eeprom_ready(struct net_device *dev)
351 int timeout = jiffies;
352 /* check to see if the EEPROM is ready, a timeout is used -
353 just in case EEPROM is ready when SI_BUSY in the
354 PP_SelfST is clear */
355 while(readreg(dev, PP_SelfST) & SI_BUSY)
356 if (jiffies - timeout >= 40)
362 get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
366 if (net_debug > 3) printk("EEPROM data from %x for %x:\n",off,len);
367 for (i = 0; i < len; i++) {
368 if (wait_eeprom_ready(dev) < 0) return -1;
369 /* Now send the EEPROM read command and EEPROM location to read */
370 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
371 if (wait_eeprom_ready(dev) < 0) return -1;
372 buffer[i] = readreg(dev, PP_EEData);
373 if (net_debug > 3) printk("%04x ", buffer[i]);
375 if (net_debug > 3) printk("\n");
380 get_eeprom_cksum(int off, int len, int *buffer)
385 for (i = 0; i < len; i++)
393 /* This is the real probe routine. Linux has a history of friendly device
394 probes on the ISA bus. A good device probes avoids doing writes, and
395 verifies that the correct device exists and functions.
400 cs89x0_probe1(struct net_device *dev, int ioaddr, int modular)
402 struct net_local *lp = netdev_priv(dev);
403 static unsigned version_printed;
405 unsigned rev_type = 0;
406 int eeprom_buff[CHKSUM_LEN];
409 SET_MODULE_OWNER(dev);
410 /* Initialize the device structure. */
412 memset(lp, 0, sizeof(*lp));
413 spin_lock_init(&lp->lock);
418 lp->dma = g_cs89x0_dma;
419 lp->dmasize = 16; /* Could make this an option... */
422 lp->force = g_cs89x0_media__force;
426 /* Grab the region so we can find another board if autoIRQ fails. */
427 /* WTF is going on here? */
428 if (!request_region(ioaddr & ~3, NETCARD_IO_EXTENT, dev->name)) {
429 printk(KERN_ERR "%s: request_region(0x%x, 0x%x) failed\n",
430 dev->name, ioaddr, NETCARD_IO_EXTENT);
435 #ifdef CONFIG_SH_HICOSH4
436 /* truely reset the chip */
437 outw(0x0114, ioaddr + ADD_PORT);
438 outw(0x0040, ioaddr + DATA_PORT);
441 /* if they give us an odd I/O address, then do ONE write to
442 the address port, to get it back to address zero, where we
443 expect to find the EISA signature word. An IO with a base of 0x3
444 will skip the test for the ADD_PORT. */
447 printk(KERN_INFO "%s: odd ioaddr 0x%x\n", dev->name, ioaddr);
448 if ((ioaddr & 2) != 2)
449 if ((inw((ioaddr & ~3)+ ADD_PORT) & ADD_MASK) != ADD_SIG) {
450 printk(KERN_ERR "%s: bad signature 0x%x\n",
451 dev->name, inw((ioaddr & ~3)+ ADD_PORT));
456 outw(PP_ChipID, ioaddr + ADD_PORT);
458 printk("PP_addr=0x%x\n", inw(ioaddr + ADD_PORT));
460 if (inw(ioaddr + DATA_PORT) != CHIP_EISA_ID_SIG) {
461 printk(KERN_ERR "%s: incorrect signature 0x%x\n",
462 dev->name, inw(ioaddr + DATA_PORT));
467 /* Fill in the 'dev' fields. */
468 dev->base_addr = ioaddr;
470 /* get the chip type */
471 rev_type = readreg(dev, PRODUCT_ID_ADD);
472 lp->chip_type = rev_type &~ REVISON_BITS;
473 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
475 /* Check the chip type and revision in order to set the correct send command
476 CS8920 revision C and CS8900 revision F can use the faster send. */
477 lp->send_cmd = TX_AFTER_381;
478 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
479 lp->send_cmd = TX_NOW;
480 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
481 lp->send_cmd = TX_NOW;
483 if (net_debug && version_printed++ == 0)
486 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#3lx ",
488 lp->chip_type==CS8900?'0':'2',
489 lp->chip_type==CS8920M?"M":"",
495 /* Here we read the current configuration of the chip. If there
496 is no Extended EEPROM then the idea is to not disturb the chip
497 configuration, it should have been correctly setup by automatic
498 EEPROM read on reset. So, if the chip says it read the EEPROM
499 the driver will always do *something* instead of complain that
502 #ifdef CONFIG_SH_HICOSH4
504 /* For the HiCO.SH4 board, things are different: we don't
505 have EEPROM, but there is some data in flash, so we go
506 get it there directly (MAC). */
509 if (((* (volatile __u32 *) 0xa0013ff0) & 0x00ffffff)
511 confd = (__u16*) 0xa0013fc0;
513 confd = (__u16*) 0xa001ffc0;
515 cnt = (*confd++ & 0x00ff) >> 1;
519 switch (j & 0x0fff) {
521 for (i = 0; i < ETH_ALEN/2; i++) {
522 dev->dev_addr[i*2] = confd[i] & 0xFF;
523 dev->dev_addr[i*2+1] = confd[i] >> 8;
534 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
535 (EEPROM_OK|EEPROM_PRESENT)) {
537 for (i=0; i < ETH_ALEN/2; i++) {
539 Addr = readreg(dev, PP_IA+i*2);
540 dev->dev_addr[i*2] = Addr & 0xFF;
541 dev->dev_addr[i*2+1] = Addr >> 8;
544 /* Load the Adapter Configuration.
545 Note: Barring any more specific information from some
546 other source (ie EEPROM+Schematics), we would not know
547 how to operate a 10Base2 interface on the AUI port.
548 However, since we do read the status of HCB1 and use
549 settings that always result in calls to control_dc_dc(dev,0)
550 a BNC interface should work if the enable pin
551 (dc/dc converter) is on HCB1. It will be called AUI
555 i = readreg(dev, PP_LineCTL);
556 /* Preserve the setting of the HCB1 pin. */
557 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
558 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
559 /* Save the sqelch bit */
560 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
561 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
562 /* Check if the card is in 10Base-t only mode */
563 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
564 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
565 /* Check if the card is in AUI only mode */
566 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
567 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
568 /* Check if the card is in Auto mode. */
569 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
570 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
571 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
574 printk(KERN_INFO "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
575 dev->name, i, lp->adapter_cnf);
577 /* IRQ. Other chips already probe, see below. */
578 if (lp->chip_type == CS8900)
579 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
581 printk( "[Cirrus EEPROM] ");
586 /* First check to see if an EEPROM is attached. */
587 #ifdef CONFIG_SH_HICOSH4 /* no EEPROM on HiCO, don't hazzle with it here */
589 printk(KERN_NOTICE "cs89x0: No EEPROM on HiCO.SH4\n");
592 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
593 printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....\n");
594 else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
595 printk(KERN_WARNING "\ncs89x0: EEPROM read failed, relying on command line.\n");
596 } else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
597 /* Check if the chip was able to read its own configuration starting
599 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
600 (EEPROM_OK|EEPROM_PRESENT))
601 printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
604 /* This reads an extended EEPROM that is not documented
605 in the CS8900 datasheet. */
607 /* get transmission control word but keep the autonegotiation bits */
608 if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];
609 /* Store adapter configuration */
610 if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];
611 /* Store ISA configuration */
612 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2];
613 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;
615 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */
616 /* store the initial memory base address */
617 for (i = 0; i < ETH_ALEN/2; i++) {
618 dev->dev_addr[i*2] = eeprom_buff[i];
619 dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8;
622 printk(KERN_DEBUG "%s: new adapter_cnf: 0x%x\n",
623 dev->name, lp->adapter_cnf);
626 /* allow them to force multiple transceivers. If they force multiple, autosense */
629 if (lp->force & FORCE_RJ45) {lp->adapter_cnf |= A_CNF_10B_T; count++; }
630 if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_AUI; count++; }
631 if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_10B_2; count++; }
632 if (count > 1) {lp->adapter_cnf |= A_CNF_MEDIA_AUTO; }
633 else if (lp->force & FORCE_RJ45){lp->adapter_cnf |= A_CNF_MEDIA_10B_T; }
634 else if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_MEDIA_AUI; }
635 else if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_MEDIA_10B_2; }
639 printk(KERN_DEBUG "%s: after force 0x%x, adapter_cnf=0x%x\n",
640 dev->name, lp->force, lp->adapter_cnf);
642 /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
644 /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
646 /* FIXME: we don't set the Ethernet address on the command line. Use
647 ifconfig IFACE hw ether AABBCCDDEEFF */
649 printk(KERN_INFO "cs89x0 media %s%s%s",
650 (lp->adapter_cnf & A_CNF_10B_T)?"RJ-45,":"",
651 (lp->adapter_cnf & A_CNF_AUI)?"AUI,":"",
652 (lp->adapter_cnf & A_CNF_10B_2)?"BNC,":"");
654 lp->irq_map = 0xffff;
656 /* If this is a CS8900 then no pnp soft */
657 if (lp->chip_type != CS8900 &&
658 /* Check if the ISA IRQ has been set */
659 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
660 (i != 0 && i < CS8920_NO_INTS))) {
664 i = lp->isa_config & INT_NO_MASK;
665 if (lp->chip_type == CS8900) {
666 /* Translate the IRQ using the IRQ mapping table. */
667 if (i >= sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]))
668 printk("\ncs89x0: invalid ISA interrupt number %d\n", i);
670 i = cs8900_irq_map[i];
672 lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
674 int irq_map_buff[IRQ_MAP_LEN/2];
676 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
678 irq_map_buff) >= 0) {
679 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
680 lp->irq_map = (irq_map_buff[0]>>8) | (irq_map_buff[1] << 8);
687 printk(" IRQ %d", dev->irq);
691 get_dma_channel(dev);
692 printk(", DMA %d", dev->dma);
697 printk(", programmed I/O");
700 /* print the ethernet address. */
702 for (i = 0; i < ETH_ALEN; i++)
704 printk("%c%02x", i ? ':' : ' ', dev->dev_addr[i]);
707 dev->open = net_open;
708 dev->stop = net_close;
709 dev->tx_timeout = net_timeout;
710 dev->watchdog_timeo = HZ;
711 dev->hard_start_xmit = net_send_packet;
712 dev->get_stats = net_get_stats;
713 dev->set_multicast_list = set_multicast_list;
714 dev->set_mac_address = set_mac_address;
718 printk("cs89x0_probe1() successful\n");
721 release_region(ioaddr & ~3, NETCARD_IO_EXTENT);
727 /*********************************
728 * This page contains DMA routines
729 **********************************/
733 #define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
736 get_dma_channel(struct net_device *dev)
738 struct net_local *lp = netdev_priv(dev);
742 lp->isa_config |= ISA_RxDMA;
744 if ((lp->isa_config & ANY_ISA_DMA) == 0)
746 dev->dma = lp->isa_config & DMA_NO_MASK;
747 if (lp->chip_type == CS8900)
749 if (dev->dma < 5 || dev->dma > 7) {
750 lp->isa_config &= ~ANY_ISA_DMA;
758 write_dma(struct net_device *dev, int chip_type, int dma)
760 struct net_local *lp = netdev_priv(dev);
761 if ((lp->isa_config & ANY_ISA_DMA) == 0)
763 if (chip_type == CS8900) {
764 writereg(dev, PP_CS8900_ISADMA, dma-5);
766 writereg(dev, PP_CS8920_ISADMA, dma);
771 set_dma_cfg(struct net_device *dev)
773 struct net_local *lp = netdev_priv(dev);
776 if ((lp->isa_config & ANY_ISA_DMA) == 0) {
778 printk("set_dma_cfg(): no DMA\n");
781 if (lp->isa_config & ISA_RxDMA) {
782 lp->curr_rx_cfg |= RX_DMA_ONLY;
784 printk("set_dma_cfg(): RX_DMA_ONLY\n");
786 lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
788 printk("set_dma_cfg(): AUTO_RX_DMA\n");
794 dma_bufcfg(struct net_device *dev)
796 struct net_local *lp = netdev_priv(dev);
798 return (lp->isa_config & ANY_ISA_DMA)? RX_DMA_ENBL : 0;
804 dma_busctl(struct net_device *dev)
807 struct net_local *lp = netdev_priv(dev);
809 if (lp->isa_config & ANY_ISA_DMA)
810 retval |= RESET_RX_DMA; /* Reset the DMA pointer */
811 if (lp->isa_config & DMA_BURST)
812 retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
813 if (lp->dmasize == 64)
814 retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
815 retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
821 dma_rx(struct net_device *dev)
823 struct net_local *lp = netdev_priv(dev);
826 unsigned char *bp = lp->rx_dma_ptr;
828 status = bp[0] + (bp[1]<<8);
829 length = bp[2] + (bp[3]<<8);
832 printk( "%s: receiving DMA packet at %lx, status %x, length %x\n",
833 dev->name, (unsigned long)bp, status, length);
835 if ((status & RX_OK) == 0) {
836 count_rx_errors(status, lp);
837 goto skip_this_frame;
840 /* Malloc up new buffer. */
841 skb = dev_alloc_skb(length + 2);
843 if (net_debug) /* I don't think we want to do this to a stressed system */
844 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
845 lp->stats.rx_dropped++;
847 /* AKPM: advance bp to the next frame */
849 bp += (length + 3) & ~3;
850 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
854 skb_reserve(skb, 2); /* longword align L3 header */
857 if (bp + length > lp->end_dma_buff) {
858 int semi_cnt = lp->end_dma_buff - bp;
859 memcpy(skb_put(skb,semi_cnt), bp, semi_cnt);
860 memcpy(skb_put(skb,length - semi_cnt), lp->dma_buff,
863 memcpy(skb_put(skb,length), bp, length);
865 bp += (length + 3) & ~3;
866 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
870 printk( "%s: received %d byte DMA packet of type %x\n",
872 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
874 skb->protocol=eth_type_trans(skb,dev);
876 dev->last_rx = jiffies;
877 lp->stats.rx_packets++;
878 lp->stats.rx_bytes += length;
881 #endif /* ALLOW_DMA */
883 void __init reset_chip(struct net_device *dev)
885 struct net_local *lp = netdev_priv(dev);
886 int ioaddr = dev->base_addr;
887 int reset_start_time;
889 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
892 current->state = TASK_INTERRUPTIBLE;
893 schedule_timeout(30*HZ/1000);
895 if (lp->chip_type != CS8900) {
896 /* Hardware problem requires PNP registers to be reconfigured after a reset */
897 outw(PP_CS8920_ISAINT, ioaddr + ADD_PORT);
898 outb(dev->irq, ioaddr + DATA_PORT);
899 outb(0, ioaddr + DATA_PORT + 1);
901 outw(PP_CS8920_ISAMemB, ioaddr + ADD_PORT);
902 outb((dev->mem_start >> 16) & 0xff, ioaddr + DATA_PORT);
903 outb((dev->mem_start >> 8) & 0xff, ioaddr + DATA_PORT + 1);
905 /* Wait until the chip is reset */
906 reset_start_time = jiffies;
907 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
913 control_dc_dc(struct net_device *dev, int on_not_off)
915 struct net_local *lp = netdev_priv(dev);
916 unsigned int selfcontrol;
917 int timenow = jiffies;
918 /* control the DC to DC convertor in the SelfControl register.
919 Note: This is hooked up to a general purpose pin, might not
920 always be a DC to DC convertor. */
922 selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
923 if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
926 selfcontrol &= ~HCB1;
927 writereg(dev, PP_SelfCTL, selfcontrol);
929 /* Wait for the DC/DC converter to power up - 500ms */
930 while (jiffies - timenow < HZ)
934 #define DETECTED_NONE 0
935 #define DETECTED_RJ45H 1
936 #define DETECTED_RJ45F 2
937 #define DETECTED_AUI 3
938 #define DETECTED_BNC 4
941 detect_tp(struct net_device *dev)
943 struct net_local *lp = netdev_priv(dev);
944 int timenow = jiffies;
947 if (net_debug > 1) printk("%s: Attempting TP\n", dev->name);
949 /* If connected to another full duplex capable 10-Base-T card the link pulses
950 seem to be lost when the auto detect bit in the LineCTL is set.
951 To overcome this the auto detect bit will be cleared whilst testing the
952 10-Base-T interface. This would not be necessary for the sparrow chip but
953 is simpler to do it anyway. */
954 writereg(dev, PP_LineCTL, lp->linectl &~ AUI_ONLY);
955 control_dc_dc(dev, 0);
957 /* Delay for the hardware to work out if the TP cable is present - 150ms */
958 for (timenow = jiffies; jiffies - timenow < 15; )
960 if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
961 return DETECTED_NONE;
963 if (lp->chip_type == CS8900) {
964 switch (lp->force & 0xf0) {
967 printk("%s: cs8900 doesn't autonegotiate\n",dev->name);
968 return DETECTED_NONE;
970 /* CS8900 doesn't support AUTO, change to HALF*/
972 lp->force &= ~FORCE_AUTO;
973 lp->force |= FORCE_HALF;
978 writereg(dev, PP_TestCTL, readreg(dev, PP_TestCTL) | FDX_8900);
981 fdx = readreg(dev, PP_TestCTL) & FDX_8900;
983 switch (lp->force & 0xf0) {
985 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
988 lp->auto_neg_cnf = 0;
991 lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
995 writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
997 if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
998 printk(KERN_INFO "%s: negotiating duplex...\n",dev->name);
999 while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
1000 if (jiffies - timenow > 4000) {
1001 printk(KERN_ERR "**** Full / half duplex auto-negotiation timed out ****\n");
1006 fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
1009 return DETECTED_RJ45F;
1011 return DETECTED_RJ45H;
1014 /* send a test packet - return true if carrier bits are ok */
1016 send_test_pkt(struct net_device *dev)
1018 char test_packet[] = { 0,0,0,0,0,0, 0,0,0,0,0,0,
1019 0, 46, /* A 46 in network order */
1020 0, 0, /* DSAP=0 & SSAP=0 fields */
1021 0xf3, 0 /* Control (Test Req + P bit set) */ };
1022 long timenow = jiffies;
1024 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
1026 memcpy(test_packet, dev->dev_addr, ETH_ALEN);
1027 memcpy(test_packet+ETH_ALEN, dev->dev_addr, ETH_ALEN);
1029 writeword(dev, TX_CMD_PORT, TX_AFTER_ALL);
1030 writeword(dev, TX_LEN_PORT, ETH_ZLEN);
1032 /* Test to see if the chip has allocated memory for the packet */
1033 while (jiffies - timenow < 5)
1034 if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
1036 if (jiffies - timenow >= 5)
1037 return 0; /* this shouldn't happen */
1039 /* Write the contents of the packet */
1040 outsw(dev->base_addr + TX_FRAME_PORT,test_packet,(ETH_ZLEN+1) >>1);
1042 if (net_debug > 1) printk("Sending test packet ");
1043 /* wait a couple of jiffies for packet to be received */
1044 for (timenow = jiffies; jiffies - timenow < 3; )
1046 if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
1047 if (net_debug > 1) printk("succeeded\n");
1050 if (net_debug > 1) printk("failed\n");
1056 detect_aui(struct net_device *dev)
1058 struct net_local *lp = netdev_priv(dev);
1060 if (net_debug > 1) printk("%s: Attempting AUI\n", dev->name);
1061 control_dc_dc(dev, 0);
1063 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1065 if (send_test_pkt(dev))
1066 return DETECTED_AUI;
1068 return DETECTED_NONE;
1072 detect_bnc(struct net_device *dev)
1074 struct net_local *lp = netdev_priv(dev);
1076 if (net_debug > 1) printk("%s: Attempting BNC\n", dev->name);
1077 control_dc_dc(dev, 1);
1079 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1081 if (send_test_pkt(dev))
1082 return DETECTED_BNC;
1084 return DETECTED_NONE;
1089 write_irq(struct net_device *dev, int chip_type, int irq)
1093 if (chip_type == CS8900) {
1094 /* Search the mapping table for the corresponding IRQ pin. */
1095 for (i = 0; i != sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]); i++)
1096 if (cs8900_irq_map[i] == irq)
1099 if (i == sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]))
1101 writereg(dev, PP_CS8900_ISAINT, i);
1103 writereg(dev, PP_CS8920_ISAINT, irq);
1107 /* Open/initialize the board. This is called (in the current kernel)
1108 sometime after booting when the 'ifconfig' program is run.
1110 This routine should set everything up anew at each open, even
1111 registers that "should" only need to be set once at boot, so that
1112 there is non-reboot way to recover if something goes wrong.
1115 /* AKPM: do we need to do any locking here? */
1118 net_open(struct net_device *dev)
1120 struct net_local *lp = netdev_priv(dev);
1125 #ifndef CONFIG_SH_HICOSH4 /* uses irq#1, so this won't work */
1127 /* Allow interrupts to be generated by the chip */
1128 /* Cirrus' release had this: */
1130 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1132 /* And 2.3.47 had this: */
1133 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1135 for (i = 2; i < CS8920_NO_INTS; i++) {
1136 if ((1 << i) & lp->irq_map) {
1137 if (request_irq(i, net_interrupt, 0, dev->name, dev) == 0) {
1139 write_irq(dev, lp->chip_type, i);
1140 /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
1146 if (i >= CS8920_NO_INTS) {
1147 writereg(dev, PP_BusCTL, 0); /* disable interrupts. */
1148 printk(KERN_ERR "cs89x0: can't get an interrupt\n");
1156 if (((1 << dev->irq) & lp->irq_map) == 0) {
1157 printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
1158 dev->name, dev->irq, lp->irq_map);
1162 /* FIXME: Cirrus' release had this: */
1163 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1164 /* And 2.3.47 had this: */
1166 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1168 write_irq(dev, lp->chip_type, dev->irq);
1169 ret = request_irq(dev->irq, &net_interrupt, 0, dev->name, dev);
1172 printk(KERN_DEBUG "cs89x0: request_irq(%d) failed\n", dev->irq);
1179 if (lp->isa_config & ANY_ISA_DMA) {
1180 unsigned long flags;
1181 lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
1182 get_order(lp->dmasize * 1024));
1184 if (!lp->dma_buff) {
1185 printk(KERN_ERR "%s: cannot get %dK memory for DMA\n", dev->name, lp->dmasize);
1188 if (net_debug > 1) {
1189 printk( "%s: dma %lx %lx\n",
1191 (unsigned long)lp->dma_buff,
1192 (unsigned long)isa_virt_to_bus(lp->dma_buff));
1194 if ((unsigned long) lp->dma_buff >= MAX_DMA_ADDRESS ||
1195 !dma_page_eq(lp->dma_buff, lp->dma_buff+lp->dmasize*1024-1)) {
1196 printk(KERN_ERR "%s: not usable as DMA buffer\n", dev->name);
1199 memset(lp->dma_buff, 0, lp->dmasize * 1024); /* Why? */
1200 if (request_dma(dev->dma, dev->name)) {
1201 printk(KERN_ERR "%s: cannot get dma channel %d\n", dev->name, dev->dma);
1204 write_dma(dev, lp->chip_type, dev->dma);
1205 lp->rx_dma_ptr = lp->dma_buff;
1206 lp->end_dma_buff = lp->dma_buff + lp->dmasize*1024;
1207 spin_lock_irqsave(&lp->lock, flags);
1208 disable_dma(dev->dma);
1209 clear_dma_ff(dev->dma);
1210 set_dma_mode(dev->dma, 0x14); /* auto_init as well */
1211 set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
1212 set_dma_count(dev->dma, lp->dmasize*1024);
1213 enable_dma(dev->dma);
1214 spin_unlock_irqrestore(&lp->lock, flags);
1217 #endif /* ALLOW_DMA */
1219 /* set the Ethernet address */
1220 for (i=0; i < ETH_ALEN/2; i++)
1221 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1223 /* while we're testing the interface, leave interrupts disabled */
1224 writereg(dev, PP_BusCTL, MEMORY_ON);
1226 /* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
1227 if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) && (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
1228 lp->linectl = LOW_RX_SQUELCH;
1232 /* check to make sure that they have the "right" hardware available */
1233 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1234 case A_CNF_MEDIA_10B_T: result = lp->adapter_cnf & A_CNF_10B_T; break;
1235 case A_CNF_MEDIA_AUI: result = lp->adapter_cnf & A_CNF_AUI; break;
1236 case A_CNF_MEDIA_10B_2: result = lp->adapter_cnf & A_CNF_10B_2; break;
1237 default: result = lp->adapter_cnf & (A_CNF_10B_T | A_CNF_AUI | A_CNF_10B_2);
1240 printk(KERN_ERR "%s: EEPROM is configured for unavailable media\n", dev->name);
1243 release_dma_buff(lp);
1245 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
1246 free_irq(dev->irq, dev);
1251 /* set the hardware to the configured choice */
1252 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1253 case A_CNF_MEDIA_10B_T:
1254 result = detect_tp(dev);
1255 if (result==DETECTED_NONE) {
1256 printk(KERN_WARNING "%s: 10Base-T (RJ-45) has no cable\n", dev->name);
1257 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1258 result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
1261 case A_CNF_MEDIA_AUI:
1262 result = detect_aui(dev);
1263 if (result==DETECTED_NONE) {
1264 printk(KERN_WARNING "%s: 10Base-5 (AUI) has no cable\n", dev->name);
1265 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1266 result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
1269 case A_CNF_MEDIA_10B_2:
1270 result = detect_bnc(dev);
1271 if (result==DETECTED_NONE) {
1272 printk(KERN_WARNING "%s: 10Base-2 (BNC) has no cable\n", dev->name);
1273 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1274 result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
1277 case A_CNF_MEDIA_AUTO:
1278 writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
1279 if (lp->adapter_cnf & A_CNF_10B_T)
1280 if ((result = detect_tp(dev)) != DETECTED_NONE)
1282 if (lp->adapter_cnf & A_CNF_AUI)
1283 if ((result = detect_aui(dev)) != DETECTED_NONE)
1285 if (lp->adapter_cnf & A_CNF_10B_2)
1286 if ((result = detect_bnc(dev)) != DETECTED_NONE)
1288 printk(KERN_ERR "%s: no media detected\n", dev->name);
1293 printk(KERN_ERR "%s: no network cable attached to configured media\n", dev->name);
1295 case DETECTED_RJ45H:
1296 printk(KERN_INFO "%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
1298 case DETECTED_RJ45F:
1299 printk(KERN_INFO "%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
1302 printk(KERN_INFO "%s: using 10Base-5 (AUI)\n", dev->name);
1305 printk(KERN_INFO "%s: using 10Base-2 (BNC)\n", dev->name);
1309 /* Turn on both receive and transmit operations */
1310 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1312 /* Receive only error free packets addressed to this card */
1314 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
1316 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
1318 if (lp->isa_config & STREAM_TRANSFER)
1319 lp->curr_rx_cfg |= RX_STREAM_ENBL;
1323 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
1325 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
1326 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
1328 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
1332 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
1334 /* now that we've got our act together, enable everything */
1335 writereg(dev, PP_BusCTL, ENABLE_IRQ
1336 | (dev->mem_start?MEMORY_ON : 0) /* turn memory on */
1341 netif_start_queue(dev);
1343 printk("cs89x0: net_open() succeeded\n");
1349 static void net_timeout(struct net_device *dev)
1351 /* If we get here, some higher level has decided we are broken.
1352 There should really be a "kick me" function call instead. */
1353 if (net_debug > 0) printk("%s: transmit timed out, %s?\n", dev->name,
1354 tx_done(dev) ? "IRQ conflict ?" : "network cable problem");
1355 /* Try to restart the adaptor. */
1356 netif_wake_queue(dev);
1359 static int net_send_packet(struct sk_buff *skb, struct net_device *dev)
1361 struct net_local *lp = netdev_priv(dev);
1363 if (net_debug > 3) {
1364 printk("%s: sent %d byte packet of type %x\n",
1365 dev->name, skb->len,
1366 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1369 /* keep the upload from being interrupted, since we
1370 ask the chip to start transmitting before the
1371 whole packet has been completely uploaded. */
1373 spin_lock_irq(&lp->lock);
1374 netif_stop_queue(dev);
1376 /* initiate a transmit sequence */
1377 writeword(dev, TX_CMD_PORT, lp->send_cmd);
1378 writeword(dev, TX_LEN_PORT, skb->len);
1380 /* Test to see if the chip has allocated memory for the packet */
1381 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1383 * Gasp! It hasn't. But that shouldn't happen since
1384 * we're waiting for TxOk, so return 1 and requeue this packet.
1387 spin_unlock_irq(&lp->lock);
1388 if (net_debug) printk("cs89x0: Tx buffer not free!\n");
1391 /* Write the contents of the packet */
1392 outsw(dev->base_addr + TX_FRAME_PORT,skb->data,(skb->len+1) >>1);
1393 spin_unlock_irq(&lp->lock);
1394 dev->trans_start = jiffies;
1395 dev_kfree_skb (skb);
1398 * We DO NOT call netif_wake_queue() here.
1399 * We also DO NOT call netif_start_queue().
1401 * Either of these would cause another bottom half run through
1402 * net_send_packet() before this packet has fully gone out. That causes
1403 * us to hit the "Gasp!" above and the send is rescheduled. it runs like
1404 * a dog. We just return and wait for the Tx completion interrupt handler
1405 * to restart the netdevice layer
1411 /* The typical workload of the driver:
1412 Handle the network interface interrupts. */
1414 static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1416 struct net_device *dev = dev_id;
1417 struct net_local *lp;
1421 ioaddr = dev->base_addr;
1422 lp = netdev_priv(dev);
1424 /* we MUST read all the events out of the ISQ, otherwise we'll never
1425 get interrupted again. As a consequence, we can't have any limit
1426 on the number of times we loop in the interrupt handler. The
1427 hardware guarantees that eventually we'll run out of events. Of
1428 course, if you're on a slow machine, and packets are arriving
1429 faster than you can read them off, you're screwed. Hasta la
1431 while ((status = readword(dev, ISQ_PORT))) {
1432 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
1434 switch(status & ISQ_EVENT_MASK) {
1435 case ISQ_RECEIVER_EVENT:
1436 /* Got a packet(s). */
1439 case ISQ_TRANSMITTER_EVENT:
1440 lp->stats.tx_packets++;
1441 netif_wake_queue(dev); /* Inform upper layers. */
1442 if ((status & ( TX_OK |
1446 TX_16_COL)) != TX_OK) {
1447 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
1448 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
1449 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
1450 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
1451 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
1454 case ISQ_BUFFER_EVENT:
1455 if (status & READY_FOR_TX) {
1456 /* we tried to transmit a packet earlier,
1457 but inexplicably ran out of buffers.
1458 That shouldn't happen since we only ever
1459 load one packet. Shrug. Do the right
1461 netif_wake_queue(dev); /* Inform upper layers. */
1463 if (status & TX_UNDERRUN) {
1464 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
1465 lp->send_underrun++;
1466 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
1467 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
1468 /* transmit cycle is done, although
1469 frame wasn't transmitted - this
1470 avoids having to wait for the upper
1471 layers to timeout on us, in the
1472 event of a tx underrun */
1473 netif_wake_queue(dev); /* Inform upper layers. */
1476 if (lp->use_dma && (status & RX_DMA)) {
1477 int count = readreg(dev, PP_DmaFrameCnt);
1480 printk("%s: receiving %d DMA frames\n", dev->name, count);
1481 if (net_debug > 2 && count >1)
1482 printk("%s: receiving %d DMA frames\n", dev->name, count);
1485 count = readreg(dev, PP_DmaFrameCnt);
1486 if (net_debug > 2 && count > 0)
1487 printk("%s: continuing with %d DMA frames\n", dev->name, count);
1492 case ISQ_RX_MISS_EVENT:
1493 lp->stats.rx_missed_errors += (status >>6);
1495 case ISQ_TX_COL_EVENT:
1496 lp->stats.collisions += (status >>6);
1500 return IRQ_RETVAL(handled);
1504 count_rx_errors(int status, struct net_local *lp)
1506 lp->stats.rx_errors++;
1507 if (status & RX_RUNT) lp->stats.rx_length_errors++;
1508 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
1509 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
1511 lp->stats.rx_crc_errors++;
1512 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
1516 /* We have a good packet(s), get it/them out of the buffers. */
1518 net_rx(struct net_device *dev)
1520 struct net_local *lp = netdev_priv(dev);
1521 struct sk_buff *skb;
1524 int ioaddr = dev->base_addr;
1525 status = inw(ioaddr + RX_FRAME_PORT);
1526 length = inw(ioaddr + RX_FRAME_PORT);
1528 if ((status & RX_OK) == 0) {
1529 count_rx_errors(status, lp);
1533 /* Malloc up new buffer. */
1534 skb = dev_alloc_skb(length + 2);
1536 #if 0 /* Again, this seems a cruel thing to do */
1537 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1539 lp->stats.rx_dropped++;
1542 skb_reserve(skb, 2); /* longword align L3 header */
1545 insw(ioaddr + RX_FRAME_PORT, skb_put(skb, length), length >> 1);
1547 skb->data[length-1] = inw(ioaddr + RX_FRAME_PORT);
1549 if (net_debug > 3) {
1550 printk( "%s: received %d byte packet of type %x\n",
1552 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1555 skb->protocol=eth_type_trans(skb,dev);
1557 dev->last_rx = jiffies;
1558 lp->stats.rx_packets++;
1559 lp->stats.rx_bytes += length;
1563 static void release_dma_buff(struct net_local *lp)
1566 free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024));
1572 /* The inverse routine to net_open(). */
1574 net_close(struct net_device *dev)
1576 struct net_local *lp = netdev_priv(dev);
1578 netif_stop_queue(dev);
1580 writereg(dev, PP_RxCFG, 0);
1581 writereg(dev, PP_TxCFG, 0);
1582 writereg(dev, PP_BufCFG, 0);
1583 writereg(dev, PP_BusCTL, 0);
1585 free_irq(dev->irq, dev);
1588 if (lp->use_dma && lp->dma) {
1590 release_dma_buff(lp);
1594 /* Update the statistics here. */
1598 /* Get the current statistics. This may be called with the card open or
1600 static struct net_device_stats *
1601 net_get_stats(struct net_device *dev)
1603 struct net_local *lp = netdev_priv(dev);
1604 unsigned long flags;
1606 spin_lock_irqsave(&lp->lock, flags);
1607 /* Update the statistics from the device registers. */
1608 lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1609 lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1610 spin_unlock_irqrestore(&lp->lock, flags);
1615 static void set_multicast_list(struct net_device *dev)
1617 struct net_local *lp = netdev_priv(dev);
1618 unsigned long flags;
1620 spin_lock_irqsave(&lp->lock, flags);
1621 if(dev->flags&IFF_PROMISC)
1623 lp->rx_mode = RX_ALL_ACCEPT;
1625 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
1627 /* The multicast-accept list is initialized to accept-all, and we
1628 rely on higher-level filtering for now. */
1629 lp->rx_mode = RX_MULTCAST_ACCEPT;
1634 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1636 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
1637 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
1638 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
1639 spin_unlock_irqrestore(&lp->lock, flags);
1643 static int set_mac_address(struct net_device *dev, void *p)
1646 struct sockaddr *addr = p;
1649 if (netif_running(dev))
1652 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1655 printk("%s: Setting MAC address to ", dev->name);
1656 for (i = 0; i < dev->addr_len; i++)
1657 printk(" %2.2x", dev->dev_addr[i]);
1660 /* set the Ethernet address */
1661 for (i=0; i < ETH_ALEN/2; i++)
1662 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1669 static struct net_device *dev_cs89x0;
1672 * Support the 'debug' module parm even if we're compiled for non-debug to
1673 * avoid breaking someone's startup scripts
1679 static char media[8];
1680 static int duplex=-1;
1682 static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
1684 static int dmasize=16; /* or 64 */
1686 MODULE_PARM(io, "i");
1687 MODULE_PARM(irq, "i");
1688 MODULE_PARM(debug, "i");
1689 MODULE_PARM(media, "c8");
1690 MODULE_PARM(duplex, "i");
1691 MODULE_PARM(dma , "i");
1692 MODULE_PARM(dmasize , "i");
1693 MODULE_PARM(use_dma , "i");
1694 MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1695 MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1697 MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1699 MODULE_PARM_DESC(debug, "(ignored)");
1701 MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1702 /* No other value than -1 for duplex seems to be currently interpreted */
1703 MODULE_PARM_DESC(duplex, "(ignored)");
1705 MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1706 MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1707 MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1709 MODULE_PARM_DESC(dma , "(ignored)");
1710 MODULE_PARM_DESC(dmasize , "(ignored)");
1711 MODULE_PARM_DESC(use_dma , "(ignored)");
1714 MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton <andrewm@uow.edu.au>");
1715 MODULE_LICENSE("GPL");
1719 * media=t - specify media type
1723 * duplex=0 - specify forced half/full/autonegotiate duplex
1724 * debug=# - debug level
1727 * Default Chip Configuration:
1728 * DMA Burst = enabled
1729 * IOCHRDY Enabled = enabled
1731 * CS8900 defaults to half-duplex if not specified on command-line
1732 * CS8920 defaults to autoneg if not specified on command-line
1733 * Use reset defaults for other config parameters
1736 * media type specified is supported (circuitry is present)
1737 * if memory address is > 1MB, then required mem decode hw is present
1738 * if 10B-2, then agent other than driver will enable DC/DC converter
1739 (hw or software util)
1747 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1748 struct net_local *lp;
1760 dev->base_addr = io;
1761 lp = netdev_priv(dev);
1765 lp->use_dma = use_dma;
1767 lp->dmasize = dmasize;
1771 spin_lock_init(&lp->lock);
1773 /* boy, they'd better get these right */
1774 if (!strcmp(media, "rj45"))
1775 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1776 else if (!strcmp(media, "aui"))
1777 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1778 else if (!strcmp(media, "bnc"))
1779 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1781 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1784 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1787 printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n");
1788 printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n");
1791 } else if (io <= 0x1ff) {
1797 if (use_dma && dmasize != 16 && dmasize != 64) {
1798 printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize);
1803 ret = cs89x0_probe1(dev, io, 1);
1807 if (register_netdev(dev) != 0) {
1808 printk(KERN_ERR "cs89x0.c: No card found at 0x%x\n", io);
1810 outw(PP_ChipID, dev->base_addr + ADD_PORT);
1811 release_region(dev->base_addr, NETCARD_IO_EXTENT);
1822 cleanup_module(void)
1824 unregister_netdev(dev_cs89x0);
1825 outw(PP_ChipID, dev_cs89x0->base_addr + ADD_PORT);
1826 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1827 free_netdev(dev_cs89x0);
1833 * version-control: t
1834 * kept-new-versions: 5