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