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