drivers/net/cs89x0.c

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