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