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