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