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