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