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