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