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