drivers/net/cs89x0.c

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