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, ...)				\
  85do {								\
  86	if (val <= net_debug)					\
  87		pr_##level(fmt, ##__VA_ARGS__);			\
  88} while (0)
  89
  90static 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)
 109static unsigned int netcard_portlist[] __used __initdata = {
 110	0x300, 0x320, 0x340, 0x360, 0x200, 0x220, 0x240,
 111	0x260, 0x280, 0x2a0, 0x2c0, 0x2e0, 0
 112};
 113static unsigned int cs8900_irq_map[] = {
 114	10, 11, 12, 5
 115};
 116#endif
 117
 118#if DEBUGGING
 119static 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. */
 137struct 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
 170static int g_cs89x0_dma;
 171
 172static 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
 181static int g_cs89x0_media__force;
 182
 183static 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
 198static 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
 211static 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
 224static u16
 225readreg(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
 233static void
 234writereg(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
 242static int __init
 243wait_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
 256static int __init
 257get_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
 276static int  __init
 277get_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
 290static void
 291write_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
 314static void
 315count_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
 337static void
 338get_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
 358static void
 359write_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
 370static void
 371set_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
 390static int
 391dma_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
 400static int
 401dma_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
 417static void
 418dma_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 */
 443skip_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
 475static 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
 486static void
 487control_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 */
 510static int
 511send_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
 558static int
 559detect_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
 638static int
 639detect_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
 654static int
 655detect_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. */
 671static void
 672net_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
 713static 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
 827static int
 828net_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);
 960release_dma:
 961#if ALLOW_DMA
 962		free_dma(dev->dma);
 963release_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;
1082bad_out:
1083	return ret;
1084}
1085
1086/* The inverse routine to net_open(). */
1087static int
1088net_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 */
1117static struct net_device_stats *
1118net_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
1132static 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
1143static 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
1194static 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
1223static 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 */
1250static 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
1258static 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
1272static 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 */
1310static int __init
1311cs89x0_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;
1577out2:
1578	iowrite16(PP_ChipID, lp->virt_addr + ADD_PORT);
1579out1:
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 */
1589static int __init
1590cs89x0_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;
1633unmap:
1634	ioport_unmap(io_mem);
1635release:
1636	release_region(ioport, NETCARD_IO_EXTENT);
1637out:
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
1650struct 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;
1684out:
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
 
 
 
 
1690static 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
1696static int io;
1697static int irq;
1698static int debug;
1699static char media[8];
1700static int duplex = -1;
1701
1702static int use_dma;			/* These generate unused var warnings if ALLOW_DMA = 0 */
1703static int dma;
1704static int dmasize = 16;		/* or 64 */
1705
1706module_param_hw(io, int, ioport, 0);
1707module_param_hw(irq, int, irq, 0);
1708module_param(debug, int, 0);
1709module_param_string(media, media, sizeof(media), 0);
1710module_param(duplex, int, 0);
1711module_param_hw(dma , int, dma, 0);
1712module_param(dmasize , int, 0);
1713module_param(use_dma , int, 0);
1714MODULE_PARM_DESC(io, "cs89x0 I/O base address");
1715MODULE_PARM_DESC(irq, "cs89x0 IRQ number");
1716#if DEBUGGING
1717MODULE_PARM_DESC(debug, "cs89x0 debug level (0-6)");
1718#else
1719MODULE_PARM_DESC(debug, "(ignored)");
1720#endif
1721MODULE_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 */
1723MODULE_PARM_DESC(duplex, "(ignored)");
1724#if ALLOW_DMA
1725MODULE_PARM_DESC(dma , "cs89x0 ISA DMA channel; ignored if use_dma=0");
1726MODULE_PARM_DESC(dmasize , "cs89x0 DMA size in kB (16,64); ignored if use_dma=0");
1727MODULE_PARM_DESC(use_dma , "cs89x0 using DMA (0-1)");
1728#else
1729MODULE_PARM_DESC(dma , "(ignored)");
1730MODULE_PARM_DESC(dmasize , "(ignored)");
1731MODULE_PARM_DESC(use_dma , "(ignored)");
1732#endif
1733
1734MODULE_AUTHOR("Mike Cruse, Russwll Nelson <nelson@crynwr.com>, Andrew Morton");
1735MODULE_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
1760static 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;
1826out:
1827	free_netdev(dev);
1828	return ret;
1829}
1830module_init(cs89x0_isa_init_module);
1831
1832static 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}
1842module_exit(cs89x0_isa_cleanup_module);
1843#endif /* MODULE */
1844#endif /* CONFIG_CS89x0_ISA */
1845
1846#if IS_ENABLED(CONFIG_CS89x0_PLATFORM)
1847static 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
1877free:
1878	free_netdev(dev);
1879	return err;
1880}
1881
1882static 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
1894static const struct of_device_id __maybe_unused cs89x0_match[] = {
1895	{ .compatible = "cirrus,cs8900", },
1896	{ .compatible = "cirrus,cs8920", },
1897	{ },
1898};
1899MODULE_DEVICE_TABLE(of, cs89x0_match);
1900
1901static 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
1909module_platform_driver_probe(cs89x0_driver, cs89x0_platform_probe);
1910
1911#endif /* CONFIG_CS89x0_PLATFORM */
1912
1913MODULE_LICENSE("GPL");
1914MODULE_DESCRIPTION("Crystal Semiconductor (Now Cirrus Logic) CS89[02]0 network driver");
1915MODULE_AUTHOR("Russell Nelson <nelson@crynwr.com>");