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