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