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