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