blob: 55445f980f9c975596d41b3a9e9a0887155f061b [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/* 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040018 : Changes for Linux 2.0 compatibility.
Linus Torvalds1da177e2005-04-16 15:20:36 -070019 : 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040024 : that the module is in use and wouldn't eject the
Linus Torvalds1da177e2005-04-16 15:20:36 -070025 : 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -040034 Melody Lee : Aug 10 1999. Changes for Linux 2.2.5 compatibility.
Linus Torvalds1da177e2005-04-16 15:20:36 -070035 : email: ethernet@crystal.cirrus.com
36
37 Alan Cox : Removed 1.2 support, added 2.1 extra counters.
38
Francois Camie1f8e872008-10-15 22:01:59 -070039 Andrew Morton : Kernel 2.3.48
Linus Torvalds1da177e2005-04-16 15:20:36 -070040 : 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
Francois Camie1f8e872008-10-15 22:01:59 -070051 Andrew Morton : Kernel 2.3.99-pre1
Linus Torvalds1da177e2005-04-16 15:20:36 -070052 : 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
Francois Camie1f8e872008-10-15 22:01:59 -070059 Andrew Morton : Kernel 2.3.99-pre4-1
Linus Torvalds1da177e2005-04-16 15:20:36 -070060 : MOD_INC/DEC race fix (see
61 : http://www.uwsg.indiana.edu/hypermail/linux/kernel/0003.3/1532.html)
62
Francois Camie1f8e872008-10-15 22:01:59 -070063 Andrew Morton : Kernel 2.4.0-test7-pre2
Linus Torvalds1da177e2005-04-16 15:20:36 -070064 : 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
Lennert Buytenhek032874e2006-01-14 13:21:15 -080089 Dmitry Pervushin : dpervushin@ru.mvista.com
90 : PNX010X platform support
91
Deepak Saxena9c878962006-01-14 13:21:18 -080092 Deepak Saxena : dsaxena@plexity.net
93 : Intel IXDP2351 platform support
94
Lennert Buytenhek5aeebe02006-01-16 22:14:53 -080095 Dmitry Pervushin : dpervushin@ru.mvista.com
96 : PNX010X platform support
97
Linus Torvalds1da177e2005-04-16 15:20:36 -070098*/
99
100/* Always include 'config.h' first in case the user wants to turn on
101 or override something. */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700102#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 */
Lennert Buytenhek91e1c462006-01-11 12:17:34 -0800110#ifndef CONFIG_ISA_DMA_API
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111#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>
Al Viro7625d482005-09-26 05:25:59 +0100150#include <asm/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700151#if ALLOW_DMA
152#include <asm/dma.h>
153#endif
154
155#include "cs89x0.h"
156
157static char version[] __initdata =
Francois Camie1f8e872008-10-15 22:01:59 -0700158"cs89x0.c: v2.4.3-pre1 Russell Nelson <nelson@crynwr.com>, Andrew Morton\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700159
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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400165 the page window before probing
166 Addr & 3 = Reset the page window and probe
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 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. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400170/* The cs8900 has 4 IRQ pins, software selectable. cs8900_irq_map maps
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171 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. */
Russell King635f0252008-10-28 09:43:54 +0000173#if defined(CONFIG_SH_HICOSH4)
Leonardo Potenzaa80763c2008-02-17 18:23:15 +0100174static unsigned int netcard_portlist[] __used __initdata =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175 { 0x0300, 0};
176static unsigned int cs8900_irq_map[] = {1,0,0,0};
Deepak Saxena9c878962006-01-14 13:21:18 -0800177#elif defined(CONFIG_MACH_IXDP2351)
Leonardo Potenzaa80763c2008-02-17 18:23:15 +0100178static unsigned int netcard_portlist[] __used __initdata = {IXDP2351_VIRT_CS8900_BASE, 0};
Deepak Saxena9c878962006-01-14 13:21:18 -0800179static unsigned int cs8900_irq_map[] = {IRQ_IXDP2351_CS8900, 0, 0, 0};
180#include <asm/irq.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700181#elif defined(CONFIG_ARCH_IXDP2X01)
182#include <asm/irq.h>
Leonardo Potenzaa80763c2008-02-17 18:23:15 +0100183static unsigned int netcard_portlist[] __used __initdata = {IXDP2X01_CS8900_VIRT_BASE, 0};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184static unsigned int cs8900_irq_map[] = {IRQ_IXDP2X01_CS8900, 0, 0, 0};
Lennert Buytenhek277cb102006-01-08 01:01:14 -0800185#elif defined(CONFIG_ARCH_PNX010X)
dmitry pervushin0dd3c782005-06-20 15:32:54 -0700186#include <asm/irq.h>
Russell Kinga09e64f2008-08-05 16:14:15 +0100187#include <mach/gpio.h>
dmitry pervushin0dd3c782005-06-20 15:32:54 -0700188#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 */
Leonardo Potenzaa80763c2008-02-17 18:23:15 +0100190static unsigned int netcard_portlist[] __used __initdata = {CIRRUS_DEFAULT_BASE, 0};
dmitry pervushin0dd3c782005-06-20 15:32:54 -0700191static unsigned int cs8900_irq_map[] = {CIRRUS_DEFAULT_IRQ, 0, 0, 0};
Gilles Chanteperdrix0ac4ed92008-09-26 15:44:43 +0100192#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};
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198#else
Leonardo Potenzaa80763c2008-02-17 18:23:15 +0100199static unsigned int netcard_portlist[] __used __initdata =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200 { 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);
David Howells7d12e782006-10-05 14:55:46 +0100253static irqreturn_t net_interrupt(int irq, void *dev_id);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700254static 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);
Deepak Saxena6f519162005-09-09 13:02:07 -0700264#ifdef CONFIG_NET_POLL_CONTROLLER
265static void net_poll_controller(struct net_device *dev);
266#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267#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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400303
Linus Torvalds1da177e2005-04-16 15:20:36 -0700304/* 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700346 return dev;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700347out:
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
Deepak Saxena9c878962006-01-14 13:21:18 -0800354#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)
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800367static u16
Lennert Buytenhek3b68d702006-01-08 01:01:11 -0800368readword(unsigned long base_addr, int portno)
369{
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800370 return __raw_readl(base_addr + (portno << 1));
Lennert Buytenhek3b68d702006-01-08 01:01:11 -0800371}
372
373static void
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800374writeword(unsigned long base_addr, int portno, u16 value)
Lennert Buytenhek3b68d702006-01-08 01:01:11 -0800375{
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800376 __raw_writel(value, base_addr + (portno << 1));
Lennert Buytenhek3b68d702006-01-08 01:01:11 -0800377}
Lennert Buytenhek580d7b82006-01-14 13:21:16 -0800378#elif defined(CONFIG_ARCH_PNX010X)
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800379static u16
Lennert Buytenhek3b68d702006-01-08 01:01:11 -0800380readword(unsigned long base_addr, int portno)
381{
382 return inw(base_addr + (portno << 1));
383}
384
385static void
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800386writeword(unsigned long base_addr, int portno, u16 value)
Lennert Buytenhek3b68d702006-01-08 01:01:11 -0800387{
388 outw(value, base_addr + (portno << 1));
389}
390#else
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800391static u16
Lennert Buytenhek0d5affc2006-01-08 01:01:09 -0800392readword(unsigned long base_addr, int portno)
393{
394 return inw(base_addr + portno);
395}
396
397static void
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800398writeword(unsigned long base_addr, int portno, u16 value)
Lennert Buytenhek0d5affc2006-01-08 01:01:09 -0800399{
400 outw(value, base_addr + portno);
401}
Lennert Buytenhek3b68d702006-01-08 01:01:11 -0800402#endif
Lennert Buytenhek0d5affc2006-01-08 01:01:09 -0800403
Lennert Buytenhek084f7462006-01-08 01:01:12 -0800404static void
405readwords(unsigned long base_addr, int portno, void *buf, int length)
406{
407 u8 *buf8 = (u8 *)buf;
408
409 do {
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800410 u16 tmp16;
Lennert Buytenhek084f7462006-01-08 01:01:12 -0800411
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800412 tmp16 = readword(base_addr, portno);
413 *buf8++ = (u8)tmp16;
414 *buf8++ = (u8)(tmp16 >> 8);
Lennert Buytenhek084f7462006-01-08 01:01:12 -0800415 } 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 {
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800424 u16 tmp16;
Lennert Buytenhek084f7462006-01-08 01:01:12 -0800425
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800426 tmp16 = *buf8++;
427 tmp16 |= (*buf8++) << 8;
428 writeword(base_addr, portno, tmp16);
Lennert Buytenhek084f7462006-01-08 01:01:12 -0800429 } while (--length);
430}
431
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800432static u16
433readreg(struct net_device *dev, u16 regno)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700434{
Lennert Buytenhek3eaa5e72006-01-08 01:01:10 -0800435 writeword(dev->base_addr, ADD_PORT, regno);
436 return readword(dev->base_addr, DATA_PORT);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700437}
438
439static void
Lennert Buytenheka07f0db2006-01-14 13:21:17 -0800440writereg(struct net_device *dev, u16 regno, u16 value)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700441{
Lennert Buytenhek3eaa5e72006-01-08 01:01:10 -0800442 writeword(dev->base_addr, ADD_PORT, regno);
443 writeword(dev->base_addr, DATA_PORT, value);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700444}
445
Linus Torvalds1da177e2005-04-16 15:20:36 -0700446static 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
Deepak Saxena6f519162005-09-09 13:02:07 -0700491#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);
David Howells7d12e782006-10-05 14:55:46 +0100499 net_interrupt(dev->irq, dev);
Deepak Saxena6f519162005-09-09 13:02:07 -0700500 enable_irq(dev->irq);
501}
502#endif
503
Stephen Hemminger15d23e72009-03-26 15:11:43 +0000504static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519/* 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;
Denis Vlasenko01bdc032005-07-31 22:34:50 -0700531 int tmp;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700532 unsigned rev_type = 0;
533 int eeprom_buff[CHKSUM_LEN];
534 int retval;
535
Linus Torvalds1da177e2005-04-16 15:20:36 -0700536 /* 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
Lennert Buytenhek277cb102006-01-08 01:01:14 -0800552#ifdef CONFIG_ARCH_PNX010X
dmitry pervushin0dd3c782005-06-20 15:32:54 -0700553 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 /* 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 */
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -0800587 writeword(ioaddr, ADD_PORT, 0x0114);
588 writeword(ioaddr, DATA_PORT, 0x0040);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589#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)
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -0800599 if ((readword(ioaddr & ~3, ADD_PORT) & ADD_MASK) != ADD_SIG) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700600 printk(KERN_ERR "%s: bad signature 0x%x\n",
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -0800601 dev->name, readword(ioaddr & ~3, ADD_PORT));
Linus Torvalds1da177e2005-04-16 15:20:36 -0700602 retval = -ENODEV;
603 goto out2;
604 }
605 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700606
607 ioaddr &= ~3;
George G. Davis9e1402a2006-11-16 14:50:14 -0500608 printk(KERN_DEBUG "PP_addr at %x[%x]: 0x%x\n",
609 ioaddr, ADD_PORT, readword(ioaddr, ADD_PORT));
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -0800610 writeword(ioaddr, ADD_PORT, PP_ChipID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700611
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -0800612 tmp = readword(ioaddr, DATA_PORT);
Denis Vlasenko01bdc032005-07-31 22:34:50 -0700613 if (tmp != CHIP_EISA_ID_SIG) {
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -0800614 printk(KERN_DEBUG "%s: incorrect signature at %x[%x]: 0x%x!="
Denis Vlasenko01bdc032005-07-31 22:34:50 -0700615 CHIP_EISA_ID_SIG_STR "\n",
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -0800616 dev->name, ioaddr, DATA_PORT, tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 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);
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400648
Linus Torvalds1da177e2005-04-16 15:20:36 -0700649 /* 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++;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400672
Linus Torvalds1da177e2005-04-16 15:20:36 -0700673 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
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400688 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
Linus Torvalds1da177e2005-04-16 15:20:36 -0700689 (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 }
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400697
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700706 however. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400707
Linus Torvalds1da177e2005-04-16 15:20:36 -0700708 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)
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400724 lp->adapter_cnf |= A_CNF_AUI | A_CNF_10B_T |
Linus Torvalds1da177e2005-04-16 15:20:36 -0700725 A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400726
Linus Torvalds1da177e2005-04-16 15:20:36 -0700727 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. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400732 if (lp->chip_type == CS8900)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700733 lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400734
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 printk( "[Cirrus EEPROM] ");
736 }
737
738 printk("\n");
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400739
Linus Torvalds1da177e2005-04-16 15:20:36 -0700740 /* 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)) !=
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400754 (EEPROM_OK|EEPROM_PRESENT))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700755 printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400756
Linus Torvalds1da177e2005-04-16 15:20:36 -0700757 } else {
758 /* This reads an extended EEPROM that is not documented
759 in the CS8900 datasheet. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400760
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 /* 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) {
Gilles Chanteperdrix0ac4ed92008-09-26 15:44:43 +0100820#ifdef CONFIG_CS89x0_NONISA_IRQ
Linus Torvalds1da177e2005-04-16 15:20:36 -0700821 i = cs8900_irq_map[0];
822#else
823 /* Translate the IRQ using the IRQ mapping table. */
Denis Chengff8ac602007-09-02 18:30:18 +0800824 if (i >= ARRAY_SIZE(cs8900_irq_map))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700825 printk("\ncs89x0: invalid ISA interrupt number %d\n", i);
826 else
827 i = cs8900_irq_map[i];
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400828
Linus Torvalds1da177e2005-04-16 15:20:36 -0700829 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. */
Johannes Berge1749612008-10-27 15:59:26 -0700859 printk(", MAC %pM", dev->dev_addr);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700860
Stephen Hemminger15d23e72009-03-26 15:11:43 +0000861 dev->netdev_ops = &net_ops;
862 dev->watchdog_timeo = HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700863
864 printk("\n");
865 if (net_debug)
866 printk("cs89x0_probe1() successful\n");
b1fc5502005-05-12 20:11:55 -0400867
868 retval = register_netdev(dev);
869 if (retval)
870 goto out3;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700871 return 0;
b1fc5502005-05-12 20:11:55 -0400872out3:
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -0800873 writeword(dev->base_addr, ADD_PORT, PP_ChipID);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874out2:
875 release_region(ioaddr & ~3, NETCARD_IO_EXTENT);
876out1:
877 return retval;
878}
879
Jeff Garzik6aa20a22006-09-13 13:24:59 -0400880
Linus Torvalds1da177e2005-04-16 15:20:36 -0700881/*********************************
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001009
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 lp->stats.rx_packets++;
1030 lp->stats.rx_bytes += length;
1031}
1032
1033#endif /* ALLOW_DMA */
1034
Hannes Ederdac499f2008-12-25 23:56:45 -08001035static void __init reset_chip(struct net_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001036{
Gilles Chanteperdrix0ac4ed92008-09-26 15:44:43 +01001037#if !defined(CONFIG_MACH_MX31ADS)
Deepak Saxena9c878962006-01-14 13:21:18 -08001038#if !defined(CONFIG_MACH_IXDP2351) && !defined(CONFIG_ARCH_IXDP2X01)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001039 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
Deepak Saxena9c878962006-01-14 13:21:18 -08001049#if !defined(CONFIG_MACH_IXDP2351) && !defined(CONFIG_ARCH_IXDP2X01)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001050 if (lp->chip_type != CS8900) {
1051 /* Hardware problem requires PNP registers to be reconfigured after a reset */
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -08001052 writeword(ioaddr, ADD_PORT, PP_CS8920_ISAINT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001053 outb(dev->irq, ioaddr + DATA_PORT);
1054 outb(0, ioaddr + DATA_PORT + 1);
1055
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -08001056 writeword(ioaddr, ADD_PORT, PP_CS8920_ISAMemB);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001057 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 ;
Gilles Chanteperdrix0ac4ed92008-09-26 15:44:43 +01001066#endif /* !CONFIG_MACH_MX31ADS */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001067}
1068
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001069
Linus Torvalds1da177e2005-04-16 15:20:36 -07001070static 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;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001076 /* control the DC to DC convertor in the SelfControl register.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001077 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
Lennert Buytenhek974dffc2006-01-08 01:01:06 -08001187 writeword(dev->base_addr, TX_CMD_PORT, TX_AFTER_ALL);
1188 writeword(dev->base_addr, TX_LEN_PORT, ETH_ZLEN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189
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 */
Lennert Buytenhek084f7462006-01-08 01:01:12 -08001198 writewords(dev->base_addr, TX_FRAME_PORT,test_packet,(ETH_ZLEN+1) >>1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001199
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
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001245
Linus Torvalds1da177e2005-04-16 15:20:36 -07001246static 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. */
Denis Chengff8ac602007-09-02 18:30:18 +08001253 for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254 if (cs8900_irq_map[i] == irq)
1255 break;
1256 /* Not found */
Denis Chengff8ac602007-09-02 18:30:18 +08001257 if (i == ARRAY_SIZE(cs8900_irq_map))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001258 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
Lennert Buytenhek277cb102006-01-08 01:01:14 -08001283#if !defined(CONFIG_SH_HICOSH4) && !defined(CONFIG_ARCH_PNX010X) /* uses irq#1, so this won't work */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001284 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 {
Gilles Chanteperdrix0ac4ed92008-09-26 15:44:43 +01001314#ifndef CONFIG_CS89x0_NONISA_IRQ
Linus Torvalds1da177e2005-04-16 15:20:36 -07001315 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 }
Lennert Buytenhek277cb102006-01-08 01:01:14 -08001399#ifdef CONFIG_ARCH_PNX010X
dmitry pervushin0dd3c782005-06-20 15:32:54 -07001400 result = A_CNF_10B_T;
1401#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001402 if (!result) {
1403 printk(KERN_ERR "%s: EEPROM is configured for unavailable media\n", dev->name);
Wang Chen17a94402008-05-30 11:18:55 +08001404release_dma:
1405#if ALLOW_DMA
1406 free_dma(dev->dma);
Wang Chen17a94402008-05-30 11:18:55 +08001407release_irq:
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408 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);
Wang Chen17a94402008-05-30 11:18:55 +08001454 goto release_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001455 }
1456 switch(result) {
1457 case DETECTED_NONE:
1458 printk(KERN_ERR "%s: no network cable attached to configured media\n", dev->name);
Wang Chen17a94402008-05-30 11:18:55 +08001459 goto release_dma;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001460 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);
Dongdong Deng79fbe132009-07-12 20:27:06 +00001527 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001528
1529 if (net_debug > 3) {
1530 printk("%s: sent %d byte packet of type %x\n",
1531 dev->name, skb->len,
1532 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1533 }
1534
1535 /* keep the upload from being interrupted, since we
1536 ask the chip to start transmitting before the
1537 whole packet has been completely uploaded. */
1538
Dongdong Deng79fbe132009-07-12 20:27:06 +00001539 spin_lock_irqsave(&lp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001540 netif_stop_queue(dev);
1541
1542 /* initiate a transmit sequence */
Lennert Buytenhek974dffc2006-01-08 01:01:06 -08001543 writeword(dev->base_addr, TX_CMD_PORT, lp->send_cmd);
1544 writeword(dev->base_addr, TX_LEN_PORT, skb->len);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001545
1546 /* Test to see if the chip has allocated memory for the packet */
1547 if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1548 /*
1549 * Gasp! It hasn't. But that shouldn't happen since
1550 * we're waiting for TxOk, so return 1 and requeue this packet.
1551 */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001552
Dongdong Deng79fbe132009-07-12 20:27:06 +00001553 spin_unlock_irqrestore(&lp->lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001554 if (net_debug) printk("cs89x0: Tx buffer not free!\n");
Patrick McHardy5b548142009-06-12 06:22:29 +00001555 return NETDEV_TX_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001556 }
1557 /* Write the contents of the packet */
Lennert Buytenhek084f7462006-01-08 01:01:12 -08001558 writewords(dev->base_addr, TX_FRAME_PORT,skb->data,(skb->len+1) >>1);
Dongdong Deng79fbe132009-07-12 20:27:06 +00001559 spin_unlock_irqrestore(&lp->lock, flags);
Ian Campbelle1699f52005-07-28 01:07:34 -07001560 lp->stats.tx_bytes += skb->len;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001561 dev->trans_start = jiffies;
1562 dev_kfree_skb (skb);
1563
1564 /*
1565 * We DO NOT call netif_wake_queue() here.
1566 * We also DO NOT call netif_start_queue().
1567 *
1568 * Either of these would cause another bottom half run through
1569 * net_send_packet() before this packet has fully gone out. That causes
1570 * us to hit the "Gasp!" above and the send is rescheduled. it runs like
1571 * a dog. We just return and wait for the Tx completion interrupt handler
1572 * to restart the netdevice layer
1573 */
1574
1575 return 0;
1576}
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001577
Linus Torvalds1da177e2005-04-16 15:20:36 -07001578/* The typical workload of the driver:
1579 Handle the network interface interrupts. */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001580
David Howells7d12e782006-10-05 14:55:46 +01001581static irqreturn_t net_interrupt(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001582{
1583 struct net_device *dev = dev_id;
1584 struct net_local *lp;
1585 int ioaddr, status;
1586 int handled = 0;
1587
1588 ioaddr = dev->base_addr;
1589 lp = netdev_priv(dev);
1590
1591 /* we MUST read all the events out of the ISQ, otherwise we'll never
1592 get interrupted again. As a consequence, we can't have any limit
1593 on the number of times we loop in the interrupt handler. The
1594 hardware guarantees that eventually we'll run out of events. Of
1595 course, if you're on a slow machine, and packets are arriving
1596 faster than you can read them off, you're screwed. Hasta la
1597 vista, baby! */
Lennert Buytenhek974dffc2006-01-08 01:01:06 -08001598 while ((status = readword(dev->base_addr, ISQ_PORT))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001599 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
1600 handled = 1;
1601 switch(status & ISQ_EVENT_MASK) {
1602 case ISQ_RECEIVER_EVENT:
1603 /* Got a packet(s). */
1604 net_rx(dev);
1605 break;
1606 case ISQ_TRANSMITTER_EVENT:
1607 lp->stats.tx_packets++;
1608 netif_wake_queue(dev); /* Inform upper layers. */
1609 if ((status & ( TX_OK |
1610 TX_LOST_CRS |
1611 TX_SQE_ERROR |
1612 TX_LATE_COL |
1613 TX_16_COL)) != TX_OK) {
1614 if ((status & TX_OK) == 0) lp->stats.tx_errors++;
1615 if (status & TX_LOST_CRS) lp->stats.tx_carrier_errors++;
1616 if (status & TX_SQE_ERROR) lp->stats.tx_heartbeat_errors++;
1617 if (status & TX_LATE_COL) lp->stats.tx_window_errors++;
1618 if (status & TX_16_COL) lp->stats.tx_aborted_errors++;
1619 }
1620 break;
1621 case ISQ_BUFFER_EVENT:
1622 if (status & READY_FOR_TX) {
1623 /* we tried to transmit a packet earlier,
1624 but inexplicably ran out of buffers.
1625 That shouldn't happen since we only ever
1626 load one packet. Shrug. Do the right
1627 thing anyway. */
1628 netif_wake_queue(dev); /* Inform upper layers. */
1629 }
1630 if (status & TX_UNDERRUN) {
1631 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
1632 lp->send_underrun++;
1633 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
1634 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
1635 /* transmit cycle is done, although
1636 frame wasn't transmitted - this
1637 avoids having to wait for the upper
1638 layers to timeout on us, in the
1639 event of a tx underrun */
1640 netif_wake_queue(dev); /* Inform upper layers. */
1641 }
1642#if ALLOW_DMA
1643 if (lp->use_dma && (status & RX_DMA)) {
1644 int count = readreg(dev, PP_DmaFrameCnt);
1645 while(count) {
1646 if (net_debug > 5)
1647 printk("%s: receiving %d DMA frames\n", dev->name, count);
1648 if (net_debug > 2 && count >1)
1649 printk("%s: receiving %d DMA frames\n", dev->name, count);
1650 dma_rx(dev);
1651 if (--count == 0)
1652 count = readreg(dev, PP_DmaFrameCnt);
1653 if (net_debug > 2 && count > 0)
1654 printk("%s: continuing with %d DMA frames\n", dev->name, count);
1655 }
1656 }
1657#endif
1658 break;
1659 case ISQ_RX_MISS_EVENT:
1660 lp->stats.rx_missed_errors += (status >>6);
1661 break;
1662 case ISQ_TX_COL_EVENT:
1663 lp->stats.collisions += (status >>6);
1664 break;
1665 }
1666 }
1667 return IRQ_RETVAL(handled);
1668}
1669
1670static void
1671count_rx_errors(int status, struct net_local *lp)
1672{
1673 lp->stats.rx_errors++;
1674 if (status & RX_RUNT) lp->stats.rx_length_errors++;
1675 if (status & RX_EXTRA_DATA) lp->stats.rx_length_errors++;
1676 if (status & RX_CRC_ERROR) if (!(status & (RX_EXTRA_DATA|RX_RUNT)))
1677 /* per str 172 */
1678 lp->stats.rx_crc_errors++;
1679 if (status & RX_DRIBBLE) lp->stats.rx_frame_errors++;
1680 return;
1681}
1682
1683/* We have a good packet(s), get it/them out of the buffers. */
1684static void
1685net_rx(struct net_device *dev)
1686{
1687 struct net_local *lp = netdev_priv(dev);
1688 struct sk_buff *skb;
1689 int status, length;
1690
1691 int ioaddr = dev->base_addr;
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -08001692 status = readword(ioaddr, RX_FRAME_PORT);
1693 length = readword(ioaddr, RX_FRAME_PORT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001694
1695 if ((status & RX_OK) == 0) {
1696 count_rx_errors(status, lp);
1697 return;
1698 }
1699
1700 /* Malloc up new buffer. */
1701 skb = dev_alloc_skb(length + 2);
1702 if (skb == NULL) {
1703#if 0 /* Again, this seems a cruel thing to do */
1704 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1705#endif
1706 lp->stats.rx_dropped++;
1707 return;
1708 }
1709 skb_reserve(skb, 2); /* longword align L3 header */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001710
Lennert Buytenhek084f7462006-01-08 01:01:12 -08001711 readwords(ioaddr, RX_FRAME_PORT, skb_put(skb, length), length >> 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001712 if (length & 1)
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -08001713 skb->data[length-1] = readword(ioaddr, RX_FRAME_PORT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001714
1715 if (net_debug > 3) {
1716 printk( "%s: received %d byte packet of type %x\n",
1717 dev->name, length,
1718 (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1719 }
1720
1721 skb->protocol=eth_type_trans(skb,dev);
1722 netif_rx(skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001723 lp->stats.rx_packets++;
1724 lp->stats.rx_bytes += length;
1725}
1726
1727#if ALLOW_DMA
1728static void release_dma_buff(struct net_local *lp)
1729{
1730 if (lp->dma_buff) {
1731 free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024));
1732 lp->dma_buff = NULL;
1733 }
1734}
1735#endif
1736
1737/* The inverse routine to net_open(). */
1738static int
1739net_close(struct net_device *dev)
1740{
1741#if ALLOW_DMA
1742 struct net_local *lp = netdev_priv(dev);
1743#endif
1744
1745 netif_stop_queue(dev);
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001746
Linus Torvalds1da177e2005-04-16 15:20:36 -07001747 writereg(dev, PP_RxCFG, 0);
1748 writereg(dev, PP_TxCFG, 0);
1749 writereg(dev, PP_BufCFG, 0);
1750 writereg(dev, PP_BusCTL, 0);
1751
1752 free_irq(dev->irq, dev);
1753
1754#if ALLOW_DMA
1755 if (lp->use_dma && lp->dma) {
1756 free_dma(dev->dma);
1757 release_dma_buff(lp);
1758 }
1759#endif
1760
1761 /* Update the statistics here. */
1762 return 0;
1763}
1764
1765/* Get the current statistics. This may be called with the card open or
1766 closed. */
1767static struct net_device_stats *
1768net_get_stats(struct net_device *dev)
1769{
1770 struct net_local *lp = netdev_priv(dev);
1771 unsigned long flags;
1772
1773 spin_lock_irqsave(&lp->lock, flags);
1774 /* Update the statistics from the device registers. */
1775 lp->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1776 lp->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1777 spin_unlock_irqrestore(&lp->lock, flags);
1778
1779 return &lp->stats;
1780}
1781
1782static void set_multicast_list(struct net_device *dev)
1783{
1784 struct net_local *lp = netdev_priv(dev);
1785 unsigned long flags;
1786
1787 spin_lock_irqsave(&lp->lock, flags);
1788 if(dev->flags&IFF_PROMISC)
1789 {
1790 lp->rx_mode = RX_ALL_ACCEPT;
1791 }
1792 else if((dev->flags&IFF_ALLMULTI)||dev->mc_list)
1793 {
1794 /* The multicast-accept list is initialized to accept-all, and we
1795 rely on higher-level filtering for now. */
1796 lp->rx_mode = RX_MULTCAST_ACCEPT;
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001797 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001798 else
1799 lp->rx_mode = 0;
1800
1801 writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1802
1803 /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
1804 writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
1805 (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
1806 spin_unlock_irqrestore(&lp->lock, flags);
1807}
1808
1809
1810static int set_mac_address(struct net_device *dev, void *p)
1811{
1812 int i;
1813 struct sockaddr *addr = p;
1814
Linus Torvalds1da177e2005-04-16 15:20:36 -07001815 if (netif_running(dev))
1816 return -EBUSY;
1817
1818 memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1819
Johannes Berge1749612008-10-27 15:59:26 -07001820 if (net_debug)
1821 printk("%s: Setting MAC address to %pM.\n",
1822 dev->name, dev->dev_addr);
1823
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824 /* set the Ethernet address */
1825 for (i=0; i < ETH_ALEN/2; i++)
1826 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1827
1828 return 0;
1829}
1830
1831#ifdef MODULE
1832
1833static struct net_device *dev_cs89x0;
1834
1835/*
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001836 * Support the 'debug' module parm even if we're compiled for non-debug to
1837 * avoid breaking someone's startup scripts
Linus Torvalds1da177e2005-04-16 15:20:36 -07001838 */
1839
1840static int io;
1841static int irq;
1842static int debug;
1843static char media[8];
1844static int duplex=-1;
1845
1846static int use_dma; /* These generate unused var warnings if ALLOW_DMA = 0 */
1847static int dma;
1848static int dmasize=16; /* or 64 */
1849
1850module_param(io, int, 0);
1851module_param(irq, int, 0);
1852module_param(debug, int, 0);
1853module_param_string(media, media, sizeof(media), 0);
1854module_param(duplex, int, 0);
1855module_param(dma , int, 0);
1856module_param(dmasize , int, 0);
1857module_param(use_dma , int, 0);
1858MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1859MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1860#if DEBUGGING
1861MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1862#else
1863MODULE_PARM_DESC(debug, "(ignored)");
1864#endif
1865MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1866/* No other value than -1 for duplex seems to be currently interpreted */
1867MODULE_PARM_DESC(duplex, "(ignored)");
1868#if ALLOW_DMA
1869MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1870MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1871MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1872#else
1873MODULE_PARM_DESC(dma , "(ignored)");
1874MODULE_PARM_DESC(dmasize , "(ignored)");
1875MODULE_PARM_DESC(use_dma , "(ignored)");
1876#endif
1877
Francois Camie1f8e872008-10-15 22:01:59 -07001878MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879MODULE_LICENSE("GPL");
1880
1881
1882/*
1883* media=t - specify media type
1884 or media=2
1885 or media=aui
1886 or medai=auto
1887* duplex=0 - specify forced half/full/autonegotiate duplex
1888* debug=# - debug level
1889
1890
1891* Default Chip Configuration:
1892 * DMA Burst = enabled
1893 * IOCHRDY Enabled = enabled
1894 * UseSA = enabled
1895 * CS8900 defaults to half-duplex if not specified on command-line
1896 * CS8920 defaults to autoneg if not specified on command-line
1897 * Use reset defaults for other config parameters
1898
1899* Assumptions:
1900 * media type specified is supported (circuitry is present)
1901 * if memory address is > 1MB, then required mem decode hw is present
1902 * if 10B-2, then agent other than driver will enable DC/DC converter
1903 (hw or software util)
1904
1905
1906*/
1907
Andrew Mortone26c1292006-08-14 22:59:59 -07001908int __init init_module(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001909{
1910 struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1911 struct net_local *lp;
1912 int ret = 0;
1913
1914#if DEBUGGING
1915 net_debug = debug;
1916#else
1917 debug = 0;
1918#endif
1919 if (!dev)
1920 return -ENOMEM;
1921
1922 dev->irq = irq;
1923 dev->base_addr = io;
1924 lp = netdev_priv(dev);
1925
1926#if ALLOW_DMA
1927 if (use_dma) {
1928 lp->use_dma = use_dma;
1929 lp->dma = dma;
1930 lp->dmasize = dmasize;
1931 }
1932#endif
1933
1934 spin_lock_init(&lp->lock);
1935
1936 /* boy, they'd better get these right */
1937 if (!strcmp(media, "rj45"))
1938 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1939 else if (!strcmp(media, "aui"))
1940 lp->adapter_cnf = A_CNF_MEDIA_AUI | A_CNF_AUI;
1941 else if (!strcmp(media, "bnc"))
1942 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1943 else
1944 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1945
1946 if (duplex==-1)
1947 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1948
1949 if (io == 0) {
1950 printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n");
1951 printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n");
1952 ret = -EPERM;
1953 goto out;
1954 } else if (io <= 0x1ff) {
1955 ret = -ENXIO;
1956 goto out;
1957 }
1958
1959#if ALLOW_DMA
1960 if (use_dma && dmasize != 16 && dmasize != 64) {
1961 printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize);
1962 ret = -EPERM;
1963 goto out;
1964 }
1965#endif
1966 ret = cs89x0_probe1(dev, io, 1);
1967 if (ret)
1968 goto out;
1969
Linus Torvalds1da177e2005-04-16 15:20:36 -07001970 dev_cs89x0 = dev;
1971 return 0;
1972out:
1973 free_netdev(dev);
1974 return ret;
1975}
1976
Al Viroafc8eb42006-06-14 18:50:53 -04001977void __exit
Linus Torvalds1da177e2005-04-16 15:20:36 -07001978cleanup_module(void)
1979{
1980 unregister_netdev(dev_cs89x0);
Lennert Buytenhekfc8c7d72006-01-08 01:01:08 -08001981 writeword(dev_cs89x0->base_addr, ADD_PORT, PP_ChipID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001982 release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1983 free_netdev(dev_cs89x0);
1984}
1985#endif /* MODULE */
Jeff Garzik6aa20a22006-09-13 13:24:59 -04001986
Linus Torvalds1da177e2005-04-16 15:20:36 -07001987/*
1988 * Local variables:
1989 * version-control: t
1990 * kept-new-versions: 5
1991 * c-indent-level: 8
1992 * tab-width: 8
1993 * End:
1994 *
1995 */