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