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