drivers/net/ethernet/cirrus/cs89x0.c

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

DEFINITIONS
