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