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