drivers/net/ethernet/cirrus/cs89x0.c

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