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