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