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