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 #define DRV_NAME "cs89x0"
146 /* First, a few definitions that the brave might change.
147 A zero-terminated list of I/O addresses to be probed. Some special flags..
148 Addr & 1 = Read back the address port, look for signature and reset
149 the page window before probing
150 Addr & 3 = Reset the page window and probe
151 The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,
152 but it is possible that a Cirrus board could be plugged into the ISA
154 /* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
155 them to system IRQ numbers. This mapping is card specific and is set to
156 the configuration of the Cirrus Eval board for this chip. */
157 #ifdef CONFIG_ARCH_CLPS7500
158 static unsigned int netcard_portlist[] __initdata =
159 { 0x80090303, 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
160 static unsigned int cs8900_irq_map[] = {12,0,0,0};
161 #elif defined(CONFIG_SH_HICOSH4)
162 static unsigned int netcard_portlist[] __initdata =
164 static unsigned int cs8900_irq_map[] = {1,0,0,0};
166 static unsigned int netcard_portlist[] __initdata =
167 { 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
168 static unsigned int cs8900_irq_map[] = {10,11,12,5};
172 static unsigned int net_debug = DEBUGGING;
174 #define net_debug 0 /* gcc will remove all the debug code for us */
177 /* The number of low I/O ports used by the ethercard. */
178 #define NETCARD_IO_EXTENT 16
180 /* we allow the user to override various values normally set in the EEPROM */
181 #define FORCE_RJ45 0x0001 /* pick one of these three */
182 #define FORCE_AUI 0x0002
183 #define FORCE_BNC 0x0004
185 #define FORCE_AUTO 0x0010 /* pick one of these three */
186 #define FORCE_HALF 0x0020
187 #define FORCE_FULL 0x0030
189 /* Information that need to be kept for each board. */
191 struct net_device_stats stats;
192 int chip_type; /* one of: CS8900, CS8920, CS8920M */
193 char chip_revision; /* revision letter of the chip ('A'...) */
194 int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
195 int auto_neg_cnf; /* auto-negotiation word from EEPROM */
196 int adapter_cnf; /* adapter configuration from EEPROM */
197 int isa_config; /* ISA configuration from EEPROM */
198 int irq_map; /* IRQ map from EEPROM */
199 int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
200 int curr_rx_cfg; /* a copy of PP_RxCFG */
201 int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
202 int send_underrun; /* keep track of how many underruns in a row we get */
203 int force; /* force various values; see FORCE* above. */
206 int use_dma; /* Flag: we're using dma */
207 int dma; /* DMA channel */
208 int dmasize; /* 16 or 64 */
209 unsigned char *dma_buff; /* points to the beginning of the buffer */
210 unsigned char *end_dma_buff; /* points to the end of the buffer */
211 unsigned char *rx_dma_ptr; /* points to the next packet */
215 /* Index to functions, as function prototypes. */
217 static int cs89x0_probe1(struct net_device *dev, int ioaddr, int modular);
218 static int net_open(struct net_device *dev);
219 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
220 static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs *regs);
221 static void set_multicast_list(struct net_device *dev);
222 static void net_timeout(struct net_device *dev);
223 static void net_rx(struct net_device *dev);
224 static int net_close(struct net_device *dev);
225 static struct net_device_stats *net_get_stats(struct net_device *dev);
226 static void reset_chip(struct net_device *dev);
227 static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer);
228 static int get_eeprom_cksum(int off, int len, int *buffer);
229 static int set_mac_address(struct net_device *dev, void *addr);
230 static void count_rx_errors(int status, struct net_local *lp);
232 static void get_dma_channel(struct net_device *dev);
233 static void release_dma_buff(struct net_local *lp);
236 /* Example routines you must write ;->. */
237 #define tx_done(dev) 1
240 * Permit 'cs89x0_dma=N' in the kernel boot environment
242 #if !defined(MODULE) && (ALLOW_DMA != 0)
243 static int g_cs89x0_dma;
245 static int __init dma_fn(char *str)
247 g_cs89x0_dma = simple_strtol(str,NULL,0);
251 __setup("cs89x0_dma=", dma_fn);
252 #endif /* !defined(MODULE) && (ALLOW_DMA != 0) */
255 static int g_cs89x0_media__force;
257 static int __init media_fn(char *str)
259 if (!strcmp(str, "rj45")) g_cs89x0_media__force = FORCE_RJ45;
260 else if (!strcmp(str, "aui")) g_cs89x0_media__force = FORCE_AUI;
261 else if (!strcmp(str, "bnc")) g_cs89x0_media__force = FORCE_BNC;
265 __setup("cs89x0_media=", media_fn);
268 /* Check for a network adaptor of this type, and return '0' iff one exists.
269 If dev->base_addr == 0, probe all likely locations.
270 If dev->base_addr == 1, always return failure.
271 If dev->base_addr == 2, allocate space for the device and return success
272 (detachable devices only).
276 struct net_device * __init cs89x0_probe(int unit)
278 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
285 return ERR_PTR(-ENODEV);
287 sprintf(dev->name, "eth%d", unit);
288 netdev_boot_setup_check(dev);
293 printk("cs89x0:cs89x0_probe(0x%x)\n", io);
295 if (io > 0x1ff) { /* Check a single specified location. */
296 err = cs89x0_probe1(dev, io, 0);
297 } else if (io != 0) { /* Don't probe at all. */
300 for (port = netcard_portlist; *port; port++) {
301 if (cs89x0_probe1(dev, *port, 0) == 0)
310 err = register_netdev(dev);
315 outw(PP_ChipID, dev->base_addr + ADD_PORT);
316 release_region(dev->base_addr, NETCARD_IO_EXTENT);
319 printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
325 readreg(struct net_device *dev, int portno)
327 outw(portno, dev->base_addr + ADD_PORT);
328 return inw(dev->base_addr + DATA_PORT);
332 writereg(struct net_device *dev, int portno, int value)
334 outw(portno, dev->base_addr + ADD_PORT);
335 outw(value, dev->base_addr + DATA_PORT);
339 readword(struct net_device *dev, int portno)
341 return inw(dev->base_addr + portno);
345 writeword(struct net_device *dev, int portno, int value)
347 outw(value, dev->base_addr + portno);
351 wait_eeprom_ready(struct net_device *dev)
353 int timeout = jiffies;
354 /* check to see if the EEPROM is ready, a timeout is used -
355 just in case EEPROM is ready when SI_BUSY in the
356 PP_SelfST is clear */
357 while(readreg(dev, PP_SelfST) & SI_BUSY)
358 if (jiffies - timeout >= 40)
364 get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
368 if (net_debug > 3) printk("EEPROM data from %x for %x:\n",off,len);
369 for (i = 0; i < len; i++) {
370 if (wait_eeprom_ready(dev) < 0) return -1;
371 /* Now send the EEPROM read command and EEPROM location to read */
372 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
373 if (wait_eeprom_ready(dev) < 0) return -1;
374 buffer[i] = readreg(dev, PP_EEData);
375 if (net_debug > 3) printk("%04x ", buffer[i]);
377 if (net_debug > 3) printk("\n");
382 get_eeprom_cksum(int off, int len, int *buffer)
387 for (i = 0; i < len; i++)
395 /* This is the real probe routine. Linux has a history of friendly device
396 probes on the ISA bus. A good device probes avoids doing writes, and
397 verifies that the correct device exists and functions.
402 cs89x0_probe1(struct net_device *dev, int ioaddr, int modular)
404 struct net_local *lp = netdev_priv(dev);
405 static unsigned version_printed;
407 unsigned rev_type = 0;
408 int eeprom_buff[CHKSUM_LEN];
411 SET_MODULE_OWNER(dev);
412 /* Initialize the device structure. */
414 memset(lp, 0, sizeof(*lp));
415 spin_lock_init(&lp->lock);
420 lp->dma = g_cs89x0_dma;
421 lp->dmasize = 16; /* Could make this an option... */
424 lp->force = g_cs89x0_media__force;
428 /* Grab the region so we can find another board if autoIRQ fails. */
429 /* WTF is going on here? */
430 if (!request_region(ioaddr & ~3, NETCARD_IO_EXTENT, DRV_NAME)) {
431 printk(KERN_ERR "%s: request_region(0x%x, 0x%x) failed\n",
432 DRV_NAME, ioaddr, NETCARD_IO_EXTENT);
437 #ifdef CONFIG_SH_HICOSH4
438 /* truely reset the chip */
439 outw(0x0114, ioaddr + ADD_PORT);
440 outw(0x0040, ioaddr + DATA_PORT);
443 /* if they give us an odd I/O address, then do ONE write to
444 the address port, to get it back to address zero, where we
445 expect to find the EISA signature word. An IO with a base of 0x3
446 will skip the test for the ADD_PORT. */
449 printk(KERN_INFO "%s: odd ioaddr 0x%x\n", dev->name, ioaddr);
450 if ((ioaddr & 2) != 2)
451 if ((inw((ioaddr & ~3)+ ADD_PORT) & ADD_MASK) != ADD_SIG) {
452 printk(KERN_ERR "%s: bad signature 0x%x\n",
453 dev->name, inw((ioaddr & ~3)+ ADD_PORT));
458 outw(PP_ChipID, ioaddr + ADD_PORT);
460 printk("PP_addr=0x%x\n", inw(ioaddr + ADD_PORT));
462 if (inw(ioaddr + DATA_PORT) != CHIP_EISA_ID_SIG) {
463 printk(KERN_ERR "%s: incorrect signature 0x%x\n",
464 dev->name, inw(ioaddr + DATA_PORT));
469 /* Fill in the 'dev' fields. */
470 dev->base_addr = ioaddr;
472 /* get the chip type */
473 rev_type = readreg(dev, PRODUCT_ID_ADD);
474 lp->chip_type = rev_type &~ REVISON_BITS;
475 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
477 /* Check the chip type and revision in order to set the correct send command
478 CS8920 revision C and CS8900 revision F can use the faster send. */
479 lp->send_cmd = TX_AFTER_381;
480 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
481 lp->send_cmd = TX_NOW;
482 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
483 lp->send_cmd = TX_NOW;
485 if (net_debug && version_printed++ == 0)
488 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#3lx ",
490 lp->chip_type==CS8900?'0':'2',
491 lp->chip_type==CS8920M?"M":"",
497 /* Here we read the current configuration of the chip. If there
498 is no Extended EEPROM then the idea is to not disturb the chip
499 configuration, it should have been correctly setup by automatic
500 EEPROM read on reset. So, if the chip says it read the EEPROM
501 the driver will always do *something* instead of complain that
504 #ifdef CONFIG_SH_HICOSH4
506 /* For the HiCO.SH4 board, things are different: we don't
507 have EEPROM, but there is some data in flash, so we go
508 get it there directly (MAC). */
511 if (((* (volatile __u32 *) 0xa0013ff0) & 0x00ffffff)
513 confd = (__u16*) 0xa0013fc0;
515 confd = (__u16*) 0xa001ffc0;
517 cnt = (*confd++ & 0x00ff) >> 1;
521 switch (j & 0x0fff) {
523 for (i = 0; i < ETH_ALEN/2; i++) {
524 dev->dev_addr[i*2] = confd[i] & 0xFF;
525 dev->dev_addr[i*2+1] = confd[i] >> 8;
536 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
537 (EEPROM_OK|EEPROM_PRESENT)) {
539 for (i=0; i < ETH_ALEN/2; i++) {
541 Addr = readreg(dev, PP_IA+i*2);
542 dev->dev_addr[i*2] = Addr & 0xFF;
543 dev->dev_addr[i*2+1] = Addr >> 8;
546 /* Load the Adapter Configuration.
547 Note: Barring any more specific information from some
548 other source (ie EEPROM+Schematics), we would not know
549 how to operate a 10Base2 interface on the AUI port.
550 However, since we do read the status of HCB1 and use
551 settings that always result in calls to control_dc_dc(dev,0)
552 a BNC interface should work if the enable pin
553 (dc/dc converter) is on HCB1. It will be called AUI
557 i = readreg(dev, PP_LineCTL);
558 /* Preserve the setting of the HCB1 pin. */
559 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
560 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
561 /* Save the sqelch bit */
562 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
563 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
564 /* Check if the card is in 10Base-t only mode */
565 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
566 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
567 /* Check if the card is in AUI only mode */
568 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
569 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
570 /* Check if the card is in Auto mode. */
571 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
572 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
573 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
576 printk(KERN_INFO "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
577 dev->name, i, lp->adapter_cnf);
579 /* IRQ. Other chips already probe, see below. */
580 if (lp->chip_type == CS8900)
581 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
583 printk( "[Cirrus EEPROM] ");
588 /* First check to see if an EEPROM is attached. */
589 #ifdef CONFIG_SH_HICOSH4 /* no EEPROM on HiCO, don't hazzle with it here */
591 printk(KERN_NOTICE "cs89x0: No EEPROM on HiCO.SH4\n");
594 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
595 printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....\n");
596 else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
597 printk(KERN_WARNING "\ncs89x0: EEPROM read failed, relying on command line.\n");
598 } else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
599 /* Check if the chip was able to read its own configuration starting
601 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
602 (EEPROM_OK|EEPROM_PRESENT))
603 printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
606 /* This reads an extended EEPROM that is not documented
607 in the CS8900 datasheet. */
609 /* get transmission control word but keep the autonegotiation bits */
610 if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];
611 /* Store adapter configuration */
612 if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];
613 /* Store ISA configuration */
614 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2];
615 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;
617 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */
618 /* store the initial memory base address */
619 for (i = 0; i < ETH_ALEN/2; i++) {
620 dev->dev_addr[i*2] = eeprom_buff[i];
621 dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8;
624 printk(KERN_DEBUG "%s: new adapter_cnf: 0x%x\n",
625 dev->name, lp->adapter_cnf);
628 /* allow them to force multiple transceivers. If they force multiple, autosense */
631 if (lp->force & FORCE_RJ45) {lp->adapter_cnf |= A_CNF_10B_T; count++; }
632 if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_AUI; count++; }
633 if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_10B_2; count++; }
634 if (count > 1) {lp->adapter_cnf |= A_CNF_MEDIA_AUTO; }
635 else if (lp->force & FORCE_RJ45){lp->adapter_cnf |= A_CNF_MEDIA_10B_T; }
636 else if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_MEDIA_AUI; }
637 else if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_MEDIA_10B_2; }
641 printk(KERN_DEBUG "%s: after force 0x%x, adapter_cnf=0x%x\n",
642 dev->name, lp->force, lp->adapter_cnf);
644 /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
646 /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
648 /* FIXME: we don't set the Ethernet address on the command line. Use
649 ifconfig IFACE hw ether AABBCCDDEEFF */
651 printk(KERN_INFO "cs89x0 media %s%s%s",
652 (lp->adapter_cnf & A_CNF_10B_T)?"RJ-45,":"",
653 (lp->adapter_cnf & A_CNF_AUI)?"AUI,":"",
654 (lp->adapter_cnf & A_CNF_10B_2)?"BNC,":"");
656 lp->irq_map = 0xffff;
658 /* If this is a CS8900 then no pnp soft */
659 if (lp->chip_type != CS8900 &&
660 /* Check if the ISA IRQ has been set */
661 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
662 (i != 0 && i < CS8920_NO_INTS))) {
666 i = lp->isa_config & INT_NO_MASK;
667 if (lp->chip_type == CS8900) {
668 /* Translate the IRQ using the IRQ mapping table. */
669 if (i >= sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]))
670 printk("\ncs89x0: invalid ISA interrupt number %d\n", i);
672 i = cs8900_irq_map[i];
674 lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
676 int irq_map_buff[IRQ_MAP_LEN/2];
678 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
680 irq_map_buff) >= 0) {
681 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
682 lp->irq_map = (irq_map_buff[0]>>8) | (irq_map_buff[1] << 8);
689 printk(" IRQ %d", dev->irq);
693 get_dma_channel(dev);
694 printk(", DMA %d", dev->dma);
699 printk(", programmed I/O");
702 /* print the ethernet address. */
704 for (i = 0; i < ETH_ALEN; i++)
706 printk("%c%02x", i ? ':' : ' ', dev->dev_addr[i]);
709 dev->open = net_open;
710 dev->stop = net_close;
711 dev->tx_timeout = net_timeout;
712 dev->watchdog_timeo = HZ;
713 dev->hard_start_xmit = net_send_packet;
714 dev->get_stats = net_get_stats;
715 dev->set_multicast_list = set_multicast_list;
716 dev->set_mac_address = set_mac_address;
720 printk("cs89x0_probe1() successful\n");
723 release_region(ioaddr & ~3, NETCARD_IO_EXTENT);
729 /*********************************
730 * This page contains DMA routines
731 **********************************/
735 #define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
738 get_dma_channel(struct net_device *dev)
740 struct net_local *lp = netdev_priv(dev);
744 lp->isa_config |= ISA_RxDMA;
746 if ((lp->isa_config & ANY_ISA_DMA) == 0)
748 dev->dma = lp->isa_config & DMA_NO_MASK;
749 if (lp->chip_type == CS8900)
751 if (dev->dma < 5 || dev->dma > 7) {
752 lp->isa_config &= ~ANY_ISA_DMA;
760 write_dma(struct net_device *dev, int chip_type, int dma)
762 struct net_local *lp = netdev_priv(dev);
763 if ((lp->isa_config & ANY_ISA_DMA) == 0)
765 if (chip_type == CS8900) {
766 writereg(dev, PP_CS8900_ISADMA, dma-5);
768 writereg(dev, PP_CS8920_ISADMA, dma);
773 set_dma_cfg(struct net_device *dev)
775 struct net_local *lp = netdev_priv(dev);
778 if ((lp->isa_config & ANY_ISA_DMA) == 0) {
780 printk("set_dma_cfg(): no DMA\n");
783 if (lp->isa_config & ISA_RxDMA) {
784 lp->curr_rx_cfg |= RX_DMA_ONLY;
786 printk("set_dma_cfg(): RX_DMA_ONLY\n");
788 lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
790 printk("set_dma_cfg(): AUTO_RX_DMA\n");
796 dma_bufcfg(struct net_device *dev)
798 struct net_local *lp = netdev_priv(dev);
800 return (lp->isa_config & ANY_ISA_DMA)? RX_DMA_ENBL : 0;
806 dma_busctl(struct net_device *dev)
809 struct net_local *lp = netdev_priv(dev);
811 if (lp->isa_config & ANY_ISA_DMA)
812 retval |= RESET_RX_DMA; /* Reset the DMA pointer */
813 if (lp->isa_config & DMA_BURST)
814 retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
815 if (lp->dmasize == 64)
816 retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
817 retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
823 dma_rx(struct net_device *dev)
825 struct net_local *lp = netdev_priv(dev);
828 unsigned char *bp = lp->rx_dma_ptr;
830 status = bp[0] + (bp[1]<<8);
831 length = bp[2] + (bp[3]<<8);
834 printk( "%s: receiving DMA packet at %lx, status %x, length %x\n",
835 dev->name, (unsigned long)bp, status, length);
837 if ((status & RX_OK) == 0) {
838 count_rx_errors(status, lp);
839 goto skip_this_frame;
842 /* Malloc up new buffer. */
843 skb = dev_alloc_skb(length + 2);
845 if (net_debug) /* I don't think we want to do this to a stressed system */
846 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
847 lp->stats.rx_dropped++;
849 /* AKPM: advance bp to the next frame */
851 bp += (length + 3) & ~3;
852 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
856 skb_reserve(skb, 2); /* longword align L3 header */
859 if (bp + length > lp->end_dma_buff) {
860 int semi_cnt = lp->end_dma_buff - bp;
861 memcpy(skb_put(skb,semi_cnt), bp, semi_cnt);
862 memcpy(skb_put(skb,length - semi_cnt), lp->dma_buff,
865 memcpy(skb_put(skb,length), bp, length);
867 bp += (length + 3) & ~3;
868 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
872 printk( "%s: received %d byte DMA packet of type %x\n",
874 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
876 skb->protocol=eth_type_trans(skb,dev);
878 dev->last_rx = jiffies;
879 lp->stats.rx_packets++;
880 lp->stats.rx_bytes += length;
883 #endif /* ALLOW_DMA */
885 void __init reset_chip(struct net_device *dev)
887 struct net_local *lp = netdev_priv(dev);
888 int ioaddr = dev->base_addr;
889 int reset_start_time;
891 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
894 current->state = TASK_INTERRUPTIBLE;
895 schedule_timeout(30*HZ/1000);
897 if (lp->chip_type != CS8900) {
898 /* Hardware problem requires PNP registers to be reconfigured after a reset */
899 outw(PP_CS8920_ISAINT, ioaddr + ADD_PORT);
900 outb(dev->irq, ioaddr + DATA_PORT);
901 outb(0, ioaddr + DATA_PORT + 1);
903 outw(PP_CS8920_ISAMemB, ioaddr + ADD_PORT);
904 outb((dev->mem_start >> 16) & 0xff, ioaddr + DATA_PORT);
905 outb((dev->mem_start >> 8) & 0xff, ioaddr + DATA_PORT + 1);
907 /* Wait until the chip is reset */
908 reset_start_time = jiffies;
909 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
915 control_dc_dc(struct net_device *dev, int on_not_off)
917 struct net_local *lp = netdev_priv(dev);
918 unsigned int selfcontrol;
919 int timenow = jiffies;
920 /* control the DC to DC convertor in the SelfControl register.
921 Note: This is hooked up to a general purpose pin, might not
922 always be a DC to DC convertor. */
924 selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
925 if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
928 selfcontrol &= ~HCB1;
929 writereg(dev, PP_SelfCTL, selfcontrol);
931 /* Wait for the DC/DC converter to power up - 500ms */
932 while (jiffies - timenow < HZ)
936 #define DETECTED_NONE 0
937 #define DETECTED_RJ45H 1
938 #define DETECTED_RJ45F 2
939 #define DETECTED_AUI 3
940 #define DETECTED_BNC 4
943 detect_tp(struct net_device *dev)
945 struct net_local *lp = netdev_priv(dev);
946 int timenow = jiffies;
949 if (net_debug > 1) printk("%s: Attempting TP\n", dev->name);
951 /* If connected to another full duplex capable 10-Base-T card the link pulses
952 seem to be lost when the auto detect bit in the LineCTL is set.
953 To overcome this the auto detect bit will be cleared whilst testing the
954 10-Base-T interface. This would not be necessary for the sparrow chip but
955 is simpler to do it anyway. */
956 writereg(dev, PP_LineCTL, lp->linectl &~ AUI_ONLY);
957 control_dc_dc(dev, 0);
959 /* Delay for the hardware to work out if the TP cable is present - 150ms */
960 for (timenow = jiffies; jiffies - timenow < 15; )
962 if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
963 return DETECTED_NONE;
965 if (lp->chip_type == CS8900) {
966 switch (lp->force & 0xf0) {
969 printk("%s: cs8900 doesn't autonegotiate\n",dev->name);
970 return DETECTED_NONE;
972 /* CS8900 doesn't support AUTO, change to HALF*/
974 lp->force &= ~FORCE_AUTO;
975 lp->force |= FORCE_HALF;
980 writereg(dev, PP_TestCTL, readreg(dev, PP_TestCTL) | FDX_8900);
983 fdx = readreg(dev, PP_TestCTL) & FDX_8900;
985 switch (lp->force & 0xf0) {
987 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
990 lp->auto_neg_cnf = 0;
993 lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
997 writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
999 if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
1000 printk(KERN_INFO "%s: negotiating duplex...\n",dev->name);
1001 while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
1002 if (jiffies - timenow > 4000) {
1003 printk(KERN_ERR "**** Full / half duplex auto-negotiation timed out ****\n");
1008 fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
1011 return DETECTED_RJ45F;
1013 return DETECTED_RJ45H;
1016 /* send a test packet - return true if carrier bits are ok */
1018 send_test_pkt(struct net_device *dev)
1020 char test_packet[] = { 0,0,0,0,0,0, 0,0,0,0,0,0,
1021 0, 46, /* A 46 in network order */
1022 0, 0, /* DSAP=0 & SSAP=0 fields */
1023 0xf3, 0 /* Control (Test Req + P bit set) */ };
1024 long timenow = jiffies;
1026 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
1028 memcpy(test_packet, dev->dev_addr, ETH_ALEN);
1029 memcpy(test_packet+ETH_ALEN, dev->dev_addr, ETH_ALEN);
1031 writeword(dev, TX_CMD_PORT, TX_AFTER_ALL);
1032 writeword(dev, TX_LEN_PORT, ETH_ZLEN);
1034 /* Test to see if the chip has allocated memory for the packet */
1035 while (jiffies - timenow < 5)
1036 if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
1038 if (jiffies - timenow >= 5)
1039 return 0; /* this shouldn't happen */
1041 /* Write the contents of the packet */
1042 outsw(dev->base_addr + TX_FRAME_PORT,test_packet,(ETH_ZLEN+1) >>1);
1044 if (net_debug > 1) printk("Sending test packet ");
1045 /* wait a couple of jiffies for packet to be received */
1046 for (timenow = jiffies; jiffies - timenow < 3; )
1048 if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
1049 if (net_debug > 1) printk("succeeded\n");
1052 if (net_debug > 1) printk("failed\n");
1058 detect_aui(struct net_device *dev)
1060 struct net_local *lp = netdev_priv(dev);
1062 if (net_debug > 1) printk("%s: Attempting AUI\n", dev->name);
1063 control_dc_dc(dev, 0);
1065 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1067 if (send_test_pkt(dev))
1068 return DETECTED_AUI;
1070 return DETECTED_NONE;
1074 detect_bnc(struct net_device *dev)
1076 struct net_local *lp = netdev_priv(dev);
1078 if (net_debug > 1) printk("%s: Attempting BNC\n", dev->name);
1079 control_dc_dc(dev, 1);
1081 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1083 if (send_test_pkt(dev))
1084 return DETECTED_BNC;
1086 return DETECTED_NONE;
1091 write_irq(struct net_device *dev, int chip_type, int irq)
1095 if (chip_type == CS8900) {
1096 /* Search the mapping table for the corresponding IRQ pin. */
1097 for (i = 0; i != sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]); i++)
1098 if (cs8900_irq_map[i] == irq)
1101 if (i == sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]))
1103 writereg(dev, PP_CS8900_ISAINT, i);
1105 writereg(dev, PP_CS8920_ISAINT, irq);
1109 /* Open/initialize the board. This is called (in the current kernel)
1110 sometime after booting when the 'ifconfig' program is run.
1112 This routine should set everything up anew at each open, even
1113 registers that "should" only need to be set once at boot, so that
1114 there is non-reboot way to recover if something goes wrong.
1117 /* AKPM: do we need to do any locking here? */
1120 net_open(struct net_device *dev)
1122 struct net_local *lp = netdev_priv(dev);
1127 #ifndef CONFIG_SH_HICOSH4 /* uses irq#1, so this won't work */
1129 /* Allow interrupts to be generated by the chip */
1130 /* Cirrus' release had this: */
1132 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1134 /* And 2.3.47 had this: */
1135 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1137 for (i = 2; i < CS8920_NO_INTS; i++) {
1138 if ((1 << i) & lp->irq_map) {
1139 if (request_irq(i, net_interrupt, 0, dev->name, dev) == 0) {
1141 write_irq(dev, lp->chip_type, i);
1142 /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
1148 if (i >= CS8920_NO_INTS) {
1149 writereg(dev, PP_BusCTL, 0); /* disable interrupts. */
1150 printk(KERN_ERR "cs89x0: can't get an interrupt\n");
1158 if (((1 << dev->irq) & lp->irq_map) == 0) {
1159 printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
1160 dev->name, dev->irq, lp->irq_map);
1164 /* FIXME: Cirrus' release had this: */
1165 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1166 /* And 2.3.47 had this: */
1168 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1170 write_irq(dev, lp->chip_type, dev->irq);
1171 ret = request_irq(dev->irq, &net_interrupt, 0, dev->name, dev);
1174 printk(KERN_DEBUG "cs89x0: request_irq(%d) failed\n", dev->irq);
1181 if (lp->isa_config & ANY_ISA_DMA) {
1182 unsigned long flags;
1183 lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
1184 get_order(lp->dmasize * 1024));
1186 if (!lp->dma_buff) {
1187 printk(KERN_ERR "%s: cannot get %dK memory for DMA\n", dev->name, lp->dmasize);
1190 if (net_debug > 1) {
1191 printk( "%s: dma %lx %lx\n",
1193 (unsigned long)lp->dma_buff,
1194 (unsigned long)isa_virt_to_bus(lp->dma_buff));
1196 if ((unsigned long) lp->dma_buff >= MAX_DMA_ADDRESS ||
1197 !dma_page_eq(lp->dma_buff, lp->dma_buff+lp->dmasize*1024-1)) {
1198 printk(KERN_ERR "%s: not usable as DMA buffer\n", dev->name);
1201 memset(lp->dma_buff, 0, lp->dmasize * 1024); /* Why? */
1202 if (request_dma(dev->dma, dev->name)) {
1203 printk(KERN_ERR "%s: cannot get dma channel %d\n", dev->name, dev->dma);
1206 write_dma(dev, lp->chip_type, dev->dma);
1207 lp->rx_dma_ptr = lp->dma_buff;
1208 lp->end_dma_buff = lp->dma_buff + lp->dmasize*1024;
1209 spin_lock_irqsave(&lp->lock, flags);
1210 disable_dma(dev->dma);
1211 clear_dma_ff(dev->dma);
1212 set_dma_mode(dev->dma, 0x14); /* auto_init as well */
1213 set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
1214 set_dma_count(dev->dma, lp->dmasize*1024);
1215 enable_dma(dev->dma);
1216 spin_unlock_irqrestore(&lp->lock, flags);
1219 #endif /* ALLOW_DMA */
1221 /* set the Ethernet address */
1222 for (i=0; i < ETH_ALEN/2; i++)
1223 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1225 /* while we're testing the interface, leave interrupts disabled */
1226 writereg(dev, PP_BusCTL, MEMORY_ON);
1228 /* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
1229 if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) && (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
1230 lp->linectl = LOW_RX_SQUELCH;
1234 /* check to make sure that they have the "right" hardware available */
1235 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1236 case A_CNF_MEDIA_10B_T: result = lp->adapter_cnf & A_CNF_10B_T; break;
1237 case A_CNF_MEDIA_AUI: result = lp->adapter_cnf & A_CNF_AUI; break;
1238 case A_CNF_MEDIA_10B_2: result = lp->adapter_cnf & A_CNF_10B_2; break;
1239 default: result = lp->adapter_cnf & (A_CNF_10B_T | A_CNF_AUI | A_CNF_10B_2);
1242 printk(KERN_ERR "%s: EEPROM is configured for unavailable media\n", dev->name);
1245 release_dma_buff(lp);
1247 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
1248 free_irq(dev->irq, dev);
1253 /* set the hardware to the configured choice */
1254 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1255 case A_CNF_MEDIA_10B_T:
1256 result = detect_tp(dev);
1257 if (result==DETECTED_NONE) {
1258 printk(KERN_WARNING "%s: 10Base-T (RJ-45) has no cable\n", dev->name);
1259 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1260 result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
1263 case A_CNF_MEDIA_AUI:
1264 result = detect_aui(dev);
1265 if (result==DETECTED_NONE) {
1266 printk(KERN_WARNING "%s: 10Base-5 (AUI) has no cable\n", dev->name);
1267 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1268 result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
1271 case A_CNF_MEDIA_10B_2:
1272 result = detect_bnc(dev);
1273 if (result==DETECTED_NONE) {
1274 printk(KERN_WARNING "%s: 10Base-2 (BNC) has no cable\n", dev->name);
1275 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1276 result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
1279 case A_CNF_MEDIA_AUTO:
1280 writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
1281 if (lp->adapter_cnf & A_CNF_10B_T)
1282 if ((result = detect_tp(dev)) != DETECTED_NONE)
1284 if (lp->adapter_cnf & A_CNF_AUI)
1285 if ((result = detect_aui(dev)) != DETECTED_NONE)
1287 if (lp->adapter_cnf & A_CNF_10B_2)
1288 if ((result = detect_bnc(dev)) != DETECTED_NONE)
1290 printk(KERN_ERR "%s: no media detected\n", dev->name);
1295 printk(KERN_ERR "%s: no network cable attached to configured media\n", dev->name);
1297 case DETECTED_RJ45H:
1298 printk(KERN_INFO "%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
1300 case DETECTED_RJ45F:
1301 printk(KERN_INFO "%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
1304 printk(KERN_INFO "%s: using 10Base-5 (AUI)\n", dev->name);
1307 printk(KERN_INFO "%s: using 10Base-2 (BNC)\n", dev->name);
1311 /* Turn on both receive and transmit operations */
1312 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1314 /* Receive only error free packets addressed to this card */
1316 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
1318 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
1320 if (lp->isa_config & STREAM_TRANSFER)
1321 lp->curr_rx_cfg |= RX_STREAM_ENBL;
1325 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
1327 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
1328 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
1330 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
1334 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
1336 /* now that we've got our act together, enable everything */
1337 writereg(dev, PP_BusCTL, ENABLE_IRQ
1338 | (dev->mem_start?MEMORY_ON : 0) /* turn memory on */
1343 netif_start_queue(dev);
1345 printk("cs89x0: net_open() succeeded\n");
1351 static void net_timeout(struct net_device *dev)
1353 /* If we get here, some higher level has decided we are broken.
1354 There should really be a "kick me" function call instead. */
1355 if (net_debug > 0) printk("%s: transmit timed out, %s?\n", dev->name,
1356 tx_done(dev) ? "IRQ conflict ?" : "network cable problem");
1357 /* Try to restart the adaptor. */
1358 netif_wake_queue(dev);
1361 static int net_send_packet(struct sk_buff *skb, struct net_device *dev)
1363 struct net_local *lp = netdev_priv(dev);
1365 if (net_debug > 3) {
1366 printk("%s: sent %d byte packet of type %x\n",
1367 dev->name, skb->len,
1368 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1371 /* keep the upload from being interrupted, since we
1372 ask the chip to start transmitting before the
1373 whole packet has been completely uploaded. */
1375 spin_lock_irq(&lp->lock);
1376 netif_stop_queue(dev);
1378 /* initiate a transmit sequence */
1379 writeword(dev, TX_CMD_PORT, lp->send_cmd);
1380 writeword(dev, TX_LEN_PORT, skb->len);
1382 /* Test to see if the chip has allocated memory for the packet */
1383 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1385 * Gasp! It hasn't. But that shouldn't happen since
1386 * we're waiting for TxOk, so return 1 and requeue this packet.
1389 spin_unlock_irq(&lp->lock);
1390 if (net_debug) printk("cs89x0: Tx buffer not free!\n");
1393 /* Write the contents of the packet */
1394 outsw(dev->base_addr + TX_FRAME_PORT,skb->data,(skb->len+1) >>1);
1395 spin_unlock_irq(&lp->lock);
1396 dev->trans_start = jiffies;
1397 dev_kfree_skb (skb);
1400 * We DO NOT call netif_wake_queue() here.
1401 * We also DO NOT call netif_start_queue().
1403 * Either of these would cause another bottom half run through
1404 * net_send_packet() before this packet has fully gone out. That causes
1405 * us to hit the "Gasp!" above and the send is rescheduled. it runs like
1406 * a dog. We just return and wait for the Tx completion interrupt handler
1407 * to restart the netdevice layer
1413 /* The typical workload of the driver:
1414 Handle the network interface interrupts. */
1416 static irqreturn_t net_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1418 struct net_device *dev = dev_id;
1419 struct net_local *lp;
1423 ioaddr = dev->base_addr;
1424 lp = netdev_priv(dev);
1426 /* we MUST read all the events out of the ISQ, otherwise we'll never
1427 get interrupted again. As a consequence, we can't have any limit
1428 on the number of times we loop in the interrupt handler. The
1429 hardware guarantees that eventually we'll run out of events. Of
1430 course, if you're on a slow machine, and packets are arriving
1431 faster than you can read them off, you're screwed. Hasta la
1433 while ((status = readword(dev, ISQ_PORT))) {
1434 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
1436 switch(status & ISQ_EVENT_MASK) {
1437 case ISQ_RECEIVER_EVENT:
1438 /* Got a packet(s). */
1441 case ISQ_TRANSMITTER_EVENT:
1442 lp->stats.tx_packets++;
1443 netif_wake_queue(dev); /* Inform upper layers. */
1444 if ((status & ( TX_OK |
1448 TX_16_COL)) != TX_OK) {
1449 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
1450 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
1451 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
1452 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
1453 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
1456 case ISQ_BUFFER_EVENT:
1457 if (status & READY_FOR_TX) {
1458 /* we tried to transmit a packet earlier,
1459 but inexplicably ran out of buffers.
1460 That shouldn't happen since we only ever
1461 load one packet. Shrug. Do the right
1463 netif_wake_queue(dev); /* Inform upper layers. */
1465 if (status & TX_UNDERRUN) {
1466 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
1467 lp->send_underrun++;
1468 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
1469 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
1470 /* transmit cycle is done, although
1471 frame wasn't transmitted - this
1472 avoids having to wait for the upper
1473 layers to timeout on us, in the
1474 event of a tx underrun */
1475 netif_wake_queue(dev); /* Inform upper layers. */
1478 if (lp->use_dma && (status & RX_DMA)) {
1479 int count = readreg(dev, PP_DmaFrameCnt);
1482 printk("%s: receiving %d DMA frames\n", dev->name, count);
1483 if (net_debug > 2 && count >1)
1484 printk("%s: receiving %d DMA frames\n", dev->name, count);
1487 count = readreg(dev, PP_DmaFrameCnt);
1488 if (net_debug > 2 && count > 0)
1489 printk("%s: continuing with %d DMA frames\n", dev->name, count);
1494 case ISQ_RX_MISS_EVENT:
1495 lp->stats.rx_missed_errors += (status >>6);
1497 case ISQ_TX_COL_EVENT:
1498 lp->stats.collisions += (status >>6);
1502 return IRQ_RETVAL(handled);
1506 count_rx_errors(int status, struct net_local *lp)
1508 lp->stats.rx_errors++;
1509 if (status & RX_RUNT) lp->stats.rx_length_errors++;
1510 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
1511 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
1513 lp->stats.rx_crc_errors++;
1514 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
1518 /* We have a good packet(s), get it/them out of the buffers. */
1520 net_rx(struct net_device *dev)
1522 struct net_local *lp = netdev_priv(dev);
1523 struct sk_buff *skb;
1526 int ioaddr = dev->base_addr;
1527 status = inw(ioaddr + RX_FRAME_PORT);
1528 length = inw(ioaddr + RX_FRAME_PORT);
1530 if ((status & RX_OK) == 0) {
1531 count_rx_errors(status, lp);
1535 /* Malloc up new buffer. */
1536 skb = dev_alloc_skb(length + 2);
1538 #if 0 /* Again, this seems a cruel thing to do */
1539 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1541 lp->stats.rx_dropped++;
1544 skb_reserve(skb, 2); /* longword align L3 header */
1547 insw(ioaddr + RX_FRAME_PORT, skb_put(skb, length), length >> 1);
1549 skb->data[length-1] = inw(ioaddr + RX_FRAME_PORT);
1551 if (net_debug > 3) {
1552 printk( "%s: received %d byte packet of type %x\n",
1554 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1557 skb->protocol=eth_type_trans(skb,dev);
1559 dev->last_rx = jiffies;
1560 lp->stats.rx_packets++;
1561 lp->stats.rx_bytes += length;
1565 static void release_dma_buff(struct net_local *lp)
1568 free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024));
1574 /* The inverse routine to net_open(). */
1576 net_close(struct net_device *dev)
1578 struct net_local *lp = netdev_priv(dev);
1580 netif_stop_queue(dev);
1582 writereg(dev, PP_RxCFG, 0);
1583 writereg(dev, PP_TxCFG, 0);
1584 writereg(dev, PP_BufCFG, 0);
1585 writereg(dev, PP_BusCTL, 0);
1587 free_irq(dev->irq, dev);
1590 if (lp->use_dma && lp->dma) {
1592 release_dma_buff(lp);
1596 /* Update the statistics here. */
1600 /* Get the current statistics. This may be called with the card open or
1602 static struct net_device_stats *
1603 net_get_stats(struct net_device *dev)
1605 struct net_local *lp = netdev_priv(dev);
1606 unsigned long flags;
1608 spin_lock_irqsave(&lp->lock, flags);
1609 /* Update the statistics from the device registers. */
1610 lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1611 lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1612 spin_unlock_irqrestore(&lp->lock, flags);
1617 static void set_multicast_list(struct net_device *dev)
1619 struct net_local *lp = netdev_priv(dev);
1620 unsigned long flags;
1622 spin_lock_irqsave(&lp->lock, flags);
1623 if(dev->flags&IFF_PROMISC)
1625 lp->rx_mode = RX_ALL_ACCEPT;
1627 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
1629 /* The multicast-accept list is initialized to accept-all, and we
1630 rely on higher-level filtering for now. */
1631 lp->rx_mode = RX_MULTCAST_ACCEPT;
1636 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1638 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
1639 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
1640 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
1641 spin_unlock_irqrestore(&lp->lock, flags);
1645 static int set_mac_address(struct net_device *dev, void *p)
1648 struct sockaddr *addr = p;
1651 if (netif_running(dev))
1654 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1657 printk("%s: Setting MAC address to ", dev->name);
1658 for (i = 0; i < dev->addr_len; i++)
1659 printk(" %2.2x", dev->dev_addr[i]);
1662 /* set the Ethernet address */
1663 for (i=0; i < ETH_ALEN/2; i++)
1664 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1671 static struct net_device *dev_cs89x0;
1674 * Support the 'debug' module parm even if we're compiled for non-debug to
1675 * avoid breaking someone's startup scripts
1681 static char media[8];
1682 static int duplex=-1;
1684 static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
1686 static int dmasize=16; /* or 64 */
1688 MODULE_PARM(io, "i");
1689 MODULE_PARM(irq, "i");
1690 MODULE_PARM(debug, "i");
1691 MODULE_PARM(media, "c8");
1692 MODULE_PARM(duplex, "i");
1693 MODULE_PARM(dma , "i");
1694 MODULE_PARM(dmasize , "i");
1695 MODULE_PARM(use_dma , "i");
1696 MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1697 MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1699 MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1701 MODULE_PARM_DESC(debug, "(ignored)");
1703 MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1704 /* No other value than -1 for duplex seems to be currently interpreted */
1705 MODULE_PARM_DESC(duplex, "(ignored)");
1707 MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1708 MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1709 MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1711 MODULE_PARM_DESC(dma , "(ignored)");
1712 MODULE_PARM_DESC(dmasize , "(ignored)");
1713 MODULE_PARM_DESC(use_dma , "(ignored)");
1716 MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton <andrewm@uow.edu.au>");
1717 MODULE_LICENSE("GPL");
1721 * media=t - specify media type
1725 * duplex=0 - specify forced half/full/autonegotiate duplex
1726 * debug=# - debug level
1729 * Default Chip Configuration:
1730 * DMA Burst = enabled
1731 * IOCHRDY Enabled = enabled
1733 * CS8900 defaults to half-duplex if not specified on command-line
1734 * CS8920 defaults to autoneg if not specified on command-line
1735 * Use reset defaults for other config parameters
1738 * media type specified is supported (circuitry is present)
1739 * if memory address is > 1MB, then required mem decode hw is present
1740 * if 10B-2, then agent other than driver will enable DC/DC converter
1741 (hw or software util)
1749 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1750 struct net_local *lp;
1762 dev->base_addr = io;
1763 lp = netdev_priv(dev);
1767 lp->use_dma = use_dma;
1769 lp->dmasize = dmasize;
1773 spin_lock_init(&lp->lock);
1775 /* boy, they'd better get these right */
1776 if (!strcmp(media, "rj45"))
1777 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1778 else if (!strcmp(media, "aui"))
1779 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1780 else if (!strcmp(media, "bnc"))
1781 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1783 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1786 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1789 printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n");
1790 printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n");
1793 } else if (io <= 0x1ff) {
1799 if (use_dma && dmasize != 16 && dmasize != 64) {
1800 printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize);
1805 ret = cs89x0_probe1(dev, io, 1);
1809 if (register_netdev(dev) != 0) {
1810 printk(KERN_ERR "cs89x0.c: No card found at 0x%x\n", io);
1812 outw(PP_ChipID, dev->base_addr + ADD_PORT);
1813 release_region(dev->base_addr, NETCARD_IO_EXTENT);
1824 cleanup_module(void)
1826 unregister_netdev(dev_cs89x0);
1827 outw(PP_ChipID, dev_cs89x0->base_addr + ADD_PORT);
1828 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1829 free_netdev(dev_cs89x0);
1835 * version-control: t
1836 * kept-new-versions: 5