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