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