?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove all #inclusions of asm/system.h
[linux-2.6.git] / drivers / net / ethernet / cirrus / cs89x0.c
blob98c171b3a45e4d1723cc9b2892e2ab5367c45f1f
1 /* cs89x0.c: A Crystal Semiconductor (Now Cirrus Logic) CS89[02]0
2 * driver for linux.
3 */
4
5 /*
6 Written 1996 by Russell Nelson, with reference to skeleton.c
7 written 1993-1994 by Donald Becker.
8
9 This software may be used and distributed according to the terms
10 of the GNU General Public License, incorporated herein by reference.
11
12 The author may be reached at nelson@crynwr.com, Crynwr
13 Software, 521 Pleasant Valley Rd., Potsdam, NY 13676
14
15 Changelog:
16
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.
21
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
25 : driver prematurely.
26
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.
31
32 Russ Nelson : Jul 13 1998. Added RxOnly DMA support.
33
34 Melody Lee : Aug 10 1999. Changes for Linux 2.2.5 compatibility.
35 : email: ethernet@crystal.cirrus.com
36
37 Alan Cox : Removed 1.2 support, added 2.1 extra counters.
38
39 Andrew Morton : Kernel 2.3.48
40 : Handle kmalloc() failures
41 : Other resource allocation fixes
42 : Add SMP locks
43 : Integrate Russ Nelson's ALLOW_DMA functionality back in.
44 : If ALLOW_DMA is true, make DMA runtime selectable
45 : Folded in changes from Cirrus (Melody Lee
46 : <klee@crystal.cirrus.com>)
47 : Don't call netif_wake_queue() in net_send_packet()
48 : Fixed an out-of-mem bug in dma_rx()
49 : Updated Documentation/networking/cs89x0.txt
50
51 Andrew Morton : Kernel 2.3.99-pre1
52 : Use skb_reserve to longword align IP header (two places)
53 : Remove a delay loop from dma_rx()
54 : Replace '100' with HZ
55 : Clean up a couple of skb API abuses
56 : Added 'cs89x0_dma=N' kernel boot option
57 : Correctly initialise lp->lock in non-module compile
58
59 Andrew Morton : Kernel 2.3.99-pre4-1
60 : MOD_INC/DEC race fix (see
61 : http://www.uwsg.indiana.edu/hypermail/linux/kernel/0003.3/1532.html)
62
63 Andrew Morton : Kernel 2.4.0-test7-pre2
64 : Enhanced EEPROM support to cover more devices,
65 : abstracted IRQ mapping to support CONFIG_ARCH_CLPS7500 arch
66 : (Jason Gunthorpe <jgg@ualberta.ca>)
67
68 Andrew Morton : Kernel 2.4.0-test11-pre4
69 : Use dev->name in request_*() (Andrey Panin)
70 : Fix an error-path memleak in init_module()
71 : Preserve return value from request_irq()
72 : Fix type of `media' module parm (Keith Owens)
73 : Use SET_MODULE_OWNER()
74 : Tidied up strange request_irq() abuse in net_open().
75
76 Andrew Morton : Kernel 2.4.3-pre1
77 : Request correct number of pages for DMA (Hugh Dickens)
78 : Select PP_ChipID _after_ unregister_netdev in cleanup_module()
79 : because unregister_netdev() calls get_stats.
80 : Make `version[]' __initdata
81 : Uninlined the read/write reg/word functions.
82
83 Oskar Schirmer : oskar@scara.com
84 : HiCO.SH4 (superh) support added (irq#1, cs89x0_media=)
85
86 Deepak Saxena : dsaxena@plexity.net
87 : Intel IXDP2x01 (XScale ixp2x00 NPU) platform support
88
89 Dmitry Pervushin : dpervushin@ru.mvista.com
90 : PNX010X platform support
91
92 Deepak Saxena : dsaxena@plexity.net
93 : Intel IXDP2351 platform support
94
95 Dmitry Pervushin : dpervushin@ru.mvista.com
96 : PNX010X platform support
97
98 Domenico Andreoli : cavokz@gmail.com
99 : QQ2440 platform support
100
101 */
102
103 /* Always include 'config.h' first in case the user wants to turn on
104 or override something. */
105 #include <linux/module.h>
106
107 /*
108 * Set this to zero to disable DMA code
109 *
110 * Note that even if DMA is turned off we still support the 'dma' and 'use_dma'
111 * module options so we don't break any startup scripts.
112 */
113 #ifndef CONFIG_ISA_DMA_API
114 #define ALLOW_DMA 0
115 #else
116 #define ALLOW_DMA 1
117 #endif
118
119 /*
120 * Set this to zero to remove all the debug statements via
121 * dead code elimination
122 */
123 #define DEBUGGING 1
124
125 /*
126 Sources:
127
128 Crynwr packet driver epktisa.
129
130 Crystal Semiconductor data sheets.
131
132 */
133
134 #include <linux/errno.h>
135 #include <linux/netdevice.h>
136 #include <linux/etherdevice.h>
137 #include <linux/kernel.h>
138 #include <linux/types.h>
139 #include <linux/fcntl.h>
140 #include <linux/interrupt.h>
141 #include <linux/ioport.h>
142 #include <linux/in.h>
143 #include <linux/skbuff.h>
144 #include <linux/spinlock.h>
145 #include <linux/string.h>
146 #include <linux/init.h>
147 #include <linux/bitops.h>
148 #include <linux/delay.h>
149 #include <linux/gfp.h>
150
151 #include <asm/io.h>
152 #include <asm/irq.h>
153 #if ALLOW_DMA
154 #include <asm/dma.h>
155 #endif
156
157 #include "cs89x0.h"
158
159 static char version[] __initdata =
160 "cs89x0.c: v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton\n";
161
162 #define DRV_NAME "cs89x0"
163
164 /* First, a few definitions that the brave might change.
165 A zero-terminated list of I/O addresses to be probed. Some special flags..
166 Addr & 1 = Read back the address port, look for signature and reset
167 the page window before probing
168 Addr & 3 = Reset the page window and probe
169 The CLPS eval board has the Cirrus chip at 0x80090300, in ARM IO space,
170 but it is possible that a Cirrus board could be plugged into the ISA
171 slots. */
172 /* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
173 them to system IRQ numbers. This mapping is card specific and is set to
174 the configuration of the Cirrus Eval board for this chip. */
175 #if defined(CONFIG_MACH_IXDP2351)
176 static unsigned int netcard_portlist[] __used __initdata = {IXDP2351_VIRT_CS8900_BASE, 0};
177 static unsigned int cs8900_irq_map[] = {IRQ_IXDP2351_CS8900, 0, 0, 0};
178 #elif defined(CONFIG_ARCH_IXDP2X01)
179 static unsigned int netcard_portlist[] __used __initdata = {IXDP2X01_CS8900_VIRT_BASE, 0};
180 static unsigned int cs8900_irq_map[] = {IRQ_IXDP2X01_CS8900, 0, 0, 0};
181 #elif defined(CONFIG_MACH_QQ2440)
182 #include <mach/qq2440.h>
183 static unsigned int netcard_portlist[] __used __initdata = { QQ2440_CS8900_VIRT_BASE + 0x300, 0 };
184 static unsigned int cs8900_irq_map[] = { QQ2440_CS8900_IRQ, 0, 0, 0 };
185 #elif defined(CONFIG_MACH_MX31ADS)
186 #include <mach/board-mx31ads.h>
187 static unsigned int netcard_portlist[] __used __initdata = {
188 PBC_BASE_ADDRESS + PBC_CS8900A_IOBASE + 0x300, 0
189 };
190 static unsigned cs8900_irq_map[] = {EXPIO_INT_ENET_INT, 0, 0, 0};
191 #else
192 static unsigned int netcard_portlist[] __used __initdata =
193 { 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
194 static unsigned int cs8900_irq_map[] = {10,11,12,5};
195 #endif
196
197 #if DEBUGGING
198 static unsigned int net_debug = DEBUGGING;
199 #else
200 #define net_debug 0 /* gcc will remove all the debug code for us */
201 #endif
202
203 /* The number of low I/O ports used by the ethercard. */
204 #define NETCARD_IO_EXTENT 16
205
206 /* we allow the user to override various values normally set in the EEPROM */
207 #define FORCE_RJ45 0x0001 /* pick one of these three */
208 #define FORCE_AUI 0x0002
209 #define FORCE_BNC 0x0004
210
211 #define FORCE_AUTO 0x0010 /* pick one of these three */
212 #define FORCE_HALF 0x0020
213 #define FORCE_FULL 0x0030
214
215 /* Information that need to be kept for each board. */
216 struct net_local {
217 int chip_type; /* one of: CS8900, CS8920, CS8920M */
218 char chip_revision; /* revision letter of the chip ('A'...) */
219 int send_cmd; /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
220 int auto_neg_cnf; /* auto-negotiation word from EEPROM */
221 int adapter_cnf; /* adapter configuration from EEPROM */
222 int isa_config; /* ISA configuration from EEPROM */
223 int irq_map; /* IRQ map from EEPROM */
224 int rx_mode; /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
225 int curr_rx_cfg; /* a copy of PP_RxCFG */
226 int linectl; /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
227 int send_underrun; /* keep track of how many underruns in a row we get */
228 int force; /* force various values; see FORCE* above. */
229 spinlock_t lock;
230 #if ALLOW_DMA
231 int use_dma; /* Flag: we're using dma */
232 int dma; /* DMA channel */
233 int dmasize; /* 16 or 64 */
234 unsigned char *dma_buff; /* points to the beginning of the buffer */
235 unsigned char *end_dma_buff; /* points to the end of the buffer */
236 unsigned char *rx_dma_ptr; /* points to the next packet */
237 #endif
238 };
239
240 /* Index to functions, as function prototypes. */
241
242 static int cs89x0_probe1(struct net_device *dev, int ioaddr, int modular);
243 static int net_open(struct net_device *dev);
244 static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev);
245 static irqreturn_t net_interrupt(int irq, void *dev_id);
246 static void set_multicast_list(struct net_device *dev);
247 static void net_timeout(struct net_device *dev);
248 static void net_rx(struct net_device *dev);
249 static int net_close(struct net_device *dev);
250 static struct net_device_stats *net_get_stats(struct net_device *dev);
251 static void reset_chip(struct net_device *dev);
252 static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer);
253 static int get_eeprom_cksum(int off, int len, int *buffer);
254 static int set_mac_address(struct net_device *dev, void *addr);
255 static void count_rx_errors(int status, struct net_device *dev);
256 #ifdef CONFIG_NET_POLL_CONTROLLER
257 static void net_poll_controller(struct net_device *dev);
258 #endif
259 #if ALLOW_DMA
260 static void get_dma_channel(struct net_device *dev);
261 static void release_dma_buff(struct net_local *lp);
262 #endif
263
264 /* Example routines you must write ;->. */
265 #define tx_done(dev) 1
266
267 /*
268 * Permit 'cs89x0_dma=N' in the kernel boot environment
269 */
270 #if !defined(MODULE) && (ALLOW_DMA != 0)
271 static int g_cs89x0_dma;
272
273 static int __init dma_fn(char *str)
274 {
275 g_cs89x0_dma = simple_strtol(str,NULL,0);
276 return 1;
277 }
278
279 __setup("cs89x0_dma=", dma_fn);
280 #endif /* !defined(MODULE) && (ALLOW_DMA != 0) */
281
282 #ifndef MODULE
283 static int g_cs89x0_media__force;
284
285 static int __init media_fn(char *str)
286 {
287 if (!strcmp(str, "rj45")) g_cs89x0_media__force = FORCE_RJ45;
288 else if (!strcmp(str, "aui")) g_cs89x0_media__force = FORCE_AUI;
289 else if (!strcmp(str, "bnc")) g_cs89x0_media__force = FORCE_BNC;
290 return 1;
291 }
292
293 __setup("cs89x0_media=", media_fn);
294
295
296 /* Check for a network adaptor of this type, and return '0' iff one exists.
297 If dev->base_addr == 0, probe all likely locations.
298 If dev->base_addr == 1, always return failure.
299 If dev->base_addr == 2, allocate space for the device and return success
300 (detachable devices only).
301 Return 0 on success.
302 */
303
304 struct net_device * __init cs89x0_probe(int unit)
305 {
306 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
307 unsigned *port;
308 int err = 0;
309 int irq;
310 int io;
311
312 if (!dev)
313 return ERR_PTR(-ENODEV);
314
315 sprintf(dev->name, "eth%d", unit);
316 netdev_boot_setup_check(dev);
317 io = dev->base_addr;
318 irq = dev->irq;
319
320 if (net_debug)
321 printk("cs89x0:cs89x0_probe(0x%x)\n", io);
322
323 if (io > 0x1ff) { /* Check a single specified location. */
324 err = cs89x0_probe1(dev, io, 0);
325 } else if (io != 0) { /* Don't probe at all. */
326 err = -ENXIO;
327 } else {
328 for (port = netcard_portlist; *port; port++) {
329 if (cs89x0_probe1(dev, *port, 0) == 0)
330 break;
331 dev->irq = irq;
332 }
333 if (!*port)
334 err = -ENODEV;
335 }
336 if (err)
337 goto out;
338 return dev;
339 out:
340 free_netdev(dev);
341 printk(KERN_WARNING "cs89x0: no cs8900 or cs8920 detected. Be sure to disable PnP with SETUP\n");
342 return ERR_PTR(err);
343 }
344 #endif
345
346 #if defined(CONFIG_MACH_IXDP2351)
347 static u16
348 readword(unsigned long base_addr, int portno)
349 {
350 return __raw_readw(base_addr + (portno << 1));
351 }
352
353 static void
354 writeword(unsigned long base_addr, int portno, u16 value)
355 {
356 __raw_writew(value, base_addr + (portno << 1));
357 }
358 #elif defined(CONFIG_ARCH_IXDP2X01)
359 static u16
360 readword(unsigned long base_addr, int portno)
361 {
362 return __raw_readl(base_addr + (portno << 1));
363 }
364
365 static void
366 writeword(unsigned long base_addr, int portno, u16 value)
367 {
368 __raw_writel(value, base_addr + (portno << 1));
369 }
370 #else
371 static u16
372 readword(unsigned long base_addr, int portno)
373 {
374 return inw(base_addr + portno);
375 }
376
377 static void
378 writeword(unsigned long base_addr, int portno, u16 value)
379 {
380 outw(value, base_addr + portno);
381 }
382 #endif
383
384 static void
385 readwords(unsigned long base_addr, int portno, void *buf, int length)
386 {
387 u8 *buf8 = (u8 *)buf;
388
389 do {
390 u16 tmp16;
391
392 tmp16 = readword(base_addr, portno);
393 *buf8++ = (u8)tmp16;
394 *buf8++ = (u8)(tmp16 >> 8);
395 } while (--length);
396 }
397
398 static void
399 writewords(unsigned long base_addr, int portno, void *buf, int length)
400 {
401 u8 *buf8 = (u8 *)buf;
402
403 do {
404 u16 tmp16;
405
406 tmp16 = *buf8++;
407 tmp16 |= (*buf8++) << 8;
408 writeword(base_addr, portno, tmp16);
409 } while (--length);
410 }
411
412 static u16
413 readreg(struct net_device *dev, u16 regno)
414 {
415 writeword(dev->base_addr, ADD_PORT, regno);
416 return readword(dev->base_addr, DATA_PORT);
417 }
418
419 static void
420 writereg(struct net_device *dev, u16 regno, u16 value)
421 {
422 writeword(dev->base_addr, ADD_PORT, regno);
423 writeword(dev->base_addr, DATA_PORT, value);
424 }
425
426 static int __init
427 wait_eeprom_ready(struct net_device *dev)
428 {
429 int timeout = jiffies;
430 /* check to see if the EEPROM is ready, a timeout is used -
431 just in case EEPROM is ready when SI_BUSY in the
432 PP_SelfST is clear */
433 while(readreg(dev, PP_SelfST) & SI_BUSY)
434 if (jiffies - timeout >= 40)
435 return -1;
436 return 0;
437 }
438
439 static int __init
440 get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
441 {
442 int i;
443
444 if (net_debug > 3) printk("EEPROM data from %x for %x:\n",off,len);
445 for (i = 0; i < len; i++) {
446 if (wait_eeprom_ready(dev) < 0) return -1;
447 /* Now send the EEPROM read command and EEPROM location to read */
448 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
449 if (wait_eeprom_ready(dev) < 0) return -1;
450 buffer[i] = readreg(dev, PP_EEData);
451 if (net_debug > 3) printk("%04x ", buffer[i]);
452 }
453 if (net_debug > 3) printk("\n");
454 return 0;
455 }
456
457 static int __init
458 get_eeprom_cksum(int off, int len, int *buffer)
459 {
460 int i, cksum;
461
462 cksum = 0;
463 for (i = 0; i < len; i++)
464 cksum += buffer[i];
465 cksum &= 0xffff;
466 if (cksum == 0)
467 return 0;
468 return -1;
469 }
470
471 #ifdef CONFIG_NET_POLL_CONTROLLER
472 /*
473 * Polling receive - used by netconsole and other diagnostic tools
474 * to allow network i/o with interrupts disabled.
475 */
476 static void net_poll_controller(struct net_device *dev)
477 {
478 disable_irq(dev->irq);
479 net_interrupt(dev->irq, dev);
480 enable_irq(dev->irq);
481 }
482 #endif
483
484 static const struct net_device_ops net_ops = {
485 .ndo_open = net_open,
486 .ndo_stop = net_close,
487 .ndo_tx_timeout = net_timeout,
488 .ndo_start_xmit = net_send_packet,
489 .ndo_get_stats = net_get_stats,
490 .ndo_set_rx_mode = set_multicast_list,
491 .ndo_set_mac_address = set_mac_address,
492 #ifdef CONFIG_NET_POLL_CONTROLLER
493 .ndo_poll_controller = net_poll_controller,
494 #endif
495 .ndo_change_mtu = eth_change_mtu,
496 .ndo_validate_addr = eth_validate_addr,
497 };
498
499 /* This is the real probe routine. Linux has a history of friendly device
500 probes on the ISA bus. A good device probes avoids doing writes, and
501 verifies that the correct device exists and functions.
502 Return 0 on success.
503 */
504
505 static int __init
506 cs89x0_probe1(struct net_device *dev, int ioaddr, int modular)
507 {
508 struct net_local *lp = netdev_priv(dev);
509 static unsigned version_printed;
510 int i;
511 int tmp;
512 unsigned rev_type = 0;
513 int eeprom_buff[CHKSUM_LEN];
514 int retval;
515
516 /* Initialize the device structure. */
517 if (!modular) {
518 memset(lp, 0, sizeof(*lp));
519 spin_lock_init(&lp->lock);
520 #ifndef MODULE
521 #if ALLOW_DMA
522 if (g_cs89x0_dma) {
523 lp->use_dma = 1;
524 lp->dma = g_cs89x0_dma;
525 lp->dmasize = 16; /* Could make this an option... */
526 }
527 #endif
528 lp->force = g_cs89x0_media__force;
529 #endif
530
531 #if defined(CONFIG_MACH_QQ2440)
532 lp->force |= FORCE_RJ45 | FORCE_FULL;
533 #endif
534 }
535
536 /* Grab the region so we can find another board if autoIRQ fails. */
537 /* WTF is going on here? */
538 if (!request_region(ioaddr & ~3, NETCARD_IO_EXTENT, DRV_NAME)) {
539 printk(KERN_ERR "%s: request_region(0x%x, 0x%x) failed\n",
540 DRV_NAME, ioaddr, NETCARD_IO_EXTENT);
541 retval = -EBUSY;
542 goto out1;
543 }
544
545 /* if they give us an odd I/O address, then do ONE write to
546 the address port, to get it back to address zero, where we
547 expect to find the EISA signature word. An IO with a base of 0x3
548 will skip the test for the ADD_PORT. */
549 if (ioaddr & 1) {
550 if (net_debug > 1)
551 printk(KERN_INFO "%s: odd ioaddr 0x%x\n", dev->name, ioaddr);
552 if ((ioaddr & 2) != 2)
553 if ((readword(ioaddr & ~3, ADD_PORT) & ADD_MASK) != ADD_SIG) {
554 printk(KERN_ERR "%s: bad signature 0x%x\n",
555 dev->name, readword(ioaddr & ~3, ADD_PORT));
556 retval = -ENODEV;
557 goto out2;
558 }
559 }
560
561 ioaddr &= ~3;
562 printk(KERN_DEBUG "PP_addr at %x[%x]: 0x%x\n",
563 ioaddr, ADD_PORT, readword(ioaddr, ADD_PORT));
564 writeword(ioaddr, ADD_PORT, PP_ChipID);
565
566 tmp = readword(ioaddr, DATA_PORT);
567 if (tmp != CHIP_EISA_ID_SIG) {
568 printk(KERN_DEBUG "%s: incorrect signature at %x[%x]: 0x%x!="
569 CHIP_EISA_ID_SIG_STR "\n",
570 dev->name, ioaddr, DATA_PORT, tmp);
571 retval = -ENODEV;
572 goto out2;
573 }
574
575 /* Fill in the 'dev' fields. */
576 dev->base_addr = ioaddr;
577
578 /* get the chip type */
579 rev_type = readreg(dev, PRODUCT_ID_ADD);
580 lp->chip_type = rev_type &~ REVISON_BITS;
581 lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
582
583 /* Check the chip type and revision in order to set the correct send command
584 CS8920 revision C and CS8900 revision F can use the faster send. */
585 lp->send_cmd = TX_AFTER_381;
586 if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
587 lp->send_cmd = TX_NOW;
588 if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
589 lp->send_cmd = TX_NOW;
590
591 if (net_debug && version_printed++ == 0)
592 printk(version);
593
594 printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#3lx ",
595 dev->name,
596 lp->chip_type==CS8900?'0':'2',
597 lp->chip_type==CS8920M?"M":"",
598 lp->chip_revision,
599 dev->base_addr);
600
601 reset_chip(dev);
602
603 /* Here we read the current configuration of the chip. If there
604 is no Extended EEPROM then the idea is to not disturb the chip
605 configuration, it should have been correctly setup by automatic
606 EEPROM read on reset. So, if the chip says it read the EEPROM
607 the driver will always do *something* instead of complain that
608 adapter_cnf is 0. */
609
610
611 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
612 (EEPROM_OK|EEPROM_PRESENT)) {
613 /* Load the MAC. */
614 for (i=0; i < ETH_ALEN/2; i++) {
615 unsigned int Addr;
616 Addr = readreg(dev, PP_IA+i*2);
617 dev->dev_addr[i*2] = Addr & 0xFF;
618 dev->dev_addr[i*2+1] = Addr >> 8;
619 }
620
621 /* Load the Adapter Configuration.
622 Note: Barring any more specific information from some
623 other source (ie EEPROM+Schematics), we would not know
624 how to operate a 10Base2 interface on the AUI port.
625 However, since we do read the status of HCB1 and use
626 settings that always result in calls to control_dc_dc(dev,0)
627 a BNC interface should work if the enable pin
628 (dc/dc converter) is on HCB1. It will be called AUI
629 however. */
630
631 lp->adapter_cnf = 0;
632 i = readreg(dev, PP_LineCTL);
633 /* Preserve the setting of the HCB1 pin. */
634 if ((i & (HCB1 | HCB1_ENBL)) == (HCB1 | HCB1_ENBL))
635 lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
636 /* Save the sqelch bit */
637 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
638 lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
639 /* Check if the card is in 10Base-t only mode */
640 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
641 lp->adapter_cnf |= A_CNF_10B_T | A_CNF_MEDIA_10B_T;
642 /* Check if the card is in AUI only mode */
643 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
644 lp->adapter_cnf |= A_CNF_AUI | A_CNF_MEDIA_AUI;
645 /* Check if the card is in Auto mode. */
646 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
647 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
648 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
649
650 if (net_debug > 1)
651 printk(KERN_INFO "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
652 dev->name, i, lp->adapter_cnf);
653
654 /* IRQ. Other chips already probe, see below. */
655 if (lp->chip_type == CS8900)
656 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
657
658 printk( "[Cirrus EEPROM] ");
659 }
660
661 printk("\n");
662
663 /* First check to see if an EEPROM is attached. */
664
665 if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
666 printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....\n");
667 else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
668 printk(KERN_WARNING "\ncs89x0: EEPROM read failed, relying on command line.\n");
669 } else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
670 /* Check if the chip was able to read its own configuration starting
671 at 0 in the EEPROM*/
672 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
673 (EEPROM_OK|EEPROM_PRESENT))
674 printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
675
676 } else {
677 /* This reads an extended EEPROM that is not documented
678 in the CS8900 datasheet. */
679
680 /* get transmission control word but keep the autonegotiation bits */
681 if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];
682 /* Store adapter configuration */
683 if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];
684 /* Store ISA configuration */
685 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2];
686 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;
687
688 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */
689 /* store the initial memory base address */
690 for (i = 0; i < ETH_ALEN/2; i++) {
691 dev->dev_addr[i*2] = eeprom_buff[i];
692 dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8;
693 }
694 if (net_debug > 1)
695 printk(KERN_DEBUG "%s: new adapter_cnf: 0x%x\n",
696 dev->name, lp->adapter_cnf);
697 }
698
699 /* allow them to force multiple transceivers. If they force multiple, autosense */
700 {
701 int count = 0;
702 if (lp->force & FORCE_RJ45) {lp->adapter_cnf |= A_CNF_10B_T; count++; }
703 if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_AUI; count++; }
704 if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_10B_2; count++; }
705 if (count > 1) {lp->adapter_cnf |= A_CNF_MEDIA_AUTO; }
706 else if (lp->force & FORCE_RJ45){lp->adapter_cnf |= A_CNF_MEDIA_10B_T; }
707 else if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_MEDIA_AUI; }
708 else if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_MEDIA_10B_2; }
709 }
710
711 if (net_debug > 1)
712 printk(KERN_DEBUG "%s: after force 0x%x, adapter_cnf=0x%x\n",
713 dev->name, lp->force, lp->adapter_cnf);
714
715 /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
716
717 /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
718
719 /* FIXME: we don't set the Ethernet address on the command line. Use
720 ifconfig IFACE hw ether AABBCCDDEEFF */
721
722 printk(KERN_INFO "cs89x0 media %s%s%s",
723 (lp->adapter_cnf & A_CNF_10B_T)?"RJ-45,":"",
724 (lp->adapter_cnf & A_CNF_AUI)?"AUI,":"",
725 (lp->adapter_cnf & A_CNF_10B_2)?"BNC,":"");
726
727 lp->irq_map = 0xffff;
728
729 /* If this is a CS8900 then no pnp soft */
730 if (lp->chip_type != CS8900 &&
731 /* Check if the ISA IRQ has been set */
732 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
733 (i != 0 && i < CS8920_NO_INTS))) {
734 if (!dev->irq)
735 dev->irq = i;
736 } else {
737 i = lp->isa_config & INT_NO_MASK;
738 if (lp->chip_type == CS8900) {
739 #ifdef CONFIG_CS89x0_NONISA_IRQ
740 i = cs8900_irq_map[0];
741 #else
742 /* Translate the IRQ using the IRQ mapping table. */
743 if (i >= ARRAY_SIZE(cs8900_irq_map))
744 printk("\ncs89x0: invalid ISA interrupt number %d\n", i);
745 else
746 i = cs8900_irq_map[i];
747
748 lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
749 } else {
750 int irq_map_buff[IRQ_MAP_LEN/2];
751
752 if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
753 IRQ_MAP_LEN/2,
754 irq_map_buff) >= 0) {
755 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
756 lp->irq_map = (irq_map_buff[0]>>8) | (irq_map_buff[1] << 8);
757 }
758 #endif
759 }
760 if (!dev->irq)
761 dev->irq = i;
762 }
763
764 printk(" IRQ %d", dev->irq);
765
766 #if ALLOW_DMA
767 if (lp->use_dma) {
768 get_dma_channel(dev);
769 printk(", DMA %d", dev->dma);
770 }
771 else
772 #endif
773 {
774 printk(", programmed I/O");
775 }
776
777 /* print the ethernet address. */
778 printk(", MAC %pM", dev->dev_addr);
779
780 dev->netdev_ops = &net_ops;
781 dev->watchdog_timeo = HZ;
782
783 printk("\n");
784 if (net_debug)
785 printk("cs89x0_probe1() successful\n");
786
787 retval = register_netdev(dev);
788 if (retval)
789 goto out3;
790 return 0;
791 out3:
792 writeword(dev->base_addr, ADD_PORT, PP_ChipID);
793 out2:
794 release_region(ioaddr & ~3, NETCARD_IO_EXTENT);
795 out1:
796 return retval;
797 }
798
799
800 /*********************************
801 * This page contains DMA routines
802 **********************************/
803
804 #if ALLOW_DMA
805
806 #define dma_page_eq(ptr1, ptr2) ((long)(ptr1)>>17 == (long)(ptr2)>>17)
807
808 static void
809 get_dma_channel(struct net_device *dev)
810 {
811 struct net_local *lp = netdev_priv(dev);
812
813 if (lp->dma) {
814 dev->dma = lp->dma;
815 lp->isa_config |= ISA_RxDMA;
816 } else {
817 if ((lp->isa_config & ANY_ISA_DMA) == 0)
818 return;
819 dev->dma = lp->isa_config & DMA_NO_MASK;
820 if (lp->chip_type == CS8900)
821 dev->dma += 5;
822 if (dev->dma < 5 || dev->dma > 7) {
823 lp->isa_config &= ~ANY_ISA_DMA;
824 return;
825 }
826 }
827 }
828
829 static void
830 write_dma(struct net_device *dev, int chip_type, int dma)
831 {
832 struct net_local *lp = netdev_priv(dev);
833 if ((lp->isa_config & ANY_ISA_DMA) == 0)
834 return;
835 if (chip_type == CS8900) {
836 writereg(dev, PP_CS8900_ISADMA, dma-5);
837 } else {
838 writereg(dev, PP_CS8920_ISADMA, dma);
839 }
840 }
841
842 static void
843 set_dma_cfg(struct net_device *dev)
844 {
845 struct net_local *lp = netdev_priv(dev);
846
847 if (lp->use_dma) {
848 if ((lp->isa_config & ANY_ISA_DMA) == 0) {
849 if (net_debug > 3)
850 printk("set_dma_cfg(): no DMA\n");
851 return;
852 }
853 if (lp->isa_config & ISA_RxDMA) {
854 lp->curr_rx_cfg |= RX_DMA_ONLY;
855 if (net_debug > 3)
856 printk("set_dma_cfg(): RX_DMA_ONLY\n");
857 } else {
858 lp->curr_rx_cfg |= AUTO_RX_DMA; /* not that we support it... */
859 if (net_debug > 3)
860 printk("set_dma_cfg(): AUTO_RX_DMA\n");
861 }
862 }
863 }
864
865 static int
866 dma_bufcfg(struct net_device *dev)
867 {
868 struct net_local *lp = netdev_priv(dev);
869 if (lp->use_dma)
870 return (lp->isa_config & ANY_ISA_DMA)? RX_DMA_ENBL : 0;
871 else
872 return 0;
873 }
874
875 static int
876 dma_busctl(struct net_device *dev)
877 {
878 int retval = 0;
879 struct net_local *lp = netdev_priv(dev);
880 if (lp->use_dma) {
881 if (lp->isa_config & ANY_ISA_DMA)
882 retval |= RESET_RX_DMA; /* Reset the DMA pointer */
883 if (lp->isa_config & DMA_BURST)
884 retval |= DMA_BURST_MODE; /* Does ISA config specify DMA burst ? */
885 if (lp->dmasize == 64)
886 retval |= RX_DMA_SIZE_64K; /* did they ask for 64K? */
887 retval |= MEMORY_ON; /* we need memory enabled to use DMA. */
888 }
889 return retval;
890 }
891
892 static void
893 dma_rx(struct net_device *dev)
894 {
895 struct net_local *lp = netdev_priv(dev);
896 struct sk_buff *skb;
897 int status, length;
898 unsigned char *bp = lp->rx_dma_ptr;
899
900 status = bp[0] + (bp[1]<<8);
901 length = bp[2] + (bp[3]<<8);
902 bp += 4;
903 if (net_debug > 5) {
904 printk( "%s: receiving DMA packet at %lx, status %x, length %x\n",
905 dev->name, (unsigned long)bp, status, length);
906 }
907 if ((status & RX_OK) == 0) {
908 count_rx_errors(status, dev);
909 goto skip_this_frame;
910 }
911
912 /* Malloc up new buffer. */
913 skb = netdev_alloc_skb(dev, length + 2);
914 if (skb == NULL) {
915 if (net_debug) /* I don't think we want to do this to a stressed system */
916 printk("%s: Memory squeeze, dropping packet.\n", dev->name);
917 dev->stats.rx_dropped++;
918
919 /* AKPM: advance bp to the next frame */
920 skip_this_frame:
921 bp += (length + 3) & ~3;
922 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
923 lp->rx_dma_ptr = bp;
924 return;
925 }
926 skb_reserve(skb, 2); /* longword align L3 header */
927
928 if (bp + length > lp->end_dma_buff) {
929 int semi_cnt = lp->end_dma_buff - bp;
930 memcpy(skb_put(skb,semi_cnt), bp, semi_cnt);
931 memcpy(skb_put(skb,length - semi_cnt), lp->dma_buff,
932 length - semi_cnt);
933 } else {
934 memcpy(skb_put(skb,length), bp, length);
935 }
936 bp += (length + 3) & ~3;
937 if (bp >= lp->end_dma_buff) bp -= lp->dmasize*1024;
938 lp->rx_dma_ptr = bp;
939
940 if (net_debug > 3) {
941 printk( "%s: received %d byte DMA packet of type %x\n",
942 dev->name, length,
943 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
944 }
945 skb->protocol=eth_type_trans(skb,dev);
946 netif_rx(skb);
947 dev->stats.rx_packets++;
948 dev->stats.rx_bytes += length;
949 }
950
951 #endif /* ALLOW_DMA */
952
953 static void __init reset_chip(struct net_device *dev)
954 {
955 #if !defined(CONFIG_MACH_MX31ADS)
956 #if !defined(CS89x0_NONISA_IRQ)
957 struct net_local *lp = netdev_priv(dev);
958 int ioaddr = dev->base_addr;
959 #endif /* CS89x0_NONISA_IRQ */
960 int reset_start_time;
961
962 writereg(dev, PP_SelfCTL, readreg(dev, PP_SelfCTL) | POWER_ON_RESET);
963
964 /* wait 30 ms */
965 msleep(30);
966
967 #if !defined(CS89x0_NONISA_IRQ)
968 if (lp->chip_type != CS8900) {
969 /* Hardware problem requires PNP registers to be reconfigured after a reset */
970 writeword(ioaddr, ADD_PORT, PP_CS8920_ISAINT);
971 outb(dev->irq, ioaddr + DATA_PORT);
972 outb(0, ioaddr + DATA_PORT + 1);
973
974 writeword(ioaddr, ADD_PORT, PP_CS8920_ISAMemB);
975 outb((dev->mem_start >> 16) & 0xff, ioaddr + DATA_PORT);
976 outb((dev->mem_start >> 8) & 0xff, ioaddr + DATA_PORT + 1);
977 }
978 #endif /* CS89x0_NONISA_IRQ */
979
980 /* Wait until the chip is reset */
981 reset_start_time = jiffies;
982 while( (readreg(dev, PP_SelfST) & INIT_DONE) == 0 && jiffies - reset_start_time < 2)
983 ;
984 #endif /* !CONFIG_MACH_MX31ADS */
985 }
986
987
988 static void
989 control_dc_dc(struct net_device *dev, int on_not_off)
990 {
991 struct net_local *lp = netdev_priv(dev);
992 unsigned int selfcontrol;
993 int timenow = jiffies;
994 /* control the DC to DC convertor in the SelfControl register.
995 Note: This is hooked up to a general purpose pin, might not
996 always be a DC to DC convertor. */
997
998 selfcontrol = HCB1_ENBL; /* Enable the HCB1 bit as an output */
999 if (((lp->adapter_cnf & A_CNF_DC_DC_POLARITY) != 0) ^ on_not_off)
1000 selfcontrol |= HCB1;
1001 else
1002 selfcontrol &= ~HCB1;
1003 writereg(dev, PP_SelfCTL, selfcontrol);
1004
1005 /* Wait for the DC/DC converter to power up - 500ms */
1006 while (jiffies - timenow < HZ)
1007 ;
1008 }
1009
1010 #define DETECTED_NONE 0
1011 #define DETECTED_RJ45H 1
1012 #define DETECTED_RJ45F 2
1013 #define DETECTED_AUI 3
1014 #define DETECTED_BNC 4
1015
1016 static int
1017 detect_tp(struct net_device *dev)
1018 {
1019 struct net_local *lp = netdev_priv(dev);
1020 int timenow = jiffies;
1021 int fdx;
1022
1023 if (net_debug > 1) printk("%s: Attempting TP\n", dev->name);
1024
1025 /* If connected to another full duplex capable 10-Base-T card the link pulses
1026 seem to be lost when the auto detect bit in the LineCTL is set.
1027 To overcome this the auto detect bit will be cleared whilst testing the
1028 10-Base-T interface. This would not be necessary for the sparrow chip but
1029 is simpler to do it anyway. */
1030 writereg(dev, PP_LineCTL, lp->linectl &~ AUI_ONLY);
1031 control_dc_dc(dev, 0);
1032
1033 /* Delay for the hardware to work out if the TP cable is present - 150ms */
1034 for (timenow = jiffies; jiffies - timenow < 15; )
1035 ;
1036 if ((readreg(dev, PP_LineST) & LINK_OK) == 0)
1037 return DETECTED_NONE;
1038
1039 if (lp->chip_type == CS8900) {
1040 switch (lp->force & 0xf0) {
1041 #if 0
1042 case FORCE_AUTO:
1043 printk("%s: cs8900 doesn't autonegotiate\n",dev->name);
1044 return DETECTED_NONE;
1045 #endif
1046 /* CS8900 doesn't support AUTO, change to HALF*/
1047 case FORCE_AUTO:
1048 lp->force &= ~FORCE_AUTO;
1049 lp->force |= FORCE_HALF;
1050 break;
1051 case FORCE_HALF:
1052 break;
1053 case FORCE_FULL:
1054 writereg(dev, PP_TestCTL, readreg(dev, PP_TestCTL) | FDX_8900);
1055 break;
1056 }
1057 fdx = readreg(dev, PP_TestCTL) & FDX_8900;
1058 } else {
1059 switch (lp->force & 0xf0) {
1060 case FORCE_AUTO:
1061 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1062 break;
1063 case FORCE_HALF:
1064 lp->auto_neg_cnf = 0;
1065 break;
1066 case FORCE_FULL:
1067 lp->auto_neg_cnf = RE_NEG_NOW | ALLOW_FDX;
1068 break;
1069 }
1070
1071 writereg(dev, PP_AutoNegCTL, lp->auto_neg_cnf & AUTO_NEG_MASK);
1072
1073 if ((lp->auto_neg_cnf & AUTO_NEG_BITS) == AUTO_NEG_ENABLE) {
1074 printk(KERN_INFO "%s: negotiating duplex...\n",dev->name);
1075 while (readreg(dev, PP_AutoNegST) & AUTO_NEG_BUSY) {
1076 if (jiffies - timenow > 4000) {
1077 printk(KERN_ERR "**** Full / half duplex auto-negotiation timed out ****\n");
1078 break;
1079 }
1080 }
1081 }
1082 fdx = readreg(dev, PP_AutoNegST) & FDX_ACTIVE;
1083 }
1084 if (fdx)
1085 return DETECTED_RJ45F;
1086 else
1087 return DETECTED_RJ45H;
1088 }
1089
1090 /* send a test packet - return true if carrier bits are ok */
1091 static int
1092 send_test_pkt(struct net_device *dev)
1093 {
1094 char test_packet[] = { 0,0,0,0,0,0, 0,0,0,0,0,0,
1095 0, 46, /* A 46 in network order */
1096 0, 0, /* DSAP=0 & SSAP=0 fields */
1097 0xf3, 0 /* Control (Test Req + P bit set) */ };
1098 long timenow = jiffies;
1099
1100 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_TX_ON);
1101
1102 memcpy(test_packet, dev->dev_addr, ETH_ALEN);
1103 memcpy(test_packet+ETH_ALEN, dev->dev_addr, ETH_ALEN);
1104
1105 writeword(dev->base_addr, TX_CMD_PORT, TX_AFTER_ALL);
1106 writeword(dev->base_addr, TX_LEN_PORT, ETH_ZLEN);
1107
1108 /* Test to see if the chip has allocated memory for the packet */
1109 while (jiffies - timenow < 5)
1110 if (readreg(dev, PP_BusST) & READY_FOR_TX_NOW)
1111 break;
1112 if (jiffies - timenow >= 5)
1113 return 0; /* this shouldn't happen */
1114
1115 /* Write the contents of the packet */
1116 writewords(dev->base_addr, TX_FRAME_PORT,test_packet,(ETH_ZLEN+1) >>1);
1117
1118 if (net_debug > 1) printk("Sending test packet ");
1119 /* wait a couple of jiffies for packet to be received */
1120 for (timenow = jiffies; jiffies - timenow < 3; )
1121 ;
1122 if ((readreg(dev, PP_TxEvent) & TX_SEND_OK_BITS) == TX_OK) {
1123 if (net_debug > 1) printk("succeeded\n");
1124 return 1;
1125 }
1126 if (net_debug > 1) printk("failed\n");
1127 return 0;
1128 }
1129
1130
1131 static int
1132 detect_aui(struct net_device *dev)
1133 {
1134 struct net_local *lp = netdev_priv(dev);
1135
1136 if (net_debug > 1) printk("%s: Attempting AUI\n", dev->name);
1137 control_dc_dc(dev, 0);
1138
1139 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1140
1141 if (send_test_pkt(dev))
1142 return DETECTED_AUI;
1143 else
1144 return DETECTED_NONE;
1145 }
1146
1147 static int
1148 detect_bnc(struct net_device *dev)
1149 {
1150 struct net_local *lp = netdev_priv(dev);
1151
1152 if (net_debug > 1) printk("%s: Attempting BNC\n", dev->name);
1153 control_dc_dc(dev, 1);
1154
1155 writereg(dev, PP_LineCTL, (lp->linectl &~ AUTO_AUI_10BASET) | AUI_ONLY);
1156
1157 if (send_test_pkt(dev))
1158 return DETECTED_BNC;
1159 else
1160 return DETECTED_NONE;
1161 }
1162
1163
1164 static void
1165 write_irq(struct net_device *dev, int chip_type, int irq)
1166 {
1167 int i;
1168
1169 if (chip_type == CS8900) {
1170 /* Search the mapping table for the corresponding IRQ pin. */
1171 for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
1172 if (cs8900_irq_map[i] == irq)
1173 break;
1174 /* Not found */
1175 if (i == ARRAY_SIZE(cs8900_irq_map))
1176 i = 3;
1177 writereg(dev, PP_CS8900_ISAINT, i);
1178 } else {
1179 writereg(dev, PP_CS8920_ISAINT, irq);
1180 }
1181 }
1182
1183 /* Open/initialize the board. This is called (in the current kernel)
1184 sometime after booting when the 'ifconfig' program is run.
1185
1186 This routine should set everything up anew at each open, even
1187 registers that "should" only need to be set once at boot, so that
1188 there is non-reboot way to recover if something goes wrong.
1189 */
1190
1191 /* AKPM: do we need to do any locking here? */
1192
1193 static int
1194 net_open(struct net_device *dev)
1195 {
1196 struct net_local *lp = netdev_priv(dev);
1197 int result = 0;
1198 int i;
1199 int ret;
1200
1201 if (dev->irq < 2) {
1202 /* Allow interrupts to be generated by the chip */
1203 /* Cirrus' release had this: */
1204 #if 0
1205 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1206 #endif
1207 /* And 2.3.47 had this: */
1208 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1209
1210 for (i = 2; i < CS8920_NO_INTS; i++) {
1211 if ((1 << i) & lp->irq_map) {
1212 if (request_irq(i, net_interrupt, 0, dev->name, dev) == 0) {
1213 dev->irq = i;
1214 write_irq(dev, lp->chip_type, i);
1215 /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
1216 break;
1217 }
1218 }
1219 }
1220
1221 if (i >= CS8920_NO_INTS) {
1222 writereg(dev, PP_BusCTL, 0); /* disable interrupts. */
1223 printk(KERN_ERR "cs89x0: can't get an interrupt\n");
1224 ret = -EAGAIN;
1225 goto bad_out;
1226 }
1227 }
1228 else
1229 {
1230 #ifndef CONFIG_CS89x0_NONISA_IRQ
1231 if (((1 << dev->irq) & lp->irq_map) == 0) {
1232 printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
1233 dev->name, dev->irq, lp->irq_map);
1234 ret = -EAGAIN;
1235 goto bad_out;
1236 }
1237 #endif
1238 /* FIXME: Cirrus' release had this: */
1239 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1240 /* And 2.3.47 had this: */
1241 #if 0
1242 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1243 #endif
1244 write_irq(dev, lp->chip_type, dev->irq);
1245 ret = request_irq(dev->irq, net_interrupt, 0, dev->name, dev);
1246 if (ret) {
1247 printk(KERN_ERR "cs89x0: request_irq(%d) failed\n", dev->irq);
1248 goto bad_out;
1249 }
1250 }
1251
1252 #if ALLOW_DMA
1253 if (lp->use_dma) {
1254 if (lp->isa_config & ANY_ISA_DMA) {
1255 unsigned long flags;
1256 lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
1257 get_order(lp->dmasize * 1024));
1258
1259 if (!lp->dma_buff) {
1260 printk(KERN_ERR "%s: cannot get %dK memory for DMA\n", dev->name, lp->dmasize);
1261 goto release_irq;
1262 }
1263 if (net_debug > 1) {
1264 printk( "%s: dma %lx %lx\n",
1265 dev->name,
1266 (unsigned long)lp->dma_buff,
1267 (unsigned long)isa_virt_to_bus(lp->dma_buff));
1268 }
1269 if ((unsigned long) lp->dma_buff >= MAX_DMA_ADDRESS ||
1270 !dma_page_eq(lp->dma_buff, lp->dma_buff+lp->dmasize*1024-1)) {
1271 printk(KERN_ERR "%s: not usable as DMA buffer\n", dev->name);
1272 goto release_irq;
1273 }
1274 memset(lp->dma_buff, 0, lp->dmasize * 1024); /* Why? */
1275 if (request_dma(dev->dma, dev->name)) {
1276 printk(KERN_ERR "%s: cannot get dma channel %d\n", dev->name, dev->dma);
1277 goto release_irq;
1278 }
1279 write_dma(dev, lp->chip_type, dev->dma);
1280 lp->rx_dma_ptr = lp->dma_buff;
1281 lp->end_dma_buff = lp->dma_buff + lp->dmasize*1024;
1282 spin_lock_irqsave(&lp->lock, flags);
1283 disable_dma(dev->dma);
1284 clear_dma_ff(dev->dma);
1285 set_dma_mode(dev->dma, DMA_RX_MODE); /* auto_init as well */
1286 set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
1287 set_dma_count(dev->dma, lp->dmasize*1024);
1288 enable_dma(dev->dma);
1289 spin_unlock_irqrestore(&lp->lock, flags);
1290 }
1291 }
1292 #endif /* ALLOW_DMA */
1293
1294 /* set the Ethernet address */
1295 for (i=0; i < ETH_ALEN/2; i++)
1296 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1297
1298 /* while we're testing the interface, leave interrupts disabled */
1299 writereg(dev, PP_BusCTL, MEMORY_ON);
1300
1301 /* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
1302 if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) && (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
1303 lp->linectl = LOW_RX_SQUELCH;
1304 else
1305 lp->linectl = 0;
1306
1307 /* check to make sure that they have the "right" hardware available */
1308 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1309 case A_CNF_MEDIA_10B_T: result = lp->adapter_cnf & A_CNF_10B_T; break;
1310 case A_CNF_MEDIA_AUI: result = lp->adapter_cnf & A_CNF_AUI; break;
1311 case A_CNF_MEDIA_10B_2: result = lp->adapter_cnf & A_CNF_10B_2; break;
1312 default: result = lp->adapter_cnf & (A_CNF_10B_T | A_CNF_AUI | A_CNF_10B_2);
1313 }
1314 if (!result) {
1315 printk(KERN_ERR "%s: EEPROM is configured for unavailable media\n", dev->name);
1316 release_dma:
1317 #if ALLOW_DMA
1318 free_dma(dev->dma);
1319 release_irq:
1320 release_dma_buff(lp);
1321 #endif
1322 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
1323 free_irq(dev->irq, dev);
1324 ret = -EAGAIN;
1325 goto bad_out;
1326 }
1327
1328 /* set the hardware to the configured choice */
1329 switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1330 case A_CNF_MEDIA_10B_T:
1331 result = detect_tp(dev);
1332 if (result==DETECTED_NONE) {
1333 printk(KERN_WARNING "%s: 10Base-T (RJ-45) has no cable\n", dev->name);
1334 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1335 result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
1336 }
1337 break;
1338 case A_CNF_MEDIA_AUI:
1339 result = detect_aui(dev);
1340 if (result==DETECTED_NONE) {
1341 printk(KERN_WARNING "%s: 10Base-5 (AUI) has no cable\n", dev->name);
1342 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1343 result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
1344 }
1345 break;
1346 case A_CNF_MEDIA_10B_2:
1347 result = detect_bnc(dev);
1348 if (result==DETECTED_NONE) {
1349 printk(KERN_WARNING "%s: 10Base-2 (BNC) has no cable\n", dev->name);
1350 if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1351 result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
1352 }
1353 break;
1354 case A_CNF_MEDIA_AUTO:
1355 writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
1356 if (lp->adapter_cnf & A_CNF_10B_T)
1357 if ((result = detect_tp(dev)) != DETECTED_NONE)
1358 break;
1359 if (lp->adapter_cnf & A_CNF_AUI)
1360 if ((result = detect_aui(dev)) != DETECTED_NONE)
1361 break;
1362 if (lp->adapter_cnf & A_CNF_10B_2)
1363 if ((result = detect_bnc(dev)) != DETECTED_NONE)
1364 break;
1365 printk(KERN_ERR "%s: no media detected\n", dev->name);
1366 goto release_dma;
1367 }
1368 switch(result) {
1369 case DETECTED_NONE:
1370 printk(KERN_ERR "%s: no network cable attached to configured media\n", dev->name);
1371 goto release_dma;
1372 case DETECTED_RJ45H:
1373 printk(KERN_INFO "%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
1374 break;
1375 case DETECTED_RJ45F:
1376 printk(KERN_INFO "%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
1377 break;
1378 case DETECTED_AUI:
1379 printk(KERN_INFO "%s: using 10Base-5 (AUI)\n", dev->name);
1380 break;
1381 case DETECTED_BNC:
1382 printk(KERN_INFO "%s: using 10Base-2 (BNC)\n", dev->name);
1383 break;
1384 }
1385
1386 /* Turn on both receive and transmit operations */
1387 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1388
1389 /* Receive only error free packets addressed to this card */
1390 lp->rx_mode = 0;
1391 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
1392
1393 lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
1394
1395 if (lp->isa_config & STREAM_TRANSFER)
1396 lp->curr_rx_cfg |= RX_STREAM_ENBL;
1397 #if ALLOW_DMA
1398 set_dma_cfg(dev);
1399 #endif
1400 writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
1401
1402 writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
1403 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
1404
1405 writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
1406 #if ALLOW_DMA
1407 dma_bufcfg(dev) |
1408 #endif
1409 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
1410
1411 /* now that we've got our act together, enable everything */
1412 writereg(dev, PP_BusCTL, ENABLE_IRQ
1413 | (dev->mem_start?MEMORY_ON : 0) /* turn memory on */
1414 #if ALLOW_DMA
1415 | dma_busctl(dev)
1416 #endif
1417 );
1418 netif_start_queue(dev);
1419 if (net_debug > 1)
1420 printk("cs89x0: net_open() succeeded\n");
1421 return 0;
1422 bad_out:
1423 return ret;
1424 }
1425
1426 static void net_timeout(struct net_device *dev)
1427 {
1428 /* If we get here, some higher level has decided we are broken.
1429 There should really be a "kick me" function call instead. */
1430 if (net_debug > 0) printk("%s: transmit timed out, %s?\n", dev->name,
1431 tx_done(dev) ? "IRQ conflict ?" : "network cable problem");
1432 /* Try to restart the adaptor. */
1433 netif_wake_queue(dev);
1434 }
1435
1436 static netdev_tx_t net_send_packet(struct sk_buff *skb,struct net_device *dev)
1437 {
1438 struct net_local *lp = netdev_priv(dev);
1439 unsigned long flags;
1440
1441 if (net_debug > 3) {
1442 printk("%s: sent %d byte packet of type %x\n",
1443 dev->name, skb->len,
1444 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1445 }
1446
1447 /* keep the upload from being interrupted, since we
1448 ask the chip to start transmitting before the
1449 whole packet has been completely uploaded. */
1450
1451 spin_lock_irqsave(&lp->lock, flags);
1452 netif_stop_queue(dev);
1453
1454 /* initiate a transmit sequence */
1455 writeword(dev->base_addr, TX_CMD_PORT, lp->send_cmd);
1456 writeword(dev->base_addr, TX_LEN_PORT, skb->len);
1457
1458 /* Test to see if the chip has allocated memory for the packet */
1459 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1460 /*
1461 * Gasp! It hasn't. But that shouldn't happen since
1462 * we're waiting for TxOk, so return 1 and requeue this packet.
1463 */
1464
1465 spin_unlock_irqrestore(&lp->lock, flags);
1466 if (net_debug) printk("cs89x0: Tx buffer not free!\n");
1467 return NETDEV_TX_BUSY;
1468 }
1469 /* Write the contents of the packet */
1470 writewords(dev->base_addr, TX_FRAME_PORT,skb->data,(skb->len+1) >>1);
1471 spin_unlock_irqrestore(&lp->lock, flags);
1472 dev->stats.tx_bytes += skb->len;
1473 dev_kfree_skb (skb);
1474
1475 /*
1476 * We DO NOT call netif_wake_queue() here.
1477 * We also DO NOT call netif_start_queue().
1478 *
1479 * Either of these would cause another bottom half run through
1480 * net_send_packet() before this packet has fully gone out. That causes
1481 * us to hit the "Gasp!" above and the send is rescheduled. it runs like
1482 * a dog. We just return and wait for the Tx completion interrupt handler
1483 * to restart the netdevice layer
1484 */
1485
1486 return NETDEV_TX_OK;
1487 }
1488
1489 /* The typical workload of the driver:
1490 Handle the network interface interrupts. */
1491
1492 static irqreturn_t net_interrupt(int irq, void *dev_id)
1493 {
1494 struct net_device *dev = dev_id;
1495 struct net_local *lp;
1496 int ioaddr, status;
1497 int handled = 0;
1498
1499 ioaddr = dev->base_addr;
1500 lp = netdev_priv(dev);
1501
1502 /* we MUST read all the events out of the ISQ, otherwise we'll never
1503 get interrupted again. As a consequence, we can't have any limit
1504 on the number of times we loop in the interrupt handler. The
1505 hardware guarantees that eventually we'll run out of events. Of
1506 course, if you're on a slow machine, and packets are arriving
1507 faster than you can read them off, you're screwed. Hasta la
1508 vista, baby! */
1509 while ((status = readword(dev->base_addr, ISQ_PORT))) {
1510 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
1511 handled = 1;
1512 switch(status & ISQ_EVENT_MASK) {
1513 case ISQ_RECEIVER_EVENT:
1514 /* Got a packet(s). */
1515 net_rx(dev);
1516 break;
1517 case ISQ_TRANSMITTER_EVENT:
1518 dev->stats.tx_packets++;
1519 netif_wake_queue(dev); /* Inform upper layers. */
1520 if ((status & ( TX_OK |
1521 TX_LOST_CRS |
1522 TX_SQE_ERROR |
1523 TX_LATE_COL |
1524 TX_16_COL)) != TX_OK) {
1525 if ((status & TX_OK) == 0)
1526 dev->stats.tx_errors++;
1527 if (status & TX_LOST_CRS)
1528 dev->stats.tx_carrier_errors++;
1529 if (status & TX_SQE_ERROR)
1530 dev->stats.tx_heartbeat_errors++;
1531 if (status & TX_LATE_COL)
1532 dev->stats.tx_window_errors++;
1533 if (status & TX_16_COL)
1534 dev->stats.tx_aborted_errors++;
1535 }
1536 break;
1537 case ISQ_BUFFER_EVENT:
1538 if (status & READY_FOR_TX) {
1539 /* we tried to transmit a packet earlier,
1540 but inexplicably ran out of buffers.
1541 That shouldn't happen since we only ever
1542 load one packet. Shrug. Do the right
1543 thing anyway. */
1544 netif_wake_queue(dev); /* Inform upper layers. */
1545 }
1546 if (status & TX_UNDERRUN) {
1547 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
1548 lp->send_underrun++;
1549 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
1550 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
1551 /* transmit cycle is done, although
1552 frame wasn't transmitted - this
1553 avoids having to wait for the upper
1554 layers to timeout on us, in the
1555 event of a tx underrun */
1556 netif_wake_queue(dev); /* Inform upper layers. */
1557 }
1558 #if ALLOW_DMA
1559 if (lp->use_dma && (status & RX_DMA)) {
1560 int count = readreg(dev, PP_DmaFrameCnt);
1561 while(count) {
1562 if (net_debug > 5)
1563 printk("%s: receiving %d DMA frames\n", dev->name, count);
1564 if (net_debug > 2 && count >1)
1565 printk("%s: receiving %d DMA frames\n", dev->name, count);
1566 dma_rx(dev);
1567 if (--count == 0)
1568 count = readreg(dev, PP_DmaFrameCnt);
1569 if (net_debug > 2 && count > 0)
1570 printk("%s: continuing with %d DMA frames\n", dev->name, count);
1571 }
1572 }
1573 #endif
1574 break;
1575 case ISQ_RX_MISS_EVENT:
1576 dev->stats.rx_missed_errors += (status >> 6);
1577 break;
1578 case ISQ_TX_COL_EVENT:
1579 dev->stats.collisions += (status >> 6);
1580 break;
1581 }
1582 }
1583 return IRQ_RETVAL(handled);
1584 }
1585
1586 static void
1587 count_rx_errors(int status, struct net_device *dev)
1588 {
1589 dev->stats.rx_errors++;
1590 if (status & RX_RUNT)
1591 dev->stats.rx_length_errors++;
1592 if (status & RX_EXTRA_DATA)
1593 dev->stats.rx_length_errors++;
1594 if ((status & RX_CRC_ERROR) && !(status & (RX_EXTRA_DATA|RX_RUNT)))
1595 /* per str 172 */
1596 dev->stats.rx_crc_errors++;
1597 if (status & RX_DRIBBLE)
1598 dev->stats.rx_frame_errors++;
1599 }
1600
1601 /* We have a good packet(s), get it/them out of the buffers. */
1602 static void
1603 net_rx(struct net_device *dev)
1604 {
1605 struct sk_buff *skb;
1606 int status, length;
1607
1608 int ioaddr = dev->base_addr;
1609 status = readword(ioaddr, RX_FRAME_PORT);
1610 length = readword(ioaddr, RX_FRAME_PORT);
1611
1612 if ((status & RX_OK) == 0) {
1613 count_rx_errors(status, dev);
1614 return;
1615 }
1616
1617 /* Malloc up new buffer. */
1618 skb = netdev_alloc_skb(dev, length + 2);
1619 if (skb == NULL) {
1620 #if 0 /* Again, this seems a cruel thing to do */
1621 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1622 #endif
1623 dev->stats.rx_dropped++;
1624 return;
1625 }
1626 skb_reserve(skb, 2); /* longword align L3 header */
1627
1628 readwords(ioaddr, RX_FRAME_PORT, skb_put(skb, length), length >> 1);
1629 if (length & 1)
1630 skb->data[length-1] = readword(ioaddr, RX_FRAME_PORT);
1631
1632 if (net_debug > 3) {
1633 printk( "%s: received %d byte packet of type %x\n",
1634 dev->name, length,
1635 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1636 }
1637
1638 skb->protocol=eth_type_trans(skb,dev);
1639 netif_rx(skb);
1640 dev->stats.rx_packets++;
1641 dev->stats.rx_bytes += length;
1642 }
1643
1644 #if ALLOW_DMA
1645 static void release_dma_buff(struct net_local *lp)
1646 {
1647 if (lp->dma_buff) {
1648 free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024));
1649 lp->dma_buff = NULL;
1650 }
1651 }
1652 #endif
1653
1654 /* The inverse routine to net_open(). */
1655 static int
1656 net_close(struct net_device *dev)
1657 {
1658 #if ALLOW_DMA
1659 struct net_local *lp = netdev_priv(dev);
1660 #endif
1661
1662 netif_stop_queue(dev);
1663
1664 writereg(dev, PP_RxCFG, 0);
1665 writereg(dev, PP_TxCFG, 0);
1666 writereg(dev, PP_BufCFG, 0);
1667 writereg(dev, PP_BusCTL, 0);
1668
1669 free_irq(dev->irq, dev);
1670
1671 #if ALLOW_DMA
1672 if (lp->use_dma && lp->dma) {
1673 free_dma(dev->dma);
1674 release_dma_buff(lp);
1675 }
1676 #endif
1677
1678 /* Update the statistics here. */
1679 return 0;
1680 }
1681
1682 /* Get the current statistics. This may be called with the card open or
1683 closed. */
1684 static struct net_device_stats *
1685 net_get_stats(struct net_device *dev)
1686 {
1687 struct net_local *lp = netdev_priv(dev);
1688 unsigned long flags;
1689
1690 spin_lock_irqsave(&lp->lock, flags);
1691 /* Update the statistics from the device registers. */
1692 dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1693 dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1694 spin_unlock_irqrestore(&lp->lock, flags);
1695
1696 return &dev->stats;
1697 }
1698
1699 static void set_multicast_list(struct net_device *dev)
1700 {
1701 struct net_local *lp = netdev_priv(dev);
1702 unsigned long flags;
1703
1704 spin_lock_irqsave(&lp->lock, flags);
1705 if(dev->flags&IFF_PROMISC)
1706 {
1707 lp->rx_mode = RX_ALL_ACCEPT;
1708 }
1709 else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev))
1710 {
1711 /* The multicast-accept list is initialized to accept-all, and we
1712 rely on higher-level filtering for now. */
1713 lp->rx_mode = RX_MULTCAST_ACCEPT;
1714 }
1715 else
1716 lp->rx_mode = 0;
1717
1718 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1719
1720 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
1721 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
1722 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
1723 spin_unlock_irqrestore(&lp->lock, flags);
1724 }
1725
1726
1727 static int set_mac_address(struct net_device *dev, void *p)
1728 {
1729 int i;
1730 struct sockaddr *addr = p;
1731
1732 if (netif_running(dev))
1733 return -EBUSY;
1734
1735 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1736
1737 if (net_debug)
1738 printk("%s: Setting MAC address to %pM.\n",
1739 dev->name, dev->dev_addr);
1740
1741 /* set the Ethernet address */
1742 for (i=0; i < ETH_ALEN/2; i++)
1743 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1744
1745 return 0;
1746 }
1747
1748 #ifdef MODULE
1749
1750 static struct net_device *dev_cs89x0;
1751
1752 /*
1753 * Support the 'debug' module parm even if we're compiled for non-debug to
1754 * avoid breaking someone's startup scripts
1755 */
1756
1757 static int io;
1758 static int irq;
1759 static int debug;
1760 static char media[8];
1761 static int duplex=-1;
1762
1763 static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
1764 static int dma;
1765 static int dmasize=16; /* or 64 */
1766
1767 module_param(io, int, 0);
1768 module_param(irq, int, 0);
1769 module_param(debug, int, 0);
1770 module_param_string(media, media, sizeof(media), 0);
1771 module_param(duplex, int, 0);
1772 module_param(dma , int, 0);
1773 module_param(dmasize , int, 0);
1774 module_param(use_dma , int, 0);
1775 MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1776 MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1777 #if DEBUGGING
1778 MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1779 #else
1780 MODULE_PARM_DESC(debug, "(ignored)");
1781 #endif
1782 MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1783 /* No other value than -1 for duplex seems to be currently interpreted */
1784 MODULE_PARM_DESC(duplex, "(ignored)");
1785 #if ALLOW_DMA
1786 MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1787 MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1788 MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1789 #else
1790 MODULE_PARM_DESC(dma , "(ignored)");
1791 MODULE_PARM_DESC(dmasize , "(ignored)");
1792 MODULE_PARM_DESC(use_dma , "(ignored)");
1793 #endif
1794
1795 MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
1796 MODULE_LICENSE("GPL");
1797
1798
1799 /*
1800 * media=t - specify media type
1801 or media=2
1802 or media=aui
1803 or medai=auto
1804 * duplex=0 - specify forced half/full/autonegotiate duplex
1805 * debug=# - debug level
1806
1807
1808 * Default Chip Configuration:
1809 * DMA Burst = enabled
1810 * IOCHRDY Enabled = enabled
1811 * UseSA = enabled
1812 * CS8900 defaults to half-duplex if not specified on command-line
1813 * CS8920 defaults to autoneg if not specified on command-line
1814 * Use reset defaults for other config parameters
1815
1816 * Assumptions:
1817 * media type specified is supported (circuitry is present)
1818 * if memory address is > 1MB, then required mem decode hw is present
1819 * if 10B-2, then agent other than driver will enable DC/DC converter
1820 (hw or software util)
1821
1822
1823 */
1824
1825 int __init init_module(void)
1826 {
1827 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1828 struct net_local *lp;
1829 int ret = 0;
1830
1831 #if DEBUGGING
1832 net_debug = debug;
1833 #else
1834 debug = 0;
1835 #endif
1836 if (!dev)
1837 return -ENOMEM;
1838
1839 dev->irq = irq;
1840 dev->base_addr = io;
1841 lp = netdev_priv(dev);
1842
1843 #if ALLOW_DMA
1844 if (use_dma) {
1845 lp->use_dma = use_dma;
1846 lp->dma = dma;
1847 lp->dmasize = dmasize;
1848 }
1849 #endif
1850
1851 spin_lock_init(&lp->lock);
1852
1853 /* boy, they'd better get these right */
1854 if (!strcmp(media, "rj45"))
1855 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1856 else if (!strcmp(media, "aui"))
1857 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1858 else if (!strcmp(media, "bnc"))
1859 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1860 else
1861 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1862
1863 if (duplex==-1)
1864 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1865
1866 if (io == 0) {
1867 printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n");
1868 printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n");
1869 ret = -EPERM;
1870 goto out;
1871 } else if (io <= 0x1ff) {
1872 ret = -ENXIO;
1873 goto out;
1874 }
1875
1876 #if ALLOW_DMA
1877 if (use_dma && dmasize != 16 && dmasize != 64) {
1878 printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize);
1879 ret = -EPERM;
1880 goto out;
1881 }
1882 #endif
1883 ret = cs89x0_probe1(dev, io, 1);
1884 if (ret)
1885 goto out;
1886
1887 dev_cs89x0 = dev;
1888 return 0;
1889 out:
1890 free_netdev(dev);
1891 return ret;
1892 }
1893
1894 void __exit
1895 cleanup_module(void)
1896 {
1897 unregister_netdev(dev_cs89x0);
1898 writeword(dev_cs89x0->base_addr, ADD_PORT, PP_ChipID);
1899 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1900 free_netdev(dev_cs89x0);
1901 }
1902 #endif /* MODULE */
1903
1904 /*
1905 * Local variables:
1906 * version-control: t
1907 * kept-new-versions: 5
1908 * c-indent-level: 8
1909 * tab-width: 8
1910 * End:
1911 *
1912 */
Linus' kernel tree