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