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