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/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>
93 #include <linux/version.h>
96 * Set this to zero to disable DMA code
98 * Note that even if DMA is turned off we still support the 'dma' and 'use_dma'
99 * module options so we don't break any startup scripts.
101 #ifdef CONFIG_BEECH /* IBM 405LP/Beech does not have external DMA */
108 * Set this to zero to remove all the debug statements via
109 * dead code elimination
116 Crynwr packet driver epktisa.
118 Crystal Semiconductor data sheets.
122 #include <linux/kernel.h>
123 #include <linux/sched.h>
124 #include <linux/types.h>
125 #include <linux/fcntl.h>
126 #include <linux/interrupt.h>
127 #include <linux/ptrace.h>
128 #include <linux/ioport.h>
129 #include <linux/in.h>
130 #include <linux/slab.h>
131 #include <linux/string.h>
132 #include <linux/init.h>
133 #include <asm/system.h>
134 #include <asm/bitops.h>
139 #include <linux/errno.h>
140 #include <linux/spinlock.h>
142 #include <linux/netdevice.h>
143 #include <linux/etherdevice.h>
144 #include <linux/skbuff.h>
148 static char version[] __initdata =
149 "cs89x0.c: v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton <andrewm@uow.edu.au>, Modified by Ralph Blach for the Earl\n";
151 /* First, a few definitions that the brave might change.
152 A zero-terminated list of I/O addresses to be probed. Some special flags..
153 Addr & 1 = Read back the address port, look for signature and reset
154 the page window before probing
155 Addr & 3 = Reset the page window and probe
156 The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,
157 but it is possible that a Cirrus board could be plugged into the ISA
159 /* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
160 them to system IRQ numbers. This mapping is card specific and is set to
161 the configuration of the Cirrus Eval board for this chip. */
162 #ifdef CONFIG_ARCH_CLPS7500
163 static unsigned int netcard_portlist[] __initdata =
164 { 0x80090303, 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
165 static unsigned int cs8900_irq_map[] = {12,0,0,0};
166 #elif defined(CONFIG_SH_HICOSH4)
167 static unsigned int netcard_portlist[] __initdata =
169 static unsigned int cs8900_irq_map[] = {1,0,0,0};
170 #elif defined (CONFIG_BEECH)
171 static unsigned int netcard_portlist[] __initdata =
172 { 0 /* filled in with mapped virtual addr later */, 0};
173 static unsigned int cs8900_irq_map[] = {UIC_IRQ_EIR4,0,0,0};
176 * Undo PCMCIA definition and replace with zero for no offset from the
177 * ioremapped address.
184 static unsigned int netcard_portlist[] __initdata =
185 { 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
186 static unsigned int cs8900_irq_map[] = {10,11,12,5};
190 static unsigned int net_debug = DEBUGGING;
192 #define net_debug 0 /* gcc will remove all the debug code for us */
195 /* The number of low I/O ports used by the ethercard. */
196 #define NETCARD_IO_EXTENT 16
198 /* we allow the user to override various values normally set in the EEPROM */
199 #define FORCE_RJ45 0x0001 /* pick one of these three */
200 #define FORCE_AUI 0x0002
201 #define FORCE_BNC 0x0004
203 #define FORCE_AUTO 0x0010 /* pick one of these three */
204 #define FORCE_HALF 0x0020
205 #define FORCE_FULL 0x0030
207 /* Information that need to be kept for each board. */
209 struct net_device_stats stats;
210 int chip_type; /* one of: CS8900, CS8920, CS8920M */
211 char chip_revision; /* revision letter of the chip ('A'...) */
212 int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
213 int auto_neg_cnf; /* auto-negotiation word from EEPROM */
214 int adapter_cnf; /* adapter configuration from EEPROM */
215 int isa_config; /* ISA configuration from EEPROM */
216 int irq_map; /* IRQ map from EEPROM */
217 int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
218 int curr_rx_cfg; /* a copy of PP_RxCFG */
219 int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
220 int send_underrun; /* keep track of how many underruns in a row we get */
221 int force; /* force various values; see FORCE* above. */
224 int use_dma; /* Flag: we're using dma */
225 int dma; /* DMA channel */
226 int dmasize; /* 16 or 64 */
227 unsigned char *dma_buff; /* points to the beginning of the buffer */
228 unsigned char *end_dma_buff; /* points to the end of the buffer */
229 unsigned char *rx_dma_ptr; /* points to the next packet */
233 /* Index to functions, as function prototypes. */
235 extern int cs89x0_probe(struct net_device *dev);
237 static int cs89x0_probe1(struct net_device *dev, int ioaddr);
238 static int net_open(struct net_device *dev);
239 static int net_send_packet(struct sk_buff *skb, struct net_device *dev);
240 static void net_interrupt(int irq, void *dev_id, struct pt_regs *regs);
241 static void set_multicast_list(struct net_device *dev);
242 static void net_timeout(struct net_device *dev);
243 static void net_rx(struct net_device *dev);
244 static int net_close(struct net_device *dev);
245 static struct net_device_stats *net_get_stats(struct net_device *dev);
246 static void reset_chip(struct net_device *dev);
247 static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer);
248 static int get_eeprom_cksum(int off, int len, int *buffer);
249 static int set_mac_address(struct net_device *dev, void *addr);
250 static void count_rx_errors(int status, struct net_local *lp);
252 static void get_dma_channel(struct net_device *dev);
253 static void release_dma_buff(struct net_local *lp);
256 /* Example routines you must write ;->. */
257 #define tx_done(dev) 1
260 * Permit 'cs89x0_dma=N' in the kernel boot environment
262 #if !defined(MODULE) && (ALLOW_DMA != 0)
263 static int g_cs89x0_dma;
265 static int __init dma_fn(char *str)
267 g_cs89x0_dma = simple_strtol(str,NULL,0);
271 __setup("cs89x0_dma=", dma_fn);
272 #endif /* !defined(MODULE) && (ALLOW_DMA != 0) */
275 static int g_cs89x0_media__force;
277 static int __init media_fn(char *str)
279 if (!strcmp(str, "rj45")) g_cs89x0_media__force = FORCE_RJ45;
280 else if (!strcmp(str, "aui")) g_cs89x0_media__force = FORCE_AUI;
281 else if (!strcmp(str, "bnc")) g_cs89x0_media__force = FORCE_BNC;
285 __setup("cs89x0_media=", media_fn);
289 /* Check for a network adaptor of this type, and return '0' iff one exists.
290 If dev->base_addr == 0, probe all likely locations.
291 If dev->base_addr == 1, always return failure.
292 If dev->base_addr == 2, allocate space for the device and return success
293 (detachable devices only).
297 int __init cs89x0_probe(struct net_device *dev)
300 int base_addr = dev ? dev->base_addr : 0;
302 SET_MODULE_OWNER(dev);
305 printk("cs89x0:cs89x0_probe(0x%x)\n", base_addr);
307 if (base_addr > 0x1ff) /* Check a single specified location. */
308 return cs89x0_probe1(dev, base_addr);
309 else if (base_addr != 0) /* Don't probe at all. */
313 netcard_portlist[0] =
314 (int) ioremap(BEECH_ETHERNET_PADDR, BEECH_ETHERNET_SIZE)
318 for (i = 0; netcard_portlist[i]; i++) {
319 if (cs89x0_probe1(dev, netcard_portlist[i]) == 0)
322 printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
325 iounmap(netcard_portlist[0]);
332 readreg(struct net_device *dev, int portno)
334 outw(portno, dev->base_addr + ADD_PORT);
335 return inw(dev->base_addr + DATA_PORT);
339 writereg(struct net_device *dev, int portno, int value)
341 outw(portno, dev->base_addr + ADD_PORT);
342 outw(value, dev->base_addr + DATA_PORT);
346 readword(struct net_device *dev, int portno)
348 return inw(dev->base_addr + portno);
352 writeword(struct net_device *dev, int portno, int value)
354 outw(value, dev->base_addr + portno);
358 wait_eeprom_ready(struct net_device *dev)
360 int timeout = jiffies;
361 /* check to see if the EEPROM is ready, a timeout is used -
362 just in case EEPROM is ready when SI_BUSY in the
363 PP_SelfST is clear */
364 while(readreg(dev, PP_SelfST) & SI_BUSY)
365 if (jiffies - timeout >= 40)
371 get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
375 if (net_debug > 3) printk("EEPROM data from %x for %x:\n",off,len);
376 for (i = 0; i < len; i++) {
377 if (wait_eeprom_ready(dev) < 0) return -1;
378 /* Now send the EEPROM read command and EEPROM location to read */
379 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
380 if (wait_eeprom_ready(dev) < 0) return -1;
381 buffer[i] = readreg(dev, PP_EEData);
382 if (net_debug > 3) printk("%04x ", buffer[i]);
384 if (net_debug > 3) printk("\n");
389 get_eeprom_cksum(int off, int len, int *buffer)
394 for (i = 0; i < len; i++)
402 /* This is the real probe routine. Linux has a history of friendly device
403 probes on the ISA bus. A good device probes avoids doing writes, and
404 verifies that the correct device exists and functions.
409 cs89x0_probe1(struct net_device *dev, int ioaddr)
411 struct net_local *lp;
412 static unsigned version_printed;
414 unsigned rev_type = 0;
415 int eeprom_buff[CHKSUM_LEN];
418 /* Initialize the device structure. */
419 if (dev->priv == NULL) {
420 dev->priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
421 if (dev->priv == 0) {
425 lp = (struct net_local *)dev->priv;
426 memset(lp, 0, sizeof(*lp));
427 spin_lock_init(&lp->lock);
428 #if !defined(MODULE) && (ALLOW_DMA != 0)
431 lp->dma = g_cs89x0_dma;
432 lp->dmasize = 16; /* Could make this an option... */
436 lp->force = g_cs89x0_media__force;
439 lp = (struct net_local *)dev->priv;
441 /* Grab the region so we can find another board if autoIRQ fails. */
442 if (!request_region(ioaddr & ~3, NETCARD_IO_EXTENT, dev->name)) {
443 printk(KERN_ERR "%s: request_region(0x%x, 0x%x) failed\n",
444 dev->name, ioaddr, NETCARD_IO_EXTENT);
449 #ifdef CONFIG_SH_HICOSH4
450 /* truely reset the chip */
451 outw(0x0114, ioaddr + ADD_PORT);
452 outw(0x0040, ioaddr + DATA_PORT);
455 /* if they give us an odd I/O address, then do ONE write to
456 the address port, to get it back to address zero, where we
457 expect to find the EISA signature word. An IO with a base of 0x3
458 will skip the test for the ADD_PORT. */
461 printk(KERN_INFO "%s: odd ioaddr 0x%x\n", dev->name, ioaddr);
462 if ((ioaddr & 2) != 2)
463 if ((inw((ioaddr & ~3)+ ADD_PORT) & ADD_MASK) != ADD_SIG) {
464 printk(KERN_ERR "%s: bad signature 0x%x\n",
465 dev->name, inw((ioaddr & ~3)+ ADD_PORT));
470 outw(PP_ChipID, ioaddr + ADD_PORT);
472 printk("PP_addr=0x%x\n", inw(ioaddr + ADD_PORT));
474 if (inw(ioaddr + DATA_PORT) != CHIP_EISA_ID_SIG) {
475 printk(KERN_ERR "%s: incorrect signature 0x%x\n",
476 dev->name, inw(ioaddr + DATA_PORT));
481 /* Fill in the 'dev' fields. */
482 dev->base_addr = ioaddr;
484 /* get the chip type */
485 rev_type = readreg(dev, PRODUCT_ID_ADD);
486 lp->chip_type = rev_type &~ REVISON_BITS;
487 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
489 /* Check the chip type and revision in order to set the correct send command
490 CS8920 revision C and CS8900 revision F can use the faster send. */
491 lp->send_cmd = TX_AFTER_381;
492 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
493 lp->send_cmd = TX_NOW;
494 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
495 lp->send_cmd = TX_NOW;
497 if (net_debug && version_printed++ == 0)
500 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#3lx ",
502 lp->chip_type==CS8900?'0':'2',
503 lp->chip_type==CS8920M?"M":"",
509 * Leave firmware settings alone, Beech does not currently provide
510 * a means of retrieving MAC address, etc. known only to f/w.
516 /* Here we read the current configuration of the chip. If there
517 is no Extended EEPROM then the idea is to not disturb the chip
518 configuration, it should have been correctly setup by automatic
519 EEPROM read on reset. So, if the chip says it read the EEPROM
520 the driver will always do *something* instead of complain that
523 #ifdef CONFIG_SH_HICOSH4
525 /* For the HiCO.SH4 board, things are different: we don't
526 have EEPROM, but there is some data in flash, so we go
527 get it there directly (MAC). */
530 if (((* (volatile __u32 *) 0xa0013ff0) & 0x00ffffff)
532 confd = (__u16*) 0xa0013fc0;
534 confd = (__u16*) 0xa001ffc0;
536 cnt = (*confd++ & 0x00ff) >> 1;
540 switch (j & 0x0fff) {
542 for (i = 0; i < ETH_ALEN/2; i++) {
543 dev->dev_addr[i*2] = confd[i] & 0xFF;
544 dev->dev_addr[i*2+1] = confd[i] >> 8;
555 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
556 (EEPROM_OK|EEPROM_PRESENT)) {
557 printk( "[Cirrus EEPROM] ");
560 /* HACK: Beech needs to do this configuration even though it
561 * doesn't have a Cirrus EEPROM */
567 for (i=0; i < ETH_ALEN/2; i++) {
569 Addr = readreg(dev, PP_IA+i*2);
570 dev->dev_addr[i*2] = Addr & 0xFF;
571 dev->dev_addr[i*2+1] = Addr >> 8;
574 /* Load the Adapter Configuration.
575 Note: Barring any more specific information from some
576 other source (ie EEPROM+Schematics), we would not know
577 how to operate a 10Base2 interface on the AUI port.
578 However, since we do read the status of HCB1 and use
579 settings that always result in calls to control_dc_dc(dev,0)
580 a BNC interface should work if the enable pin
581 (dc/dc converter) is on HCB1. It will be called AUI
585 i = readreg(dev, PP_LineCTL);
586 /* Preserve the setting of the HCB1 pin. */
587 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
588 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
589 /* Save the sqelch bit */
590 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
591 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
592 /* Check if the card is in 10Base-t only mode */
593 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
594 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
595 /* Check if the card is in AUI only mode */
596 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
597 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
598 /* Check if the card is in Auto mode. */
599 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
600 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
601 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
604 printk(KERN_INFO "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
605 dev->name, i, lp->adapter_cnf);
607 /* IRQ. Other chips already probe, see below. */
608 if (lp->chip_type == CS8900)
609 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
614 /* First check to see if an EEPROM is attached. */
615 #ifdef CONFIG_SH_HICOSH4 /* no EEPROM on HiCO, don't hazzle with it here */
617 printk(KERN_NOTICE "cs89x0: No EEPROM on HiCO.SH4\n");
620 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
621 printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....\n");
622 else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
623 printk(KERN_WARNING "\ncs89x0: EEPROM read failed, relying on command line.\n");
624 } else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
625 /* Check if the chip was able to read its own configuration starting
627 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
628 (EEPROM_OK|EEPROM_PRESENT))
629 printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
632 /* This reads an extended EEPROM that is not documented
633 in the CS8900 datasheet. */
635 /* get transmission control word but keep the autonegotiation bits */
636 if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];
637 /* Store adapter configuration */
638 if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];
639 /* Store ISA configuration */
640 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2];
641 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;
643 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */
644 /* store the initial memory base address */
645 for (i = 0; i < ETH_ALEN/2; i++) {
646 dev->dev_addr[i*2] = eeprom_buff[i];
647 dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8;
650 printk(KERN_DEBUG "%s: new adapter_cnf: 0x%x\n",
651 dev->name, lp->adapter_cnf);
654 /* allow them to force multiple transceivers. If they force multiple, autosense */
657 if (lp->force & FORCE_RJ45) {lp->adapter_cnf |= A_CNF_10B_T; count++; }
658 if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_AUI; count++; }
659 if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_10B_2; count++; }
660 if (count > 1) {lp->adapter_cnf |= A_CNF_MEDIA_AUTO; }
661 else if (lp->force & FORCE_RJ45){lp->adapter_cnf |= A_CNF_MEDIA_10B_T; }
662 else if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_MEDIA_AUI; }
663 else if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_MEDIA_10B_2; }
667 printk(KERN_DEBUG "%s: after force 0x%x, adapter_cnf=0x%x\n",
668 dev->name, lp->force, lp->adapter_cnf);
670 /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
672 /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
674 /* FIXME: we don't set the Ethernet address on the command line. Use
675 ifconfig IFACE hw ether AABBCCDDEEFF */
677 printk(KERN_INFO "cs89x0 media %s%s%s",
678 (lp->adapter_cnf & A_CNF_10B_T)?"RJ-45,":"",
679 (lp->adapter_cnf & A_CNF_AUI)?"AUI,":"",
680 (lp->adapter_cnf & A_CNF_10B_2)?"BNC,":"");
682 lp->irq_map = 0xffff;
684 /* If this is a CS8900 then no pnp soft */
685 if (lp->chip_type != CS8900 &&
686 /* Check if the ISA IRQ has been set */
687 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
688 (i != 0 && i < CS8920_NO_INTS))) {
692 i = lp->isa_config & INT_NO_MASK;
693 if (lp->chip_type == CS8900) {
694 /* Translate the IRQ using the IRQ mapping table. */
695 if (i >= sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]))
696 printk("\ncs89x0: invalid ISA interrupt number %d\n", i);
698 i = cs8900_irq_map[i];
700 lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
702 int irq_map_buff[IRQ_MAP_LEN/2];
704 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
706 irq_map_buff) >= 0) {
707 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
708 lp->irq_map = (irq_map_buff[0]>>8) | (irq_map_buff[1] << 8);
715 printk(" IRQ %d", dev->irq);
719 get_dma_channel(dev);
720 printk(", DMA %d", dev->dma);
725 printk(", programmed I/O");
728 /* print the ethernet address. */
730 for (i = 0; i < ETH_ALEN; i++)
732 printk("%c%02x", i ? ':' : ' ', dev->dev_addr[i]);
735 dev->open = net_open;
736 dev->stop = net_close;
737 dev->tx_timeout = net_timeout;
738 dev->watchdog_timeo = HZ;
739 dev->hard_start_xmit = net_send_packet;
740 dev->get_stats = net_get_stats;
741 dev->set_multicast_list = set_multicast_list;
742 dev->set_mac_address = set_mac_address;
744 /* Fill in the fields of the device structure with ethernet values. */
749 printk("cs89x0_probe1() successful\n");
752 release_region(ioaddr & ~3, NETCARD_IO_EXTENT);
761 /*********************************
762 * This page contains DMA routines
763 **********************************/
767 #define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
770 get_dma_channel(struct net_device *dev)
772 struct net_local *lp = (struct net_local *)dev->priv;
776 lp->isa_config |= ISA_RxDMA;
778 if ((lp->isa_config & ANY_ISA_DMA) == 0)
780 dev->dma = lp->isa_config & DMA_NO_MASK;
781 if (lp->chip_type == CS8900)
783 if (dev->dma < 5 || dev->dma > 7) {
784 lp->isa_config &= ~ANY_ISA_DMA;
792 write_dma(struct net_device *dev, int chip_type, int dma)
794 struct net_local *lp = (struct net_local *)dev->priv;
795 if ((lp->isa_config & ANY_ISA_DMA) == 0)
797 if (chip_type == CS8900) {
798 writereg(dev, PP_CS8900_ISADMA, dma-5);
800 writereg(dev, PP_CS8920_ISADMA, dma);
805 set_dma_cfg(struct net_device *dev)
807 struct net_local *lp = (struct net_local *)dev->priv;
810 if ((lp->isa_config & ANY_ISA_DMA) == 0) {
812 printk("set_dma_cfg(): no DMA\n");
815 if (lp->isa_config & ISA_RxDMA) {
816 lp->curr_rx_cfg |= RX_DMA_ONLY;
818 printk("set_dma_cfg(): RX_DMA_ONLY\n");
820 lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
822 printk("set_dma_cfg(): AUTO_RX_DMA\n");
828 dma_bufcfg(struct net_device *dev)
830 struct net_local *lp = (struct net_local *)dev->priv;
832 return (lp->isa_config & ANY_ISA_DMA)? RX_DMA_ENBL : 0;
838 dma_busctl(struct net_device *dev)
841 struct net_local *lp = (struct net_local *)dev->priv;
843 if (lp->isa_config & ANY_ISA_DMA)
844 retval |= RESET_RX_DMA; /* Reset the DMA pointer */
845 if (lp->isa_config & DMA_BURST)
846 retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
847 if (lp->dmasize == 64)
848 retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
849 retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
855 dma_rx(struct net_device *dev)
857 struct net_local *lp = (struct net_local *)dev->priv;
860 unsigned char *bp = lp->rx_dma_ptr;
862 status = bp[0] + (bp[1]<<8);
863 length = bp[2] + (bp[3]<<8);
866 printk( "%s: receiving DMA packet at %lx, status %x, length %x\n",
867 dev->name, (unsigned long)bp, status, length);
869 if ((status & RX_OK) == 0) {
870 count_rx_errors(status, lp);
871 goto skip_this_frame;
874 /* Malloc up new buffer. */
875 skb = dev_alloc_skb(length + 2);
877 if (net_debug) /* I don't think we want to do this to a stressed system */
878 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
879 lp->stats.rx_dropped++;
881 /* AKPM: advance bp to the next frame */
883 bp += (length + 3) & ~3;
884 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
888 skb_reserve(skb, 2); /* longword align L3 header */
891 if (bp + length > lp->end_dma_buff) {
892 int semi_cnt = lp->end_dma_buff - bp;
893 memcpy(skb_put(skb,semi_cnt), bp, semi_cnt);
894 memcpy(skb_put(skb,length - semi_cnt), lp->dma_buff,
897 memcpy(skb_put(skb,length), bp, length);
899 bp += (length + 3) & ~3;
900 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
904 printk( "%s: received %d byte DMA packet of type %x\n",
906 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
908 skb->protocol=eth_type_trans(skb,dev);
910 dev->last_rx = jiffies;
911 lp->stats.rx_packets++;
912 lp->stats.rx_bytes += length;
915 #endif /* ALLOW_DMA */
917 void __init reset_chip(struct net_device *dev)
919 struct net_local *lp = (struct net_local *)dev->priv;
920 int ioaddr = dev->base_addr;
921 int reset_start_time;
923 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
926 current->state = TASK_INTERRUPTIBLE;
927 schedule_timeout(30*HZ/1000);
929 if (lp->chip_type != CS8900) {
930 /* Hardware problem requires PNP registers to be reconfigured after a reset */
931 outw(PP_CS8920_ISAINT, ioaddr + ADD_PORT);
932 outb(dev->irq, ioaddr + DATA_PORT);
933 outb(0, ioaddr + DATA_PORT + 1);
935 outw(PP_CS8920_ISAMemB, ioaddr + ADD_PORT);
936 outb((dev->mem_start >> 16) & 0xff, ioaddr + DATA_PORT);
937 outb((dev->mem_start >> 8) & 0xff, ioaddr + DATA_PORT + 1);
939 /* Wait until the chip is reset */
940 reset_start_time = jiffies;
941 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
947 control_dc_dc(struct net_device *dev, int on_not_off)
949 struct net_local *lp = (struct net_local *)dev->priv;
950 unsigned int selfcontrol;
951 int timenow = jiffies;
952 /* control the DC to DC convertor in the SelfControl register.
953 Note: This is hooked up to a general purpose pin, might not
954 always be a DC to DC convertor. */
956 selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
957 if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
960 selfcontrol &= ~HCB1;
961 writereg(dev, PP_SelfCTL, selfcontrol);
963 /* Wait for the DC/DC converter to power up - 500ms */
964 while (jiffies - timenow < HZ)
968 #define DETECTED_NONE 0
969 #define DETECTED_RJ45H 1
970 #define DETECTED_RJ45F 2
971 #define DETECTED_AUI 3
972 #define DETECTED_BNC 4
975 detect_tp(struct net_device *dev)
977 struct net_local *lp = (struct net_local *)dev->priv;
978 int timenow = jiffies;
981 if (net_debug > 1) printk("%s: Attempting TP\n", dev->name);
983 /* If connected to another full duplex capable 10-Base-T card the link pulses
984 seem to be lost when the auto detect bit in the LineCTL is set.
985 To overcome this the auto detect bit will be cleared whilst testing the
986 10-Base-T interface. This would not be necessary for the sparrow chip but
987 is simpler to do it anyway. */
988 writereg(dev, PP_LineCTL, lp->linectl &~ AUI_ONLY);
989 control_dc_dc(dev, 0);
991 /* Delay for the hardware to work out if the TP cable is present - 150ms */
992 for (timenow = jiffies; jiffies - timenow < 15; )
994 if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
995 return DETECTED_NONE;
997 if (lp->chip_type == CS8900) {
998 switch (lp->force & 0xf0) {
1001 printk("%s: cs8900 doesn't autonegotiate\n",dev->name);
1002 return DETECTED_NONE;
1004 /* CS8900 doesn't support AUTO, change to HALF*/
1006 lp->force &= ~FORCE_AUTO;
1007 lp->force |= FORCE_HALF;
1012 writereg(dev, PP_TestCTL, readreg(dev, PP_TestCTL) | FDX_8900);
1015 fdx = readreg(dev, PP_TestCTL) & FDX_8900;
1017 switch (lp->force & 0xf0) {
1019 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1022 lp->auto_neg_cnf = 0;
1025 lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
1029 writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
1031 if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
1032 printk(KERN_INFO "%s: negotiating duplex...\n",dev->name);
1033 while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
1034 if (jiffies - timenow > 4000) {
1035 printk(KERN_ERR "**** Full / half duplex auto-negotiation timed out ****\n");
1040 fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
1043 return DETECTED_RJ45F;
1045 return DETECTED_RJ45H;
1048 /* send a test packet - return true if carrier bits are ok */
1050 send_test_pkt(struct net_device *dev)
1052 char test_packet[] = { 0,0,0,0,0,0, 0,0,0,0,0,0,
1053 0, 46, /* A 46 in network order */
1054 0, 0, /* DSAP=0 & SSAP=0 fields */
1055 0xf3, 0 /* Control (Test Req + P bit set) */ };
1056 long timenow = jiffies;
1058 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
1060 memcpy(test_packet, dev->dev_addr, ETH_ALEN);
1061 memcpy(test_packet+ETH_ALEN, dev->dev_addr, ETH_ALEN);
1063 writeword(dev, TX_CMD_PORT, TX_AFTER_ALL);
1064 writeword(dev, TX_LEN_PORT, ETH_ZLEN);
1066 /* Test to see if the chip has allocated memory for the packet */
1067 while (jiffies - timenow < 5)
1068 if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
1070 if (jiffies - timenow >= 5)
1071 return 0; /* this shouldn't happen */
1073 /* Write the contents of the packet */
1074 outsw(dev->base_addr + TX_FRAME_PORT,test_packet,(ETH_ZLEN+1) >>1);
1076 if (net_debug > 1) printk("Sending test packet ");
1077 /* wait a couple of jiffies for packet to be received */
1078 for (timenow = jiffies; jiffies - timenow < 3; )
1080 if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
1081 if (net_debug > 1) printk("succeeded\n");
1084 if (net_debug > 1) printk("failed\n");
1090 detect_aui(struct net_device *dev)
1092 struct net_local *lp = (struct net_local *)dev->priv;
1094 if (net_debug > 1) printk("%s: Attempting AUI\n", dev->name);
1095 control_dc_dc(dev, 0);
1097 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1099 if (send_test_pkt(dev))
1100 return DETECTED_AUI;
1102 return DETECTED_NONE;
1106 detect_bnc(struct net_device *dev)
1108 struct net_local *lp = (struct net_local *)dev->priv;
1110 if (net_debug > 1) printk("%s: Attempting BNC\n", dev->name);
1111 control_dc_dc(dev, 1);
1113 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1115 if (send_test_pkt(dev))
1116 return DETECTED_BNC;
1118 return DETECTED_NONE;
1123 write_irq(struct net_device *dev, int chip_type, int irq)
1127 if (chip_type == CS8900) {
1128 /* Search the mapping table for the corresponding IRQ pin. */
1129 for (i = 0; i != sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]); i++)
1130 if (cs8900_irq_map[i] == irq)
1133 if (i == sizeof(cs8900_irq_map)/sizeof(cs8900_irq_map[0]))
1135 writereg(dev, PP_CS8900_ISAINT, i);
1137 writereg(dev, PP_CS8920_ISAINT, irq);
1141 /* Open/initialize the board. This is called (in the current kernel)
1142 sometime after booting when the 'ifconfig' program is run.
1144 This routine should set everything up anew at each open, even
1145 registers that "should" only need to be set once at boot, so that
1146 there is non-reboot way to recover if something goes wrong.
1149 /* AKPM: do we need to do any locking here? */
1152 net_open(struct net_device *dev)
1154 struct net_local *lp = (struct net_local *)dev->priv;
1159 #ifndef CONFIG_SH_HICOSH4 /* uses irq#1, so this wont work */
1161 /* Allow interrupts to be generated by the chip */
1162 /* Cirrus' release had this: */
1164 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1166 /* And 2.3.47 had this: */
1167 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1169 for (i = 2; i < CS8920_NO_INTS; i++) {
1170 if ((1 << i) & lp->irq_map) {
1171 if (request_irq(i, net_interrupt, 0, dev->name, dev) == 0) {
1173 write_irq(dev, lp->chip_type, i);
1174 /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
1180 if (i >= CS8920_NO_INTS) {
1181 writereg(dev, PP_BusCTL, 0); /* disable interrupts. */
1182 printk(KERN_ERR "cs89x0: can't get an interrupt\n");
1190 if (((1 << dev->irq) & lp->irq_map) == 0) {
1191 printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
1192 dev->name, dev->irq, lp->irq_map);
1196 /* FIXME: Cirrus' release had this: */
1197 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1198 /* And 2.3.47 had this: */
1200 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1202 write_irq(dev, lp->chip_type, dev->irq);
1203 ret = request_irq(dev->irq, &net_interrupt, 0, dev->name, dev);
1206 printk(KERN_DEBUG "cs89x0: request_irq(%d) failed\n", dev->irq);
1213 if (lp->isa_config & ANY_ISA_DMA) {
1214 unsigned long flags;
1215 lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
1216 get_order(lp->dmasize * 1024));
1218 if (!lp->dma_buff) {
1219 printk(KERN_ERR "%s: cannot get %dK memory for DMA\n", dev->name, lp->dmasize);
1222 if (net_debug > 1) {
1223 printk( "%s: dma %lx %lx\n",
1225 (unsigned long)lp->dma_buff,
1226 (unsigned long)virt_to_bus(lp->dma_buff));
1228 if ((unsigned long) lp->dma_buff >= MAX_DMA_ADDRESS ||
1229 !dma_page_eq(lp->dma_buff, lp->dma_buff+lp->dmasize*1024-1)) {
1230 printk(KERN_ERR "%s: not usable as DMA buffer\n", dev->name);
1233 memset(lp->dma_buff, 0, lp->dmasize * 1024); /* Why? */
1234 if (request_dma(dev->dma, dev->name)) {
1235 printk(KERN_ERR "%s: cannot get dma channel %d\n", dev->name, dev->dma);
1238 write_dma(dev, lp->chip_type, dev->dma);
1239 lp->rx_dma_ptr = lp->dma_buff;
1240 lp->end_dma_buff = lp->dma_buff + lp->dmasize*1024;
1241 spin_lock_irqsave(&lp->lock, flags);
1242 disable_dma(dev->dma);
1243 clear_dma_ff(dev->dma);
1244 set_dma_mode(dev->dma, 0x14); /* auto_init as well */
1245 set_dma_addr(dev->dma, virt_to_bus(lp->dma_buff));
1246 set_dma_count(dev->dma, lp->dmasize*1024);
1247 enable_dma(dev->dma);
1248 spin_unlock_irqrestore(&lp->lock, flags);
1251 #endif /* ALLOW_DMA */
1253 /* set the Ethernet address */
1254 for (i=0; i < ETH_ALEN/2; i++)
1255 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1257 /* while we're testing the interface, leave interrupts disabled */
1258 writereg(dev, PP_BusCTL, MEMORY_ON);
1260 /* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
1261 if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) && (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
1262 lp->linectl = LOW_RX_SQUELCH;
1266 /* check to make sure that they have the "right" hardware available */
1267 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1268 case A_CNF_MEDIA_10B_T: result = lp->adapter_cnf & A_CNF_10B_T; break;
1269 case A_CNF_MEDIA_AUI: result = lp->adapter_cnf & A_CNF_AUI; break;
1270 case A_CNF_MEDIA_10B_2: result = lp->adapter_cnf & A_CNF_10B_2; break;
1271 default: result = lp->adapter_cnf & (A_CNF_10B_T | A_CNF_AUI | A_CNF_10B_2);
1274 printk(KERN_ERR "%s: EEPROM is configured for unavailable media\n", dev->name);
1277 release_dma_buff(lp);
1279 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
1280 free_irq(dev->irq, dev);
1285 /* set the hardware to the configured choice */
1286 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1287 case A_CNF_MEDIA_10B_T:
1288 result = detect_tp(dev);
1289 if (result==DETECTED_NONE) {
1290 printk(KERN_WARNING "%s: 10Base-T (RJ-45) has no cable\n", dev->name);
1291 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1292 result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
1295 case A_CNF_MEDIA_AUI:
1296 result = detect_aui(dev);
1297 if (result==DETECTED_NONE) {
1298 printk(KERN_WARNING "%s: 10Base-5 (AUI) has no cable\n", dev->name);
1299 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1300 result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
1303 case A_CNF_MEDIA_10B_2:
1304 result = detect_bnc(dev);
1305 if (result==DETECTED_NONE) {
1306 printk(KERN_WARNING "%s: 10Base-2 (BNC) has no cable\n", dev->name);
1307 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1308 result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
1311 case A_CNF_MEDIA_AUTO:
1312 writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
1313 if (lp->adapter_cnf & A_CNF_10B_T)
1314 if ((result = detect_tp(dev)) != DETECTED_NONE)
1316 if (lp->adapter_cnf & A_CNF_AUI)
1317 if ((result = detect_aui(dev)) != DETECTED_NONE)
1319 if (lp->adapter_cnf & A_CNF_10B_2)
1320 if ((result = detect_bnc(dev)) != DETECTED_NONE)
1322 printk(KERN_ERR "%s: no media detected\n", dev->name);
1327 printk(KERN_ERR "%s: no network cable attached to configured media\n", dev->name);
1329 case DETECTED_RJ45H:
1330 printk(KERN_INFO "%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
1332 case DETECTED_RJ45F:
1333 printk(KERN_INFO "%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
1336 printk(KERN_INFO "%s: using 10Base-5 (AUI)\n", dev->name);
1339 printk(KERN_INFO "%s: using 10Base-2 (BNC)\n", dev->name);
1343 /* Turn on both receive and transmit operations */
1344 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1346 /* Receive only error free packets addressed to this card */
1348 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
1350 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
1352 if (lp->isa_config & STREAM_TRANSFER)
1353 lp->curr_rx_cfg |= RX_STREAM_ENBL;
1357 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
1359 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
1360 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
1362 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
1366 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
1368 /* now that we've got our act together, enable everything */
1369 writereg(dev, PP_BusCTL, ENABLE_IRQ
1370 | (dev->mem_start?MEMORY_ON : 0) /* turn memory on */
1375 netif_start_queue(dev);
1377 printk("cs89x0: net_open() succeeded\n");
1383 static void net_timeout(struct net_device *dev)
1385 /* If we get here, some higher level has decided we are broken.
1386 There should really be a "kick me" function call instead. */
1387 if (net_debug > 0) printk("%s: transmit timed out, %s?\n", dev->name,
1388 tx_done(dev) ? "IRQ conflict ?" : "network cable problem");
1389 /* Try to restart the adaptor. */
1390 netif_wake_queue(dev);
1393 static int net_send_packet(struct sk_buff *skb, struct net_device *dev)
1395 struct net_local *lp = (struct net_local *)dev->priv;
1397 if (net_debug > 3) {
1398 printk("%s: sent %d byte packet of type %x\n",
1399 dev->name, skb->len,
1400 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1403 /* keep the upload from being interrupted, since we
1404 ask the chip to start transmitting before the
1405 whole packet has been completely uploaded. */
1407 spin_lock_irq(&lp->lock);
1408 netif_stop_queue(dev);
1410 /* initiate a transmit sequence */
1411 writeword(dev, TX_CMD_PORT, lp->send_cmd);
1412 writeword(dev, TX_LEN_PORT, skb->len);
1414 /* Test to see if the chip has allocated memory for the packet */
1415 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1417 * Gasp! It hasn't. But that shouldn't happen since
1418 * we're waiting for TxOk, so return 1 and requeue this packet.
1421 spin_unlock_irq(&lp->lock);
1422 if (net_debug) printk("cs89x0: Tx buffer not free!\n");
1425 /* Write the contents of the packet */
1426 outsw(dev->base_addr + TX_FRAME_PORT,skb->data,(skb->len+1) >>1);
1427 spin_unlock_irq(&lp->lock);
1428 dev->trans_start = jiffies;
1429 dev_kfree_skb (skb);
1432 * We DO NOT call netif_wake_queue() here.
1433 * We also DO NOT call netif_start_queue().
1435 * Either of these would cause another bottom half run through
1436 * net_send_packet() before this packet has fully gone out. That causes
1437 * us to hit the "Gasp!" above and the send is rescheduled. it runs like
1438 * a dog. We just return and wait for the Tx completion interrupt handler
1439 * to restart the netdevice layer
1445 /* The typical workload of the driver:
1446 Handle the network interface interrupts. */
1448 static void net_interrupt(int irq, void *dev_id, struct pt_regs * regs)
1450 struct net_device *dev = dev_id;
1451 struct net_local *lp;
1454 ioaddr = dev->base_addr;
1455 lp = (struct net_local *)dev->priv;
1457 /* we MUST read all the events out of the ISQ, otherwise we'll never
1458 get interrupted again. As a consequence, we can't have any limit
1459 on the number of times we loop in the interrupt handler. The
1460 hardware guarantees that eventually we'll run out of events. Of
1461 course, if you're on a slow machine, and packets are arriving
1462 faster than you can read them off, you're screwed. Hasta la
1464 while ((status = readword(dev, ISQ_PORT))) {
1465 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
1466 switch(status & ISQ_EVENT_MASK) {
1467 case ISQ_RECEIVER_EVENT:
1468 /* Got a packet(s). */
1471 case ISQ_TRANSMITTER_EVENT:
1472 lp->stats.tx_packets++;
1473 netif_wake_queue(dev); /* Inform upper layers. */
1474 if ((status & ( TX_OK |
1478 TX_16_COL)) != TX_OK) {
1479 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
1480 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
1481 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
1482 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
1483 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
1486 case ISQ_BUFFER_EVENT:
1487 if (status & READY_FOR_TX) {
1488 /* we tried to transmit a packet earlier,
1489 but inexplicably ran out of buffers.
1490 That shouldn't happen since we only ever
1491 load one packet. Shrug. Do the right
1493 netif_wake_queue(dev); /* Inform upper layers. */
1495 if (status & TX_UNDERRUN) {
1496 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
1497 lp->send_underrun++;
1498 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
1499 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
1500 /* transmit cycle is done, although
1501 frame wasn't transmitted - this
1502 avoids having to wait for the upper
1503 layers to timeout on us, in the
1504 event of a tx underrun */
1505 netif_wake_queue(dev); /* Inform upper layers. */
1508 if (lp->use_dma && (status & RX_DMA)) {
1509 int count = readreg(dev, PP_DmaFrameCnt);
1512 printk("%s: receiving %d DMA frames\n", dev->name, count);
1513 if (net_debug > 2 && count >1)
1514 printk("%s: receiving %d DMA frames\n", dev->name, count);
1517 count = readreg(dev, PP_DmaFrameCnt);
1518 if (net_debug > 2 && count > 0)
1519 printk("%s: continuing with %d DMA frames\n", dev->name, count);
1524 case ISQ_RX_MISS_EVENT:
1525 lp->stats.rx_missed_errors += (status >>6);
1527 case ISQ_TX_COL_EVENT:
1528 lp->stats.collisions += (status >>6);
1535 count_rx_errors(int status, struct net_local *lp)
1537 lp->stats.rx_errors++;
1538 if (status & RX_RUNT) lp->stats.rx_length_errors++;
1539 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
1540 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
1542 lp->stats.rx_crc_errors++;
1543 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
1547 /* We have a good packet(s), get it/them out of the buffers. */
1549 net_rx(struct net_device *dev)
1551 struct net_local *lp = (struct net_local *)dev->priv;
1552 struct sk_buff *skb;
1555 int ioaddr = dev->base_addr;
1556 status = inw(ioaddr + RX_FRAME_PORT);
1557 length = inw(ioaddr + RX_FRAME_PORT);
1559 if ((status & RX_OK) == 0) {
1560 count_rx_errors(status, lp);
1564 /* Malloc up new buffer. */
1565 skb = dev_alloc_skb(length + 2);
1567 #if 0 /* Again, this seems a cruel thing to do */
1568 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1570 lp->stats.rx_dropped++;
1573 skb_reserve(skb, 2); /* longword align L3 header */
1576 insw(ioaddr + RX_FRAME_PORT, skb_put(skb, length), length >> 1);
1578 skb->data[length-1] = inw(ioaddr + RX_FRAME_PORT);
1580 if (net_debug > 3) {
1581 printk( "%s: received %d byte packet of type %x\n",
1583 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1586 skb->protocol=eth_type_trans(skb,dev);
1588 dev->last_rx = jiffies;
1589 lp->stats.rx_packets++;
1590 lp->stats.rx_bytes += length;
1594 static void release_dma_buff(struct net_local *lp)
1597 free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024));
1603 /* The inverse routine to net_open(). */
1605 net_close(struct net_device *dev)
1607 struct net_local *lp = (struct net_local *)dev->priv;
1609 netif_stop_queue(dev);
1611 writereg(dev, PP_RxCFG, 0);
1612 writereg(dev, PP_TxCFG, 0);
1613 writereg(dev, PP_BufCFG, 0);
1614 writereg(dev, PP_BusCTL, 0);
1616 free_irq(dev->irq, dev);
1619 if (lp->use_dma && lp->dma) {
1621 release_dma_buff(lp);
1625 /* Update the statistics here. */
1629 /* Get the current statistics. This may be called with the card open or
1631 static struct net_device_stats *
1632 net_get_stats(struct net_device *dev)
1634 struct net_local *lp = (struct net_local *)dev->priv;
1635 unsigned long flags;
1637 spin_lock_irqsave(&lp->lock, flags);
1638 /* Update the statistics from the device registers. */
1639 lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1640 lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1641 spin_unlock_irqrestore(&lp->lock, flags);
1646 static void set_multicast_list(struct net_device *dev)
1648 struct net_local *lp = (struct net_local *)dev->priv;
1649 unsigned long flags;
1651 spin_lock_irqsave(&lp->lock, flags);
1652 if(dev->flags&IFF_PROMISC)
1654 lp->rx_mode = RX_ALL_ACCEPT;
1656 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
1658 /* The multicast-accept list is initialized to accept-all, and we
1659 rely on higher-level filtering for now. */
1660 lp->rx_mode = RX_MULTCAST_ACCEPT;
1665 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1667 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
1668 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
1669 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
1670 spin_unlock_irqrestore(&lp->lock, flags);
1674 static int set_mac_address(struct net_device *dev, void *addr)
1678 if (netif_running(dev))
1681 printk("%s: Setting MAC address to ", dev->name);
1682 for (i = 0; i < 6; i++)
1683 printk(" %2.2x", dev->dev_addr[i] = ((unsigned char *)addr)[i]);
1686 /* set the Ethernet address */
1687 for (i=0; i < ETH_ALEN/2; i++)
1688 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1695 static struct net_device dev_cs89x0 = {
1699 0, 0, 0, NULL, NULL };
1702 * Support the 'debug' module parm even if we're compiled for non-debug to
1703 * avoid breaking someone's startup scripts
1709 static char media[8];
1710 static int duplex=-1;
1712 static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
1714 static int dmasize=16; /* or 64 */
1716 MODULE_PARM(io, "i");
1717 MODULE_PARM(irq, "i");
1718 MODULE_PARM(debug, "i");
1719 MODULE_PARM(media, "c8");
1720 MODULE_PARM(duplex, "i");
1721 MODULE_PARM(dma , "i");
1722 MODULE_PARM(dmasize , "i");
1723 MODULE_PARM(use_dma , "i");
1724 MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1725 MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1727 MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1729 MODULE_PARM_DESC(debug, "(ignored)");
1731 MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1732 /* No other value than -1 for duplex seems to be currently interpreted */
1733 MODULE_PARM_DESC(duplex, "(ignored)");
1735 MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1736 MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1737 MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1739 MODULE_PARM_DESC(dma , "(ignored)");
1740 MODULE_PARM_DESC(dmasize , "(ignored)");
1741 MODULE_PARM_DESC(use_dma , "(ignored)");
1744 MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton <andrewm@uow.edu.au>");
1745 MODULE_LICENSE("GPL");
1751 * media=t - specify media type
1755 * duplex=0 - specify forced half/full/autonegotiate duplex
1756 * debug=# - debug level
1759 * Default Chip Configuration:
1760 * DMA Burst = enabled
1761 * IOCHRDY Enabled = enabled
1763 * CS8900 defaults to half-duplex if not specified on command-line
1764 * CS8920 defaults to autoneg if not specified on command-line
1765 * Use reset defaults for other config parameters
1768 * media type specified is supported (circuitry is present)
1769 * if memory address is > 1MB, then required mem decode hw is present
1770 * if 10B-2, then agent other than driver will enable DC/DC converter
1771 (hw or software util)
1779 struct net_local *lp;
1788 dev_cs89x0.irq = irq;
1789 dev_cs89x0.base_addr = io;
1791 dev_cs89x0.init = cs89x0_probe;
1792 dev_cs89x0.priv = kmalloc(sizeof(struct net_local), GFP_KERNEL);
1793 if (dev_cs89x0.priv == 0) {
1794 printk(KERN_ERR "cs89x0.c: Out of memory.\n");
1797 memset(dev_cs89x0.priv, 0, sizeof(struct net_local));
1798 lp = (struct net_local *)dev_cs89x0.priv;
1802 lp->use_dma = use_dma;
1804 lp->dmasize = dmasize;
1808 spin_lock_init(&lp->lock);
1810 /* boy, they'd better get these right */
1811 if (!strcmp(media, "rj45"))
1812 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1813 else if (!strcmp(media, "aui"))
1814 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1815 else if (!strcmp(media, "bnc"))
1816 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1818 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1821 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1824 printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n");
1825 printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n");
1831 if (use_dma && dmasize != 16 && dmasize != 64) {
1832 printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize);
1838 if (register_netdev(&dev_cs89x0) != 0) {
1839 printk(KERN_ERR "cs89x0.c: No card found at 0x%x\n", io);
1845 kfree(dev_cs89x0.priv);
1850 cleanup_module(void)
1852 if (dev_cs89x0.priv != NULL) {
1853 /* Free up the private structure, or leak memory :-) */
1854 unregister_netdev(&dev_cs89x0);
1855 outw(PP_ChipID, dev_cs89x0.base_addr + ADD_PORT);
1856 kfree(dev_cs89x0.priv);
1857 dev_cs89x0.priv = NULL; /* gets re-allocated by cs89x0_probe1 */
1858 /* If we don't do this, we can't re-insmod it later. */
1859 release_region(dev_cs89x0.base_addr, NETCARD_IO_EXTENT);
1866 * version-control: t
1867 * kept-new-versions: 5