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