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/io.h>
 152 #include <asm/irq.h>
 153 #include <linux/atomic.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 #define CS89x0_NONISA_IRQ
 178 static unsigned int netcard_portlist[] __used __initdata = {IXDP2351_VIRT_CS8900_BASE, 0};
 179 static unsigned int cs8900_irq_map[] = {IRQ_IXDP2351_CS8900, 0, 0, 0};
 180 #elif defined(CONFIG_ARCH_IXDP2X01)
 181 #define CS89x0_NONISA_IRQ
 182 static unsigned int netcard_portlist[] __used __initdata = {IXDP2X01_CS8900_VIRT_BASE, 0};
 183 static unsigned int cs8900_irq_map[] = {IRQ_IXDP2X01_CS8900, 0, 0, 0};
 184 #else
 185 #ifndef CONFIG_CS89x0_PLATFORM
 186 static unsigned int netcard_portlist[] __used __initdata =
 187    { 0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240, 0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0};
 188 static unsigned int cs8900_irq_map[] = {10,11,12,5};
 189 #endif
 190 #endif
 191
 192 #if DEBUGGING
 193 static unsigned int net_debug = DEBUGGING;
 194 #else
 195 #define net_debug 0     /* gcc will remove all the debug code for us */
 196 #endif
 197
 198 /* The number of low I/O ports used by the ethercard. */
 199 #define NETCARD_IO_EXTENT       16
 200
 201 /* we allow the user to override various values normally set in the EEPROM */
 202 #define FORCE_RJ45      0x0001    /* pick one of these three */
 203 #define FORCE_AUI       0x0002
 204 #define FORCE_BNC       0x0004
 205
 206 #define FORCE_AUTO      0x0010    /* pick one of these three */
 207 #define FORCE_HALF      0x0020
 208 #define FORCE_FULL      0x0030
 209
 210 /* Information that need to be kept for each board. */
 211 struct net_local {
 212         int chip_type;          /* one of: CS8900, CS8920, CS8920M */
 213         char chip_revision;     /* revision letter of the chip ('A'...) */
 214         int send_cmd;           /* the proper send command: TX_NOW, TX_AFTER_381, or TX_AFTER_ALL */
 215         int auto_neg_cnf;       /* auto-negotiation word from EEPROM */
 216         int adapter_cnf;        /* adapter configuration from EEPROM */
 217         int isa_config;         /* ISA configuration from EEPROM */
 218         int irq_map;            /* IRQ map from EEPROM */
 219         int rx_mode;            /* what mode are we in? 0, RX_MULTCAST_ACCEPT, or RX_ALL_ACCEPT */
 220         int curr_rx_cfg;        /* a copy of PP_RxCFG */
 221         int linectl;            /* either 0 or LOW_RX_SQUELCH, depending on configuration. */
 222         int send_underrun;      /* keep track of how many underruns in a row we get */
 223         int force;              /* force various values; see FORCE* above. */
 224         spinlock_t lock;
 225 #if ALLOW_DMA
 226         int use_dma;            /* Flag: we're using dma */
 227         int dma;                /* DMA channel */
 228         int dmasize;            /* 16 or 64 */
 229         unsigned char *dma_buff;        /* points to the beginning of the buffer */
 230         unsigned char *end_dma_buff;    /* points to the end of the buffer */
 231         unsigned char *rx_dma_ptr;      /* points to the next packet  */
 232 #endif
 233 #ifdef CONFIG_CS89x0_PLATFORM
 234         void __iomem *virt_addr;/* Virtual address for accessing the CS89x0. */
 235         unsigned long phys_addr;/* Physical address for accessing the CS89x0. */
 236         unsigned long size;     /* Length of CS89x0 memory region. */
 237 #endif
 238 };
 239
 240 /* Index to functions, as function prototypes. */
 241
 242 static int cs89x0_probe1(struct net_device *dev, unsigned long ioaddr, int modular);
 243 static int net_open(struct net_device *dev);
 244 static netdev_tx_t net_send_packet(struct sk_buff *skb, struct net_device *dev);
 245 static irqreturn_t net_interrupt(int irq, void *dev_id);
 246 static void set_multicast_list(struct net_device *dev);
 247 static void net_timeout(struct net_device *dev);
 248 static void net_rx(struct net_device *dev);
 249 static int net_close(struct net_device *dev);
 250 static struct net_device_stats *net_get_stats(struct net_device *dev);
 251 static void reset_chip(struct net_device *dev);
 252 static int get_eeprom_data(struct net_device *dev, int off, int len, int *buffer);
 253 static int get_eeprom_cksum(int off, int len, int *buffer);
 254 static int set_mac_address(struct net_device *dev, void *addr);
 255 static void count_rx_errors(int status, struct net_device *dev);
 256 #ifdef CONFIG_NET_POLL_CONTROLLER
 257 static void net_poll_controller(struct net_device *dev);
 258 #endif
 259 #if ALLOW_DMA
 260 static void get_dma_channel(struct net_device *dev);
 261 static void release_dma_buff(struct net_local *lp);
 262 #endif
 263
 264 /* Example routines you must write ;->. */
 265 #define tx_done(dev) 1
 266
 267 /*
 268  * Permit 'cs89x0_dma=N' in the kernel boot environment
 269  */
 270 #if !defined(MODULE) && (ALLOW_DMA != 0)
 271 static int g_cs89x0_dma;
 272
 273 static int __init dma_fn(char *str)
 274 {
 275         g_cs89x0_dma = simple_strtol(str,NULL,0);
 276         return 1;
 277 }
 278
 279 __setup("cs89x0_dma=", dma_fn);
 280 #endif  /* !defined(MODULE) && (ALLOW_DMA != 0) */
 281
 282 #ifndef MODULE
 283 static int g_cs89x0_media__force;
 284
 285 static int __init media_fn(char *str)
 286 {
 287         if (!strcmp(str, "rj45")) g_cs89x0_media__force = FORCE_RJ45;
 288         else if (!strcmp(str, "aui")) g_cs89x0_media__force = FORCE_AUI;
 289         else if (!strcmp(str, "bnc")) g_cs89x0_media__force = FORCE_BNC;
 290         return 1;
 291 }
 292
 293 __setup("cs89x0_media=", media_fn);
 294
 295
 296 #ifndef CONFIG_CS89x0_PLATFORM
 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 #endif
 347
 348 #if defined(CONFIG_MACH_IXDP2351)
 349 static u16
 350 readword(unsigned long base_addr, int portno)
 351 {
 352         return __raw_readw(base_addr + (portno << 1));
 353 }
 354
 355 static void
 356 writeword(unsigned long base_addr, int portno, u16 value)
 357 {
 358         __raw_writew(value, base_addr + (portno << 1));
 359 }
 360 #elif defined(CONFIG_ARCH_IXDP2X01)
 361 static u16
 362 readword(unsigned long base_addr, int portno)
 363 {
 364         return __raw_readl(base_addr + (portno << 1));
 365 }
 366
 367 static void
 368 writeword(unsigned long base_addr, int portno, u16 value)
 369 {
 370         __raw_writel(value, base_addr + (portno << 1));
 371 }
 372 #else
 373 static u16
 374 readword(unsigned long base_addr, int portno)
 375 {
 376         return inw(base_addr + portno);
 377 }
 378
 379 static void
 380 writeword(unsigned long base_addr, int portno, u16 value)
 381 {
 382         outw(value, base_addr + portno);
 383 }
 384 #endif
 385
 386 static void
 387 readwords(unsigned long base_addr, int portno, void *buf, int length)
 388 {
 389         u8 *buf8 = (u8 *)buf;
 390
 391         do {
 392                 u16 tmp16;
 393
 394                 tmp16 = readword(base_addr, portno);
 395                 *buf8++ = (u8)tmp16;
 396                 *buf8++ = (u8)(tmp16 >> 8);
 397         } while (--length);
 398 }
 399
 400 static void
 401 writewords(unsigned long base_addr, int portno, void *buf, int length)
 402 {
 403         u8 *buf8 = (u8 *)buf;
 404
 405         do {
 406                 u16 tmp16;
 407
 408                 tmp16 = *buf8++;
 409                 tmp16 |= (*buf8++) << 8;
 410                 writeword(base_addr, portno, tmp16);
 411         } while (--length);
 412 }
 413
 414 static u16
 415 readreg(struct net_device *dev, u16 regno)
 416 {
 417         writeword(dev->base_addr, ADD_PORT, regno);
 418         return readword(dev->base_addr, DATA_PORT);
 419 }
 420
 421 static void
 422 writereg(struct net_device *dev, u16 regno, u16 value)
 423 {
 424         writeword(dev->base_addr, ADD_PORT, regno);
 425         writeword(dev->base_addr, DATA_PORT, value);
 426 }
 427
 428 static int __init
 429 wait_eeprom_ready(struct net_device *dev)
 430 {
 431         int timeout = jiffies;
 432         /* check to see if the EEPROM is ready, a timeout is used -
 433            just in case EEPROM is ready when SI_BUSY in the
 434            PP_SelfST is clear */
 435         while(readreg(dev, PP_SelfST) & SI_BUSY)
 436                 if (jiffies - timeout >= 40)
 437                         return -1;
 438         return 0;
 439 }
 440
 441 static int __init
 442 get_eeprom_data(struct net_device *dev, int off, int len, int *buffer)
 443 {
 444         int i;
 445
 446         if (net_debug > 3) printk("EEPROM data from %x for %x:\n",off,len);
 447         for (i = 0; i < len; i++) {
 448                 if (wait_eeprom_ready(dev) < 0) return -1;
 449                 /* Now send the EEPROM read command and EEPROM location to read */
 450                 writereg(dev, PP_EECMD, (off + i) | EEPROM_READ_CMD);
 451                 if (wait_eeprom_ready(dev) < 0) return -1;
 452                 buffer[i] = readreg(dev, PP_EEData);
 453                 if (net_debug > 3) printk("%04x ", buffer[i]);
 454         }
 455         if (net_debug > 3) printk("\n");
 456         return 0;
 457 }
 458
 459 static int  __init
 460 get_eeprom_cksum(int off, int len, int *buffer)
 461 {
 462         int i, cksum;
 463
 464         cksum = 0;
 465         for (i = 0; i < len; i++)
 466                 cksum += buffer[i];
 467         cksum &= 0xffff;
 468         if (cksum == 0)
 469                 return 0;
 470         return -1;
 471 }
 472
 473 #ifdef CONFIG_NET_POLL_CONTROLLER
 474 /*
 475  * Polling receive - used by netconsole and other diagnostic tools
 476  * to allow network i/o with interrupts disabled.
 477  */
 478 static void net_poll_controller(struct net_device *dev)
 479 {
 480         disable_irq(dev->irq);
 481         net_interrupt(dev->irq, dev);
 482         enable_irq(dev->irq);
 483 }
 484 #endif
 485
 486 static const struct net_device_ops net_ops = {
 487         .ndo_open               = net_open,
 488         .ndo_stop               = net_close,
 489         .ndo_tx_timeout         = net_timeout,
 490         .ndo_start_xmit         = net_send_packet,
 491         .ndo_get_stats          = net_get_stats,
 492         .ndo_set_rx_mode        = set_multicast_list,
 493         .ndo_set_mac_address    = set_mac_address,
 494 #ifdef CONFIG_NET_POLL_CONTROLLER
 495         .ndo_poll_controller    = net_poll_controller,
 496 #endif
 497         .ndo_change_mtu         = eth_change_mtu,
 498         .ndo_validate_addr      = eth_validate_addr,
 499 };
 500
 501 /* This is the real probe routine.  Linux has a history of friendly device
 502    probes on the ISA bus.  A good device probes avoids doing writes, and
 503    verifies that the correct device exists and functions.
 504    Return 0 on success.
 505  */
 506
 507 static int __init
 508 cs89x0_probe1(struct net_device *dev, unsigned long ioaddr, int modular)
 509 {
 510         struct net_local *lp = netdev_priv(dev);
 511         static unsigned version_printed;
 512         int i;
 513         int tmp;
 514         unsigned rev_type = 0;
 515         int eeprom_buff[CHKSUM_LEN];
 516         int retval;
 517
 518         /* Initialize the device structure. */
 519         if (!modular) {
 520                 memset(lp, 0, sizeof(*lp));
 521                 spin_lock_init(&lp->lock);
 522 #ifndef MODULE
 523 #if ALLOW_DMA
 524                 if (g_cs89x0_dma) {
 525                         lp->use_dma = 1;
 526                         lp->dma = g_cs89x0_dma;
 527                         lp->dmasize = 16;       /* Could make this an option... */
 528                 }
 529 #endif
 530                 lp->force = g_cs89x0_media__force;
 531 #endif
 532
 533         }
 534
 535         /* Grab the region so we can find another board if autoIRQ fails. */
 536         /* WTF is going on here? */
 537         if (!request_region(ioaddr & ~3, NETCARD_IO_EXTENT, DRV_NAME)) {
 538                 printk(KERN_ERR "%s: request_region(0x%lx, 0x%x) failed\n",
 539                                 DRV_NAME, ioaddr, NETCARD_IO_EXTENT);
 540                 retval = -EBUSY;
 541                 goto out1;
 542         }
 543
 544         /* if they give us an odd I/O address, then do ONE write to
 545            the address port, to get it back to address zero, where we
 546            expect to find the EISA signature word. An IO with a base of 0x3
 547            will skip the test for the ADD_PORT. */
 548         if (ioaddr & 1) {
 549                 if (net_debug > 1)
 550                         printk(KERN_INFO "%s: odd ioaddr 0x%lx\n", dev->name, ioaddr);
 551                 if ((ioaddr & 2) != 2)
 552                         if ((readword(ioaddr & ~3, ADD_PORT) & ADD_MASK) != ADD_SIG) {
 553                                 printk(KERN_ERR "%s: bad signature 0x%x\n",
 554                                         dev->name, readword(ioaddr & ~3, ADD_PORT));
 555                                 retval = -ENODEV;
 556                                 goto out2;
 557                         }
 558         }
 559
 560         ioaddr &= ~3;
 561         printk(KERN_DEBUG "PP_addr at %lx[%x]: 0x%x\n",
 562                         ioaddr, ADD_PORT, readword(ioaddr, ADD_PORT));
 563         writeword(ioaddr, ADD_PORT, PP_ChipID);
 564
 565         tmp = readword(ioaddr, DATA_PORT);
 566         if (tmp != CHIP_EISA_ID_SIG) {
 567                 printk(KERN_DEBUG "%s: incorrect signature at %lx[%x]: 0x%x!="
 568                         CHIP_EISA_ID_SIG_STR "\n",
 569                         dev->name, ioaddr, DATA_PORT, tmp);
 570                 retval = -ENODEV;
 571                 goto out2;
 572         }
 573
 574         /* Fill in the 'dev' fields. */
 575         dev->base_addr = ioaddr;
 576
 577         /* get the chip type */
 578         rev_type = readreg(dev, PRODUCT_ID_ADD);
 579         lp->chip_type = rev_type &~ REVISON_BITS;
 580         lp->chip_revision = ((rev_type & REVISON_BITS) >> 8) + 'A';
 581
 582         /* Check the chip type and revision in order to set the correct send command
 583         CS8920 revision C and CS8900 revision F can use the faster send. */
 584         lp->send_cmd = TX_AFTER_381;
 585         if (lp->chip_type == CS8900 && lp->chip_revision >= 'F')
 586                 lp->send_cmd = TX_NOW;
 587         if (lp->chip_type != CS8900 && lp->chip_revision >= 'C')
 588                 lp->send_cmd = TX_NOW;
 589
 590         if (net_debug  &&  version_printed++ == 0)
 591                 printk(version);
 592
 593         printk(KERN_INFO "%s: cs89%c0%s rev %c found at %#3lx ",
 594                dev->name,
 595                lp->chip_type==CS8900?'0':'2',
 596                lp->chip_type==CS8920M?"M":"",
 597                lp->chip_revision,
 598                dev->base_addr);
 599
 600         reset_chip(dev);
 601
 602         /* Here we read the current configuration of the chip. If there
 603            is no Extended EEPROM then the idea is to not disturb the chip
 604            configuration, it should have been correctly setup by automatic
 605            EEPROM read on reset. So, if the chip says it read the EEPROM
 606            the driver will always do *something* instead of complain that
 607            adapter_cnf is 0. */
 608
 609
 610         if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) ==
 611               (EEPROM_OK|EEPROM_PRESENT)) {
 612                 /* Load the MAC. */
 613                 for (i=0; i < ETH_ALEN/2; i++) {
 614                         unsigned int Addr;
 615                         Addr = readreg(dev, PP_IA+i*2);
 616                         dev->dev_addr[i*2] = Addr & 0xFF;
 617                         dev->dev_addr[i*2+1] = Addr >> 8;
 618                 }
 619
 620                 /* Load the Adapter Configuration.
 621                    Note:  Barring any more specific information from some
 622                    other source (ie EEPROM+Schematics), we would not know
 623                    how to operate a 10Base2 interface on the AUI port.
 624                    However, since we  do read the status of HCB1 and use
 625                    settings that always result in calls to control_dc_dc(dev,0)
 626                    a BNC interface should work if the enable pin
 627                    (dc/dc converter) is on HCB1. It will be called AUI
 628                    however. */
 629
 630                 lp->adapter_cnf = 0;
 631                 i = readreg(dev, PP_LineCTL);
 632                 /* Preserve the setting of the HCB1 pin. */
 633                 if ((i & (HCB1 | HCB1_ENBL)) ==  (HCB1 | HCB1_ENBL))
 634                         lp->adapter_cnf |= A_CNF_DC_DC_POLARITY;
 635                 /* Save the sqelch bit */
 636                 if ((i & LOW_RX_SQUELCH) == LOW_RX_SQUELCH)
 637                         lp->adapter_cnf |= A_CNF_EXTND_10B_2 | A_CNF_LOW_RX_SQUELCH;
 638                 /* Check if the card is in 10Base-t only mode */
 639                 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == 0)
 640                         lp->adapter_cnf |=  A_CNF_10B_T | A_CNF_MEDIA_10B_T;
 641                 /* Check if the card is in AUI only mode */
 642                 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUI_ONLY)
 643                         lp->adapter_cnf |=  A_CNF_AUI | A_CNF_MEDIA_AUI;
 644                 /* Check if the card is in Auto mode. */
 645                 if ((i & (AUI_ONLY | AUTO_AUI_10BASET)) == AUTO_AUI_10BASET)
 646                         lp->adapter_cnf |=  A_CNF_AUI | A_CNF_10B_T |
 647                         A_CNF_MEDIA_AUI | A_CNF_MEDIA_10B_T | A_CNF_MEDIA_AUTO;
 648
 649                 if (net_debug > 1)
 650                         printk(KERN_INFO "%s: PP_LineCTL=0x%x, adapter_cnf=0x%x\n",
 651                                         dev->name, i, lp->adapter_cnf);
 652
 653                 /* IRQ. Other chips already probe, see below. */
 654                 if (lp->chip_type == CS8900)
 655                         lp->isa_config = readreg(dev, PP_CS8900_ISAINT) & INT_NO_MASK;
 656
 657                 printk( "[Cirrus EEPROM] ");
 658         }
 659
 660         printk("\n");
 661
 662         /* First check to see if an EEPROM is attached. */
 663
 664         if ((readreg(dev, PP_SelfST) & EEPROM_PRESENT) == 0)
 665                 printk(KERN_WARNING "cs89x0: No EEPROM, relying on command line....\n");
 666         else if (get_eeprom_data(dev, START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
 667                 printk(KERN_WARNING "\ncs89x0: EEPROM read failed, relying on command line.\n");
 668         } else if (get_eeprom_cksum(START_EEPROM_DATA,CHKSUM_LEN,eeprom_buff) < 0) {
 669                 /* Check if the chip was able to read its own configuration starting
 670                    at 0 in the EEPROM*/
 671                 if ((readreg(dev, PP_SelfST) & (EEPROM_OK | EEPROM_PRESENT)) !=
 672                     (EEPROM_OK|EEPROM_PRESENT))
 673                         printk(KERN_WARNING "cs89x0: Extended EEPROM checksum bad and no Cirrus EEPROM, relying on command line\n");
 674
 675         } else {
 676                 /* This reads an extended EEPROM that is not documented
 677                    in the CS8900 datasheet. */
 678
 679                 /* get transmission control word  but keep the autonegotiation bits */
 680                 if (!lp->auto_neg_cnf) lp->auto_neg_cnf = eeprom_buff[AUTO_NEG_CNF_OFFSET/2];
 681                 /* Store adapter configuration */
 682                 if (!lp->adapter_cnf) lp->adapter_cnf = eeprom_buff[ADAPTER_CNF_OFFSET/2];
 683                 /* Store ISA configuration */
 684                 lp->isa_config = eeprom_buff[ISA_CNF_OFFSET/2];
 685                 dev->mem_start = eeprom_buff[PACKET_PAGE_OFFSET/2] << 8;
 686
 687                 /* eeprom_buff has 32-bit ints, so we can't just memcpy it */
 688                 /* store the initial memory base address */
 689                 for (i = 0; i < ETH_ALEN/2; i++) {
 690                         dev->dev_addr[i*2] = eeprom_buff[i];
 691                         dev->dev_addr[i*2+1] = eeprom_buff[i] >> 8;
 692                 }
 693                 if (net_debug > 1)
 694                         printk(KERN_DEBUG "%s: new adapter_cnf: 0x%x\n",
 695                                 dev->name, lp->adapter_cnf);
 696         }
 697
 698         /* allow them to force multiple transceivers.  If they force multiple, autosense */
 699         {
 700                 int count = 0;
 701                 if (lp->force & FORCE_RJ45)     {lp->adapter_cnf |= A_CNF_10B_T; count++; }
 702                 if (lp->force & FORCE_AUI)      {lp->adapter_cnf |= A_CNF_AUI; count++; }
 703                 if (lp->force & FORCE_BNC)      {lp->adapter_cnf |= A_CNF_10B_2; count++; }
 704                 if (count > 1)                  {lp->adapter_cnf |= A_CNF_MEDIA_AUTO; }
 705                 else if (lp->force & FORCE_RJ45){lp->adapter_cnf |= A_CNF_MEDIA_10B_T; }
 706                 else if (lp->force & FORCE_AUI) {lp->adapter_cnf |= A_CNF_MEDIA_AUI; }
 707                 else if (lp->force & FORCE_BNC) {lp->adapter_cnf |= A_CNF_MEDIA_10B_2; }
 708         }
 709
 710         if (net_debug > 1)
 711                 printk(KERN_DEBUG "%s: after force 0x%x, adapter_cnf=0x%x\n",
 712                         dev->name, lp->force, lp->adapter_cnf);
 713
 714         /* FIXME: We don't let you set dc-dc polarity or low RX squelch from the command line: add it here */
 715
 716         /* FIXME: We don't let you set the IMM bit from the command line: add it to lp->auto_neg_cnf here */
 717
 718         /* FIXME: we don't set the Ethernet address on the command line.  Use
 719            ifconfig IFACE hw ether AABBCCDDEEFF */
 720
 721         printk(KERN_INFO "cs89x0 media %s%s%s",
 722                (lp->adapter_cnf & A_CNF_10B_T)?"RJ-45,":"",
 723                (lp->adapter_cnf & A_CNF_AUI)?"AUI,":"",
 724                (lp->adapter_cnf & A_CNF_10B_2)?"BNC,":"");
 725
 726         lp->irq_map = 0xffff;
 727
 728         /* If this is a CS8900 then no pnp soft */
 729         if (lp->chip_type != CS8900 &&
 730             /* Check if the ISA IRQ has been set  */
 731                 (i = readreg(dev, PP_CS8920_ISAINT) & 0xff,
 732                  (i != 0 && i < CS8920_NO_INTS))) {
 733                 if (!dev->irq)
 734                         dev->irq = i;
 735         } else {
 736                 i = lp->isa_config & INT_NO_MASK;
 737 #ifndef CONFIG_CS89x0_PLATFORM
 738                 if (lp->chip_type == CS8900) {
 739 #ifdef CS89x0_NONISA_IRQ
 740                         i = cs8900_irq_map[0];
 741 #else
 742                         /* Translate the IRQ using the IRQ mapping table. */
 743                         if (i >= ARRAY_SIZE(cs8900_irq_map))
 744                                 printk("\ncs89x0: invalid ISA interrupt number %d\n", i);
 745                         else
 746                                 i = cs8900_irq_map[i];
 747
 748                         lp->irq_map = CS8900_IRQ_MAP; /* fixed IRQ map for CS8900 */
 749                 } else {
 750                         int irq_map_buff[IRQ_MAP_LEN/2];
 751
 752                         if (get_eeprom_data(dev, IRQ_MAP_EEPROM_DATA,
 753                                             IRQ_MAP_LEN/2,
 754                                             irq_map_buff) >= 0) {
 755                                 if ((irq_map_buff[0] & 0xff) == PNP_IRQ_FRMT)
 756                                         lp->irq_map = (irq_map_buff[0]>>8) | (irq_map_buff[1] << 8);
 757                         }
 758 #endif
 759                 }
 760 #endif
 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 = netdev_alloc_skb(dev, 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 #ifndef CONFIG_CS89x0_PLATFORM
1172                 /* Search the mapping table for the corresponding IRQ pin. */
1173                 for (i = 0; i != ARRAY_SIZE(cs8900_irq_map); i++)
1174                         if (cs8900_irq_map[i] == irq)
1175                                 break;
1176                 /* Not found */
1177                 if (i == ARRAY_SIZE(cs8900_irq_map))
1178                         i = 3;
1179 #else
1180                 /* INTRQ0 pin is used for interrupt generation. */
1181                 i = 0;
1182 #endif
1183                 writereg(dev, PP_CS8900_ISAINT, i);
1184         } else {
1185                 writereg(dev, PP_CS8920_ISAINT, irq);
1186         }
1187 }
1188
1189 /* Open/initialize the board.  This is called (in the current kernel)
1190    sometime after booting when the 'ifconfig' program is run.
1191
1192    This routine should set everything up anew at each open, even
1193    registers that "should" only need to be set once at boot, so that
1194    there is non-reboot way to recover if something goes wrong.
1195    */
1196
1197 /* AKPM: do we need to do any locking here? */
1198
1199 static int
1200 net_open(struct net_device *dev)
1201 {
1202         struct net_local *lp = netdev_priv(dev);
1203         int result = 0;
1204         int i;
1205         int ret;
1206
1207         if (dev->irq < 2) {
1208                 /* Allow interrupts to be generated by the chip */
1209 /* Cirrus' release had this: */
1210 #if 0
1211                 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1212 #endif
1213 /* And 2.3.47 had this: */
1214                 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1215
1216                 for (i = 2; i < CS8920_NO_INTS; i++) {
1217                         if ((1 << i) & lp->irq_map) {
1218                                 if (request_irq(i, net_interrupt, 0, dev->name, dev) == 0) {
1219                                         dev->irq = i;
1220                                         write_irq(dev, lp->chip_type, i);
1221                                         /* writereg(dev, PP_BufCFG, GENERATE_SW_INTERRUPT); */
1222                                         break;
1223                                 }
1224                         }
1225                 }
1226
1227                 if (i >= CS8920_NO_INTS) {
1228                         writereg(dev, PP_BusCTL, 0);    /* disable interrupts. */
1229                         printk(KERN_ERR "cs89x0: can't get an interrupt\n");
1230                         ret = -EAGAIN;
1231                         goto bad_out;
1232                 }
1233         }
1234         else
1235         {
1236 #if !defined(CS89x0_NONISA_IRQ) && !defined(CONFIG_CS89x0_PLATFORM)
1237                 if (((1 << dev->irq) & lp->irq_map) == 0) {
1238                         printk(KERN_ERR "%s: IRQ %d is not in our map of allowable IRQs, which is %x\n",
1239                                dev->name, dev->irq, lp->irq_map);
1240                         ret = -EAGAIN;
1241                         goto bad_out;
1242                 }
1243 #endif
1244 /* FIXME: Cirrus' release had this: */
1245                 writereg(dev, PP_BusCTL, readreg(dev, PP_BusCTL)|ENABLE_IRQ );
1246 /* And 2.3.47 had this: */
1247 #if 0
1248                 writereg(dev, PP_BusCTL, ENABLE_IRQ | MEMORY_ON);
1249 #endif
1250                 write_irq(dev, lp->chip_type, dev->irq);
1251                 ret = request_irq(dev->irq, net_interrupt, 0, dev->name, dev);
1252                 if (ret) {
1253                         printk(KERN_ERR "cs89x0: request_irq(%d) failed\n", dev->irq);
1254                         goto bad_out;
1255                 }
1256         }
1257
1258 #if ALLOW_DMA
1259         if (lp->use_dma) {
1260                 if (lp->isa_config & ANY_ISA_DMA) {
1261                         unsigned long flags;
1262                         lp->dma_buff = (unsigned char *)__get_dma_pages(GFP_KERNEL,
1263                                                         get_order(lp->dmasize * 1024));
1264
1265                         if (!lp->dma_buff) {
1266                                 printk(KERN_ERR "%s: cannot get %dK memory for DMA\n", dev->name, lp->dmasize);
1267                                 goto release_irq;
1268                         }
1269                         if (net_debug > 1) {
1270                                 printk( "%s: dma %lx %lx\n",
1271                                         dev->name,
1272                                         (unsigned long)lp->dma_buff,
1273                                         (unsigned long)isa_virt_to_bus(lp->dma_buff));
1274                         }
1275                         if ((unsigned long) lp->dma_buff >= MAX_DMA_ADDRESS ||
1276                             !dma_page_eq(lp->dma_buff, lp->dma_buff+lp->dmasize*1024-1)) {
1277                                 printk(KERN_ERR "%s: not usable as DMA buffer\n", dev->name);
1278                                 goto release_irq;
1279                         }
1280                         memset(lp->dma_buff, 0, lp->dmasize * 1024);    /* Why? */
1281                         if (request_dma(dev->dma, dev->name)) {
1282                                 printk(KERN_ERR "%s: cannot get dma channel %d\n", dev->name, dev->dma);
1283                                 goto release_irq;
1284                         }
1285                         write_dma(dev, lp->chip_type, dev->dma);
1286                         lp->rx_dma_ptr = lp->dma_buff;
1287                         lp->end_dma_buff = lp->dma_buff + lp->dmasize*1024;
1288                         spin_lock_irqsave(&lp->lock, flags);
1289                         disable_dma(dev->dma);
1290                         clear_dma_ff(dev->dma);
1291                         set_dma_mode(dev->dma, DMA_RX_MODE); /* auto_init as well */
1292                         set_dma_addr(dev->dma, isa_virt_to_bus(lp->dma_buff));
1293                         set_dma_count(dev->dma, lp->dmasize*1024);
1294                         enable_dma(dev->dma);
1295                         spin_unlock_irqrestore(&lp->lock, flags);
1296                 }
1297         }
1298 #endif  /* ALLOW_DMA */
1299
1300         /* set the Ethernet address */
1301         for (i=0; i < ETH_ALEN/2; i++)
1302                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1303
1304         /* while we're testing the interface, leave interrupts disabled */
1305         writereg(dev, PP_BusCTL, MEMORY_ON);
1306
1307         /* Set the LineCTL quintuplet based on adapter configuration read from EEPROM */
1308         if ((lp->adapter_cnf & A_CNF_EXTND_10B_2) && (lp->adapter_cnf & A_CNF_LOW_RX_SQUELCH))
1309                 lp->linectl = LOW_RX_SQUELCH;
1310         else
1311                 lp->linectl = 0;
1312
1313         /* check to make sure that they have the "right" hardware available */
1314         switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1315         case A_CNF_MEDIA_10B_T: result = lp->adapter_cnf & A_CNF_10B_T; break;
1316         case A_CNF_MEDIA_AUI:   result = lp->adapter_cnf & A_CNF_AUI; break;
1317         case A_CNF_MEDIA_10B_2: result = lp->adapter_cnf & A_CNF_10B_2; break;
1318         default: result = lp->adapter_cnf & (A_CNF_10B_T | A_CNF_AUI | A_CNF_10B_2);
1319         }
1320         if (!result) {
1321                 printk(KERN_ERR "%s: EEPROM is configured for unavailable media\n", dev->name);
1322 release_dma:
1323 #if ALLOW_DMA
1324                 free_dma(dev->dma);
1325 release_irq:
1326                 release_dma_buff(lp);
1327 #endif
1328                 writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) & ~(SERIAL_TX_ON | SERIAL_RX_ON));
1329                 free_irq(dev->irq, dev);
1330                 ret = -EAGAIN;
1331                 goto bad_out;
1332         }
1333
1334         /* set the hardware to the configured choice */
1335         switch(lp->adapter_cnf & A_CNF_MEDIA_TYPE) {
1336         case A_CNF_MEDIA_10B_T:
1337                 result = detect_tp(dev);
1338                 if (result==DETECTED_NONE) {
1339                         printk(KERN_WARNING "%s: 10Base-T (RJ-45) has no cable\n", dev->name);
1340                         if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1341                                 result = DETECTED_RJ45H; /* Yes! I don't care if I see a link pulse */
1342                 }
1343                 break;
1344         case A_CNF_MEDIA_AUI:
1345                 result = detect_aui(dev);
1346                 if (result==DETECTED_NONE) {
1347                         printk(KERN_WARNING "%s: 10Base-5 (AUI) has no cable\n", dev->name);
1348                         if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1349                                 result = DETECTED_AUI; /* Yes! I don't care if I see a carrrier */
1350                 }
1351                 break;
1352         case A_CNF_MEDIA_10B_2:
1353                 result = detect_bnc(dev);
1354                 if (result==DETECTED_NONE) {
1355                         printk(KERN_WARNING "%s: 10Base-2 (BNC) has no cable\n", dev->name);
1356                         if (lp->auto_neg_cnf & IMM_BIT) /* check "ignore missing media" bit */
1357                                 result = DETECTED_BNC; /* Yes! I don't care if I can xmit a packet */
1358                 }
1359                 break;
1360         case A_CNF_MEDIA_AUTO:
1361                 writereg(dev, PP_LineCTL, lp->linectl | AUTO_AUI_10BASET);
1362                 if (lp->adapter_cnf & A_CNF_10B_T)
1363                         if ((result = detect_tp(dev)) != DETECTED_NONE)
1364                                 break;
1365                 if (lp->adapter_cnf & A_CNF_AUI)
1366                         if ((result = detect_aui(dev)) != DETECTED_NONE)
1367                                 break;
1368                 if (lp->adapter_cnf & A_CNF_10B_2)
1369                         if ((result = detect_bnc(dev)) != DETECTED_NONE)
1370                                 break;
1371                 printk(KERN_ERR "%s: no media detected\n", dev->name);
1372                 goto release_dma;
1373         }
1374         switch(result) {
1375         case DETECTED_NONE:
1376                 printk(KERN_ERR "%s: no network cable attached to configured media\n", dev->name);
1377                 goto release_dma;
1378         case DETECTED_RJ45H:
1379                 printk(KERN_INFO "%s: using half-duplex 10Base-T (RJ-45)\n", dev->name);
1380                 break;
1381         case DETECTED_RJ45F:
1382                 printk(KERN_INFO "%s: using full-duplex 10Base-T (RJ-45)\n", dev->name);
1383                 break;
1384         case DETECTED_AUI:
1385                 printk(KERN_INFO "%s: using 10Base-5 (AUI)\n", dev->name);
1386                 break;
1387         case DETECTED_BNC:
1388                 printk(KERN_INFO "%s: using 10Base-2 (BNC)\n", dev->name);
1389                 break;
1390         }
1391
1392         /* Turn on both receive and transmit operations */
1393         writereg(dev, PP_LineCTL, readreg(dev, PP_LineCTL) | SERIAL_RX_ON | SERIAL_TX_ON);
1394
1395         /* Receive only error free packets addressed to this card */
1396         lp->rx_mode = 0;
1397         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT);
1398
1399         lp->curr_rx_cfg = RX_OK_ENBL | RX_CRC_ERROR_ENBL;
1400
1401         if (lp->isa_config & STREAM_TRANSFER)
1402                 lp->curr_rx_cfg |= RX_STREAM_ENBL;
1403 #if ALLOW_DMA
1404         set_dma_cfg(dev);
1405 #endif
1406         writereg(dev, PP_RxCFG, lp->curr_rx_cfg);
1407
1408         writereg(dev, PP_TxCFG, TX_LOST_CRS_ENBL | TX_SQE_ERROR_ENBL | TX_OK_ENBL |
1409                 TX_LATE_COL_ENBL | TX_JBR_ENBL | TX_ANY_COL_ENBL | TX_16_COL_ENBL);
1410
1411         writereg(dev, PP_BufCFG, READY_FOR_TX_ENBL | RX_MISS_COUNT_OVRFLOW_ENBL |
1412 #if ALLOW_DMA
1413                 dma_bufcfg(dev) |
1414 #endif
1415                 TX_COL_COUNT_OVRFLOW_ENBL | TX_UNDERRUN_ENBL);
1416
1417         /* now that we've got our act together, enable everything */
1418         writereg(dev, PP_BusCTL, ENABLE_IRQ
1419                  | (dev->mem_start?MEMORY_ON : 0) /* turn memory on */
1420 #if ALLOW_DMA
1421                  | dma_busctl(dev)
1422 #endif
1423                  );
1424         netif_start_queue(dev);
1425         if (net_debug > 1)
1426                 printk("cs89x0: net_open() succeeded\n");
1427         return 0;
1428 bad_out:
1429         return ret;
1430 }
1431
1432 static void net_timeout(struct net_device *dev)
1433 {
1434         /* If we get here, some higher level has decided we are broken.
1435            There should really be a "kick me" function call instead. */
1436         if (net_debug > 0) printk("%s: transmit timed out, %s?\n", dev->name,
1437                    tx_done(dev) ? "IRQ conflict ?" : "network cable problem");
1438         /* Try to restart the adaptor. */
1439         netif_wake_queue(dev);
1440 }
1441
1442 static netdev_tx_t net_send_packet(struct sk_buff *skb,struct net_device *dev)
1443 {
1444         struct net_local *lp = netdev_priv(dev);
1445         unsigned long flags;
1446
1447         if (net_debug > 3) {
1448                 printk("%s: sent %d byte packet of type %x\n",
1449                         dev->name, skb->len,
1450                         (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1451         }
1452
1453         /* keep the upload from being interrupted, since we
1454                   ask the chip to start transmitting before the
1455                   whole packet has been completely uploaded. */
1456
1457         spin_lock_irqsave(&lp->lock, flags);
1458         netif_stop_queue(dev);
1459
1460         /* initiate a transmit sequence */
1461         writeword(dev->base_addr, TX_CMD_PORT, lp->send_cmd);
1462         writeword(dev->base_addr, TX_LEN_PORT, skb->len);
1463
1464         /* Test to see if the chip has allocated memory for the packet */
1465         if ((readreg(dev, PP_BusST) & READY_FOR_TX_NOW) == 0) {
1466                 /*
1467                  * Gasp!  It hasn't.  But that shouldn't happen since
1468                  * we're waiting for TxOk, so return 1 and requeue this packet.
1469                  */
1470
1471                 spin_unlock_irqrestore(&lp->lock, flags);
1472                 if (net_debug) printk("cs89x0: Tx buffer not free!\n");
1473                 return NETDEV_TX_BUSY;
1474         }
1475         /* Write the contents of the packet */
1476         writewords(dev->base_addr, TX_FRAME_PORT,skb->data,(skb->len+1) >>1);
1477         spin_unlock_irqrestore(&lp->lock, flags);
1478         dev->stats.tx_bytes += skb->len;
1479         dev_kfree_skb (skb);
1480
1481         /*
1482          * We DO NOT call netif_wake_queue() here.
1483          * We also DO NOT call netif_start_queue().
1484          *
1485          * Either of these would cause another bottom half run through
1486          * net_send_packet() before this packet has fully gone out.  That causes
1487          * us to hit the "Gasp!" above and the send is rescheduled.  it runs like
1488          * a dog.  We just return and wait for the Tx completion interrupt handler
1489          * to restart the netdevice layer
1490          */
1491
1492         return NETDEV_TX_OK;
1493 }
1494
1495 /* The typical workload of the driver:
1496    Handle the network interface interrupts. */
1497
1498 static irqreturn_t net_interrupt(int irq, void *dev_id)
1499 {
1500         struct net_device *dev = dev_id;
1501         struct net_local *lp;
1502         int ioaddr, status;
1503         int handled = 0;
1504
1505         ioaddr = dev->base_addr;
1506         lp = netdev_priv(dev);
1507
1508         /* we MUST read all the events out of the ISQ, otherwise we'll never
1509            get interrupted again.  As a consequence, we can't have any limit
1510            on the number of times we loop in the interrupt handler.  The
1511            hardware guarantees that eventually we'll run out of events.  Of
1512            course, if you're on a slow machine, and packets are arriving
1513            faster than you can read them off, you're screwed.  Hasta la
1514            vista, baby!  */
1515         while ((status = readword(dev->base_addr, ISQ_PORT))) {
1516                 if (net_debug > 4)printk("%s: event=%04x\n", dev->name, status);
1517                 handled = 1;
1518                 switch(status & ISQ_EVENT_MASK) {
1519                 case ISQ_RECEIVER_EVENT:
1520                         /* Got a packet(s). */
1521                         net_rx(dev);
1522                         break;
1523                 case ISQ_TRANSMITTER_EVENT:
1524                         dev->stats.tx_packets++;
1525                         netif_wake_queue(dev);  /* Inform upper layers. */
1526                         if ((status & ( TX_OK |
1527                                         TX_LOST_CRS |
1528                                         TX_SQE_ERROR |
1529                                         TX_LATE_COL |
1530                                         TX_16_COL)) != TX_OK) {
1531                                 if ((status & TX_OK) == 0)
1532                                         dev->stats.tx_errors++;
1533                                 if (status & TX_LOST_CRS)
1534                                         dev->stats.tx_carrier_errors++;
1535                                 if (status & TX_SQE_ERROR)
1536                                         dev->stats.tx_heartbeat_errors++;
1537                                 if (status & TX_LATE_COL)
1538                                         dev->stats.tx_window_errors++;
1539                                 if (status & TX_16_COL)
1540                                         dev->stats.tx_aborted_errors++;
1541                         }
1542                         break;
1543                 case ISQ_BUFFER_EVENT:
1544                         if (status & READY_FOR_TX) {
1545                                 /* we tried to transmit a packet earlier,
1546                                    but inexplicably ran out of buffers.
1547                                    That shouldn't happen since we only ever
1548                                    load one packet.  Shrug.  Do the right
1549                                    thing anyway. */
1550                                 netif_wake_queue(dev);  /* Inform upper layers. */
1551                         }
1552                         if (status & TX_UNDERRUN) {
1553                                 if (net_debug > 0) printk("%s: transmit underrun\n", dev->name);
1554                                 lp->send_underrun++;
1555                                 if (lp->send_underrun == 3) lp->send_cmd = TX_AFTER_381;
1556                                 else if (lp->send_underrun == 6) lp->send_cmd = TX_AFTER_ALL;
1557                                 /* transmit cycle is done, although
1558                                    frame wasn't transmitted - this
1559                                    avoids having to wait for the upper
1560                                    layers to timeout on us, in the
1561                                    event of a tx underrun */
1562                                 netif_wake_queue(dev);  /* Inform upper layers. */
1563                         }
1564 #if ALLOW_DMA
1565                         if (lp->use_dma && (status & RX_DMA)) {
1566                                 int count = readreg(dev, PP_DmaFrameCnt);
1567                                 while(count) {
1568                                         if (net_debug > 5)
1569                                                 printk("%s: receiving %d DMA frames\n", dev->name, count);
1570                                         if (net_debug > 2 && count >1)
1571                                                 printk("%s: receiving %d DMA frames\n", dev->name, count);
1572                                         dma_rx(dev);
1573                                         if (--count == 0)
1574                                                 count = readreg(dev, PP_DmaFrameCnt);
1575                                         if (net_debug > 2 && count > 0)
1576                                                 printk("%s: continuing with %d DMA frames\n", dev->name, count);
1577                                 }
1578                         }
1579 #endif
1580                         break;
1581                 case ISQ_RX_MISS_EVENT:
1582                         dev->stats.rx_missed_errors += (status >> 6);
1583                         break;
1584                 case ISQ_TX_COL_EVENT:
1585                         dev->stats.collisions += (status >> 6);
1586                         break;
1587                 }
1588         }
1589         return IRQ_RETVAL(handled);
1590 }
1591
1592 static void
1593 count_rx_errors(int status, struct net_device *dev)
1594 {
1595         dev->stats.rx_errors++;
1596         if (status & RX_RUNT)
1597                 dev->stats.rx_length_errors++;
1598         if (status & RX_EXTRA_DATA)
1599                 dev->stats.rx_length_errors++;
1600         if ((status & RX_CRC_ERROR) && !(status & (RX_EXTRA_DATA|RX_RUNT)))
1601                 /* per str 172 */
1602                 dev->stats.rx_crc_errors++;
1603         if (status & RX_DRIBBLE)
1604                 dev->stats.rx_frame_errors++;
1605 }
1606
1607 /* We have a good packet(s), get it/them out of the buffers. */
1608 static void
1609 net_rx(struct net_device *dev)
1610 {
1611         struct sk_buff *skb;
1612         int status, length;
1613
1614         int ioaddr = dev->base_addr;
1615         status = readword(ioaddr, RX_FRAME_PORT);
1616         length = readword(ioaddr, RX_FRAME_PORT);
1617
1618         if ((status & RX_OK) == 0) {
1619                 count_rx_errors(status, dev);
1620                 return;
1621         }
1622
1623         /* Malloc up new buffer. */
1624         skb = netdev_alloc_skb(dev, length + 2);
1625         if (skb == NULL) {
1626 #if 0           /* Again, this seems a cruel thing to do */
1627                 printk(KERN_WARNING "%s: Memory squeeze, dropping packet.\n", dev->name);
1628 #endif
1629                 dev->stats.rx_dropped++;
1630                 return;
1631         }
1632         skb_reserve(skb, 2);    /* longword align L3 header */
1633
1634         readwords(ioaddr, RX_FRAME_PORT, skb_put(skb, length), length >> 1);
1635         if (length & 1)
1636                 skb->data[length-1] = readword(ioaddr, RX_FRAME_PORT);
1637
1638         if (net_debug > 3) {
1639                 printk( "%s: received %d byte packet of type %x\n",
1640                         dev->name, length,
1641                         (skb->data[ETH_ALEN+ETH_ALEN] << 8) | skb->data[ETH_ALEN+ETH_ALEN+1]);
1642         }
1643
1644         skb->protocol=eth_type_trans(skb,dev);
1645         netif_rx(skb);
1646         dev->stats.rx_packets++;
1647         dev->stats.rx_bytes += length;
1648 }
1649
1650 #if ALLOW_DMA
1651 static void release_dma_buff(struct net_local *lp)
1652 {
1653         if (lp->dma_buff) {
1654                 free_pages((unsigned long)(lp->dma_buff), get_order(lp->dmasize * 1024));
1655                 lp->dma_buff = NULL;
1656         }
1657 }
1658 #endif
1659
1660 /* The inverse routine to net_open(). */
1661 static int
1662 net_close(struct net_device *dev)
1663 {
1664 #if ALLOW_DMA
1665         struct net_local *lp = netdev_priv(dev);
1666 #endif
1667
1668         netif_stop_queue(dev);
1669
1670         writereg(dev, PP_RxCFG, 0);
1671         writereg(dev, PP_TxCFG, 0);
1672         writereg(dev, PP_BufCFG, 0);
1673         writereg(dev, PP_BusCTL, 0);
1674
1675         free_irq(dev->irq, dev);
1676
1677 #if ALLOW_DMA
1678         if (lp->use_dma && lp->dma) {
1679                 free_dma(dev->dma);
1680                 release_dma_buff(lp);
1681         }
1682 #endif
1683
1684         /* Update the statistics here. */
1685         return 0;
1686 }
1687
1688 /* Get the current statistics.  This may be called with the card open or
1689    closed. */
1690 static struct net_device_stats *
1691 net_get_stats(struct net_device *dev)
1692 {
1693         struct net_local *lp = netdev_priv(dev);
1694         unsigned long flags;
1695
1696         spin_lock_irqsave(&lp->lock, flags);
1697         /* Update the statistics from the device registers. */
1698         dev->stats.rx_missed_errors += (readreg(dev, PP_RxMiss) >> 6);
1699         dev->stats.collisions += (readreg(dev, PP_TxCol) >> 6);
1700         spin_unlock_irqrestore(&lp->lock, flags);
1701
1702         return &dev->stats;
1703 }
1704
1705 static void set_multicast_list(struct net_device *dev)
1706 {
1707         struct net_local *lp = netdev_priv(dev);
1708         unsigned long flags;
1709
1710         spin_lock_irqsave(&lp->lock, flags);
1711         if(dev->flags&IFF_PROMISC)
1712         {
1713                 lp->rx_mode = RX_ALL_ACCEPT;
1714         }
1715         else if ((dev->flags & IFF_ALLMULTI) || !netdev_mc_empty(dev))
1716         {
1717                 /* The multicast-accept list is initialized to accept-all, and we
1718                    rely on higher-level filtering for now. */
1719                 lp->rx_mode = RX_MULTCAST_ACCEPT;
1720         }
1721         else
1722                 lp->rx_mode = 0;
1723
1724         writereg(dev, PP_RxCTL, DEF_RX_ACCEPT | lp->rx_mode);
1725
1726         /* in promiscuous mode, we accept errored packets, so we have to enable interrupts on them also */
1727         writereg(dev, PP_RxCFG, lp->curr_rx_cfg |
1728              (lp->rx_mode == RX_ALL_ACCEPT? (RX_CRC_ERROR_ENBL|RX_RUNT_ENBL|RX_EXTRA_DATA_ENBL) : 0));
1729         spin_unlock_irqrestore(&lp->lock, flags);
1730 }
1731
1732
1733 static int set_mac_address(struct net_device *dev, void *p)
1734 {
1735         int i;
1736         struct sockaddr *addr = p;
1737
1738         if (netif_running(dev))
1739                 return -EBUSY;
1740
1741         memcpy(dev->dev_addr, addr->sa_data, dev->addr_len);
1742
1743         if (net_debug)
1744                 printk("%s: Setting MAC address to %pM.\n",
1745                        dev->name, dev->dev_addr);
1746
1747         /* set the Ethernet address */
1748         for (i=0; i < ETH_ALEN/2; i++)
1749                 writereg(dev, PP_IA+i*2, dev->dev_addr[i*2] | (dev->dev_addr[i*2+1] << 8));
1750
1751         return 0;
1752 }
1753
1754 #if defined(MODULE) && !defined(CONFIG_CS89x0_PLATFORM)
1755
1756 static struct net_device *dev_cs89x0;
1757
1758 /*
1759  * Support the 'debug' module parm even if we're compiled for non-debug to
1760  * avoid breaking someone's startup scripts
1761  */
1762
1763 static int io;
1764 static int irq;
1765 static int debug;
1766 static char media[8];
1767 static int duplex=-1;
1768
1769 static int use_dma;                     /* These generate unused var warnings if ALLOW_DMA = 0 */
1770 static int dma;
1771 static int dmasize=16;                  /* or 64 */
1772
1773 module_param(io, int, 0);
1774 module_param(irq, int, 0);
1775 module_param(debug, int, 0);
1776 module_param_string(media, media, sizeof(media), 0);
1777 module_param(duplex, int, 0);
1778 module_param(dma , int, 0);
1779 module_param(dmasize , int, 0);
1780 module_param(use_dma , int, 0);
1781 MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1782 MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1783 #if DEBUGGING
1784 MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1785 #else
1786 MODULE_PARM_DESC(debug, "(ignored)");
1787 #endif
1788 MODULE_PARM_DESC(media, "Set cs89x0 adapter(s) media type(s) (rj45,bnc,aui)");
1789 /* No other value than -1 for duplex seems to be currently interpreted */
1790 MODULE_PARM_DESC(duplex, "(ignored)");
1791 #if ALLOW_DMA
1792 MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1793 MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1794 MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1795 #else
1796 MODULE_PARM_DESC(dma , "(ignored)");
1797 MODULE_PARM_DESC(dmasize , "(ignored)");
1798 MODULE_PARM_DESC(use_dma , "(ignored)");
1799 #endif
1800
1801 MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
1802 MODULE_LICENSE("GPL");
1803
1804
1805 /*
1806 * media=t             - specify media type
1807    or media=2
1808    or media=aui
1809    or medai=auto
1810 * duplex=0            - specify forced half/full/autonegotiate duplex
1811 * debug=#             - debug level
1812
1813
1814 * Default Chip Configuration:
1815   * DMA Burst = enabled
1816   * IOCHRDY Enabled = enabled
1817     * UseSA = enabled
1818     * CS8900 defaults to half-duplex if not specified on command-line
1819     * CS8920 defaults to autoneg if not specified on command-line
1820     * Use reset defaults for other config parameters
1821
1822 * Assumptions:
1823   * media type specified is supported (circuitry is present)
1824   * if memory address is > 1MB, then required mem decode hw is present
1825   * if 10B-2, then agent other than driver will enable DC/DC converter
1826     (hw or software util)
1827
1828
1829 */
1830
1831 int __init init_module(void)
1832 {
1833         struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1834         struct net_local *lp;
1835         int ret = 0;
1836
1837 #if DEBUGGING
1838         net_debug = debug;
1839 #else
1840         debug = 0;
1841 #endif
1842         if (!dev)
1843                 return -ENOMEM;
1844
1845         dev->irq = irq;
1846         dev->base_addr = io;
1847         lp = netdev_priv(dev);
1848
1849 #if ALLOW_DMA
1850         if (use_dma) {
1851                 lp->use_dma = use_dma;
1852                 lp->dma = dma;
1853                 lp->dmasize = dmasize;
1854         }
1855 #endif
1856
1857         spin_lock_init(&lp->lock);
1858
1859         /* boy, they'd better get these right */
1860         if (!strcmp(media, "rj45"))
1861                 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1862         else if (!strcmp(media, "aui"))
1863                 lp->adapter_cnf = A_CNF_MEDIA_AUI   | A_CNF_AUI;
1864         else if (!strcmp(media, "bnc"))
1865                 lp->adapter_cnf = A_CNF_MEDIA_10B_2 | A_CNF_10B_2;
1866         else
1867                 lp->adapter_cnf = A_CNF_MEDIA_10B_T | A_CNF_10B_T;
1868
1869         if (duplex==-1)
1870                 lp->auto_neg_cnf = AUTO_NEG_ENABLE;
1871
1872         if (io == 0) {
1873                 printk(KERN_ERR "cs89x0.c: Module autoprobing not allowed.\n");
1874                 printk(KERN_ERR "cs89x0.c: Append io=0xNNN\n");
1875                 ret = -EPERM;
1876                 goto out;
1877         } else if (io <= 0x1ff) {
1878                 ret = -ENXIO;
1879                 goto out;
1880         }
1881
1882 #if ALLOW_DMA
1883         if (use_dma && dmasize != 16 && dmasize != 64) {
1884                 printk(KERN_ERR "cs89x0.c: dma size must be either 16K or 64K, not %dK\n", dmasize);
1885                 ret = -EPERM;
1886                 goto out;
1887         }
1888 #endif
1889         ret = cs89x0_probe1(dev, io, 1);
1890         if (ret)
1891                 goto out;
1892
1893         dev_cs89x0 = dev;
1894         return 0;
1895 out:
1896         free_netdev(dev);
1897         return ret;
1898 }
1899
1900 void __exit
1901 cleanup_module(void)
1902 {
1903         unregister_netdev(dev_cs89x0);
1904         writeword(dev_cs89x0->base_addr, ADD_PORT, PP_ChipID);
1905         release_region(dev_cs89x0->base_addr, NETCARD_IO_EXTENT);
1906         free_netdev(dev_cs89x0);
1907 }
1908 #endif /* MODULE && !CONFIG_CS89x0_PLATFORM */
1909
1910 #ifdef CONFIG_CS89x0_PLATFORM
1911 static int __init cs89x0_platform_probe(struct platform_device *pdev)
1912 {
1913         struct net_device *dev = alloc_etherdev(sizeof(struct net_local));
1914         struct net_local *lp;
1915         struct resource *mem_res;
1916         int err;
1917
1918         if (!dev)
1919                 return -ENOMEM;
1920
1921         lp = netdev_priv(dev);
1922
1923         mem_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1924         dev->irq = platform_get_irq(pdev, 0);
1925         if (mem_res == NULL || dev->irq <= 0) {
1926                 dev_warn(&dev->dev, "memory/interrupt resource missing.\n");
1927                 err = -ENXIO;
1928                 goto free;
1929         }
1930
1931         lp->phys_addr = mem_res->start;
1932         lp->size = resource_size(mem_res);
1933         if (!request_mem_region(lp->phys_addr, lp->size, DRV_NAME)) {
1934                 dev_warn(&dev->dev, "request_mem_region() failed.\n");
1935                 err = -EBUSY;
1936                 goto free;
1937         }
1938
1939         lp->virt_addr = ioremap(lp->phys_addr, lp->size);
1940         if (!lp->virt_addr) {
1941                 dev_warn(&dev->dev, "ioremap() failed.\n");
1942                 err = -ENOMEM;
1943                 goto release;
1944         }
1945
1946         err = cs89x0_probe1(dev, (unsigned long)lp->virt_addr, 0);
1947         if (err) {
1948                 dev_warn(&dev->dev, "no cs8900 or cs8920 detected.\n");
1949                 goto unmap;
1950         }
1951
1952         platform_set_drvdata(pdev, dev);
1953         return 0;
1954
1955 unmap:
1956         iounmap(lp->virt_addr);
1957 release:
1958         release_mem_region(lp->phys_addr, lp->size);
1959 free:
1960         free_netdev(dev);
1961         return err;
1962 }
1963
1964 static int cs89x0_platform_remove(struct platform_device *pdev)
1965 {
1966         struct net_device *dev = platform_get_drvdata(pdev);
1967         struct net_local *lp = netdev_priv(dev);
1968
1969         unregister_netdev(dev);
1970         iounmap(lp->virt_addr);
1971         release_mem_region(lp->phys_addr, lp->size);
1972         free_netdev(dev);
1973         return 0;
1974 }
1975
1976 static struct platform_driver cs89x0_driver = {
1977         .driver = {
1978                 .name   = DRV_NAME,
1979                 .owner  = THIS_MODULE,
1980         },
1981         .remove = cs89x0_platform_remove,
1982 };
1983
1984 static int __init cs89x0_init(void)
1985 {
1986         return platform_driver_probe(&cs89x0_driver, cs89x0_platform_probe);
1987 }
1988
1989 module_init(cs89x0_init);
1990
1991 static void __exit cs89x0_cleanup(void)
1992 {
1993         platform_driver_unregister(&cs89x0_driver);
1994 }
1995
1996 module_exit(cs89x0_cleanup);
1997
1998 #endif /* CONFIG_CS89x0_PLATFORM */
1999
2000 /*
2001  * Local variables:
2002  *  version-control: t
2003  *  kept-new-versions: 5
2004  *  c-indent-level: 8
2005  *  tab-width: 8
2006  * End:
2007  *
2008  */