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