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