xircom_tulip_cb.c 51.1 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
/* xircom_tulip_cb.c: A Xircom CBE-100 ethernet driver for Linux. */
Linus Torvalds's avatar
Linus Torvalds committed
2 3 4 5
/*
	Written/copyright 1994-1999 by Donald Becker.

	This software may be used and distributed according to the terms
Linus Torvalds's avatar
Linus Torvalds committed
6
	of the GNU General Public License, incorporated herein by reference.
Linus Torvalds's avatar
Linus Torvalds committed
7

Linus Torvalds's avatar
Linus Torvalds committed
8 9 10 11
	The author may be reached as becker@scyld.com, or C/O
	Scyld Computing Corporation
	410 Severn Ave., Suite 210
	Annapolis MD 21403
Linus Torvalds's avatar
Linus Torvalds committed
12 13 14 15 16 17 18 19 20 21 22 23 24 25

	-----------------------------------------------------------

	Linux kernel-specific changes:

	LK1.0 (Ion Badulescu)
	- Major cleanup
	- Use 2.4 PCI API
	- Support ethtool
	- Rewrite perfect filter/hash code
	- Use interrupts for media changes

	LK1.1 (Ion Badulescu)
	- Disallow negotiation of unsupported full-duplex modes
Linus Torvalds's avatar
Linus Torvalds committed
26 27
*/

Linus Torvalds's avatar
Linus Torvalds committed
28
#define DRV_NAME	"xircom_tulip_cb"
Linus Torvalds's avatar
Linus Torvalds committed
29 30
#define DRV_VERSION	"0.91+LK1.1"
#define DRV_RELDATE	"October 11, 2001"
Linus Torvalds's avatar
Linus Torvalds committed
31

Linus Torvalds's avatar
Linus Torvalds committed
32 33 34 35 36 37 38
#define CARDBUS 1

/* A few user-configurable values. */

/* Maximum events (Rx packets, etc.) to handle at each interrupt. */
static int max_interrupt_work = 25;

Linus Torvalds's avatar
Linus Torvalds committed
39
#define MAX_UNITS 4
Linus Torvalds's avatar
Linus Torvalds committed
40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71
/* Used to pass the full-duplex flag, etc. */
static int full_duplex[MAX_UNITS];
static int options[MAX_UNITS];
static int mtu[MAX_UNITS];			/* Jumbo MTU for interfaces. */

/* Keep the ring sizes a power of two for efficiency.
   Making the Tx ring too large decreases the effectiveness of channel
   bonding and packet priority.
   There are no ill effects from too-large receive rings. */
#define TX_RING_SIZE	16
#define RX_RING_SIZE	32

/* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
#ifdef __alpha__
static int rx_copybreak = 1518;
#else
static int rx_copybreak = 100;
#endif

/*
  Set the bus performance register.
	Typical: Set 16 longword cache alignment, no burst limit.
	Cache alignment bits 15:14	     Burst length 13:8
		0000	No alignment  0x00000000 unlimited		0800 8 longwords
		4000	8  longwords		0100 1 longword		1000 16 longwords
		8000	16 longwords		0200 2 longwords	2000 32 longwords
		C000	32  longwords		0400 4 longwords
	Warning: many older 486 systems are broken and require setting 0x00A04800
	   8 longword cache alignment, 8 longword burst.
	ToDo: Non-Intel setting could be better.
*/

Linus Torvalds's avatar
Linus Torvalds committed
72
#if defined(__alpha__) || defined(__ia64__) || defined(__x86_64__)
Linus Torvalds's avatar
Linus Torvalds committed
73 74 75 76 77 78 79 80 81 82 83 84 85 86
static int csr0 = 0x01A00000 | 0xE000;
#elif defined(__powerpc__)
static int csr0 = 0x01B00000 | 0x8000;
#elif defined(__sparc__)
static int csr0 = 0x01B00080 | 0x8000;
#elif defined(__i386__)
static int csr0 = 0x01A00000 | 0x8000;
#else
#warning Processor architecture undefined!
static int csr0 = 0x00A00000 | 0x4800;
#endif

/* Operational parameters that usually are not changed. */
/* Time in jiffies before concluding the transmitter is hung. */
Linus Torvalds's avatar
Linus Torvalds committed
87
#define TX_TIMEOUT		(4 * HZ)
Linus Torvalds's avatar
Linus Torvalds committed
88
#define PKT_BUF_SZ		1536			/* Size of each temporary Rx buffer.*/
Linus Torvalds's avatar
Linus Torvalds committed
89
#define PKT_SETUP_SZ		192			/* Size of the setup frame */
Linus Torvalds's avatar
Linus Torvalds committed
90

Linus Torvalds's avatar
Linus Torvalds committed
91 92
/* PCI registers */
#define PCI_POWERMGMT 	0x40
Linus Torvalds's avatar
Linus Torvalds committed
93

Linus Torvalds's avatar
Linus Torvalds committed
94
#include <linux/config.h>
Linus Torvalds's avatar
Linus Torvalds committed
95 96 97 98 99 100 101
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/pci.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/delay.h>
#include <linux/init.h>
Linus Torvalds's avatar
Linus Torvalds committed
102 103
#include <linux/mii.h>
#include <linux/ethtool.h>
Linus Torvalds's avatar
Linus Torvalds committed
104
#include <linux/crc32.h>
Linus Torvalds's avatar
Linus Torvalds committed
105 106 107

#include <asm/io.h>
#include <asm/processor.h>	/* Processor type for cache alignment. */
Linus Torvalds's avatar
Linus Torvalds committed
108 109
#include <asm/uaccess.h>

Linus Torvalds's avatar
Linus Torvalds committed
110

Linus Torvalds's avatar
Linus Torvalds committed
111 112 113 114
/* These identify the driver base version and may not be removed. */
static char version[] __devinitdata =
KERN_INFO DRV_NAME ".c derived from tulip.c:v0.91 4/14/99 becker@scyld.com\n"
KERN_INFO " unofficial 2.4.x kernel port, version " DRV_VERSION ", " DRV_RELDATE "\n";
Linus Torvalds's avatar
Linus Torvalds committed
115

Linus Torvalds's avatar
Linus Torvalds committed
116
MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
Linus Torvalds's avatar
Linus Torvalds committed
117 118
MODULE_DESCRIPTION("Xircom CBE-100 ethernet driver");
MODULE_LICENSE("GPL v2");
Linus Torvalds's avatar
Linus Torvalds committed
119

Linus Torvalds's avatar
Linus Torvalds committed
120 121 122 123 124 125 126 127 128
MODULE_PARM(debug, "i");
MODULE_PARM(max_interrupt_work, "i");
MODULE_PARM(rx_copybreak, "i");
MODULE_PARM(csr0, "i");
MODULE_PARM(options, "1-" __MODULE_STRING(MAX_UNITS) "i");
MODULE_PARM(full_duplex, "1-" __MODULE_STRING(MAX_UNITS) "i");

#define RUN_AT(x) (jiffies + (x))

Linus Torvalds's avatar
Linus Torvalds committed
129 130 131
#define xircom_debug debug
#ifdef XIRCOM_DEBUG
static int xircom_debug = XIRCOM_DEBUG;
Linus Torvalds's avatar
Linus Torvalds committed
132
#else
Linus Torvalds's avatar
Linus Torvalds committed
133
static int xircom_debug = 1;
Linus Torvalds's avatar
Linus Torvalds committed
134 135 136 137 138 139 140
#endif

/*
				Theory of Operation

I. Board Compatibility

Linus Torvalds's avatar
Linus Torvalds committed
141 142 143
This device driver was forked from the driver for the DECchip "Tulip",
Digital's single-chip ethernet controllers for PCI.  It supports Xircom's
almost-Tulip-compatible CBE-100 CardBus adapters.
Linus Torvalds's avatar
Linus Torvalds committed
144 145 146 147 148 149 150 151 152 153 154

II. Board-specific settings

PCI bus devices are configured by the system at boot time, so no jumpers
need to be set on the board.  The system BIOS preferably should assign the
PCI INTA signal to an otherwise unused system IRQ line.

III. Driver operation

IIIa. Ring buffers

Linus Torvalds's avatar
Linus Torvalds committed
155
The Xircom can use either ring buffers or lists of Tx and Rx descriptors.
Linus Torvalds's avatar
Linus Torvalds committed
156 157 158
This driver uses statically allocated rings of Rx and Tx descriptors, set at
compile time by RX/TX_RING_SIZE.  This version of the driver allocates skbuffs
for the Rx ring buffers at open() time and passes the skb->data field to the
Linus Torvalds's avatar
Linus Torvalds committed
159
Xircom as receive data buffers.  When an incoming frame is less than
Linus Torvalds's avatar
Linus Torvalds committed
160 161 162 163 164 165 166 167 168 169 170
RX_COPYBREAK bytes long, a fresh skbuff is allocated and the frame is
copied to the new skbuff.  When the incoming frame is larger, the skbuff is
passed directly up the protocol stack and replaced by a newly allocated
skbuff.

The RX_COPYBREAK value is chosen to trade-off the memory wasted by
using a full-sized skbuff for small frames vs. the copying costs of larger
frames.  For small frames the copying cost is negligible (esp. considering
that we are pre-loading the cache with immediately useful header
information).  For large frames the copying cost is non-trivial, and the
larger copy might flush the cache of useful data.  A subtle aspect of this
Linus Torvalds's avatar
Linus Torvalds committed
171
choice is that the Xircom only receives into longword aligned buffers, thus
Linus Torvalds's avatar
Linus Torvalds committed
172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
the IP header at offset 14 isn't longword aligned for further processing.
Copied frames are put into the new skbuff at an offset of "+2", thus copying
has the beneficial effect of aligning the IP header and preloading the
cache.

IIIC. Synchronization
The driver runs as two independent, single-threaded flows of control.  One
is the send-packet routine, which enforces single-threaded use by the
dev->tbusy flag.  The other thread is the interrupt handler, which is single
threaded by the hardware and other software.

The send packet thread has partial control over the Tx ring and 'dev->tbusy'
flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
queue slot is empty, it clears the tbusy flag when finished otherwise it sets
the 'tp->tx_full' flag.

The interrupt handler has exclusive control over the Rx ring and records stats
from the Tx ring.  (The Tx-done interrupt can't be selectively turned off, so
we can't avoid the interrupt overhead by having the Tx routine reap the Tx
stats.)	 After reaping the stats, it marks the queue entry as empty by setting
the 'base' to zero.	 Iff the 'tp->tx_full' flag is set, it clears both the
tx_full and tbusy flags.

IV. Notes

IVb. References

http://cesdis.gsfc.nasa.gov/linux/misc/NWay.html
http://www.digital.com  (search for current 21*4* datasheets and "21X4 SROM")
http://www.national.com/pf/DP/DP83840A.html

IVc. Errata

*/

/* A full-duplex map for media types. */
enum MediaIs {
	MediaIsFD = 1, MediaAlwaysFD=2, MediaIsMII=4, MediaIsFx=8,
	MediaIs100=16};
static const char media_cap[] =
{0,0,0,16,  3,19,16,24,  27,4,7,5, 0,20,23,20 };

/* Offsets to the Command and Status Registers, "CSRs".  All accesses
   must be longword instructions and quadword aligned. */
Linus Torvalds's avatar
Linus Torvalds committed
216
enum xircom_offsets {
Linus Torvalds's avatar
Linus Torvalds committed
217 218
	CSR0=0,    CSR1=0x08, CSR2=0x10, CSR3=0x18, CSR4=0x20, CSR5=0x28,
	CSR6=0x30, CSR7=0x38, CSR8=0x40, CSR9=0x48, CSR10=0x50, CSR11=0x58,
Linus Torvalds's avatar
Linus Torvalds committed
219
	CSR12=0x60, CSR13=0x68, CSR14=0x70, CSR15=0x78, CSR16=0x04, };
Linus Torvalds's avatar
Linus Torvalds committed
220 221 222

/* The bits in the CSR5 status registers, mostly interrupt sources. */
enum status_bits {
Linus Torvalds's avatar
Linus Torvalds committed
223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256
	LinkChange=0x08000000,
	NormalIntr=0x10000, NormalIntrMask=0x00014045,
	AbnormalIntr=0x8000, AbnormalIntrMask=0x0a00a5a2,
	ReservedIntrMask=0xe0001a18,
	EarlyRxIntr=0x4000, BusErrorIntr=0x2000,
	EarlyTxIntr=0x400, RxDied=0x100, RxNoBuf=0x80, RxIntr=0x40,
	TxFIFOUnderflow=0x20, TxNoBuf=0x04, TxDied=0x02, TxIntr=0x01,
};

enum csr0_control_bits {
	EnableMWI=0x01000000, EnableMRL=0x00800000,
	EnableMRM=0x00200000, EqualBusPrio=0x02,
	SoftwareReset=0x01,
};

enum csr6_control_bits {
	ReceiveAllBit=0x40000000, AllMultiBit=0x80, PromiscBit=0x40,
	HashFilterBit=0x01, FullDuplexBit=0x0200,
	TxThresh10=0x400000, TxStoreForw=0x200000,
	TxThreshMask=0xc000, TxThreshShift=14,
	EnableTx=0x2000, EnableRx=0x02,
	ReservedZeroMask=0x8d930134, ReservedOneMask=0x320c0000,
	EnableTxRx=(EnableTx | EnableRx),
};


enum tbl_flag {
	HAS_MII=1, HAS_ACPI=2,
};
static struct xircom_chip_table {
	char *chip_name;
	int valid_intrs;			/* CSR7 interrupt enable settings */
	int flags;
} xircom_tbl[] = {
Linus Torvalds's avatar
Linus Torvalds committed
257
  { "Xircom Cardbus Adapter",
Linus Torvalds's avatar
Linus Torvalds committed
258 259 260 261 262 263 264 265
	LinkChange | NormalIntr | AbnormalIntr | BusErrorIntr |
	RxDied | RxNoBuf | RxIntr | TxFIFOUnderflow | TxNoBuf | TxDied | TxIntr,
	HAS_MII | HAS_ACPI, },
  { NULL, },
};
/* This matches the table above. */
enum chips {
	X3201_3,
Linus Torvalds's avatar
Linus Torvalds committed
266 267
};

Linus Torvalds's avatar
Linus Torvalds committed
268 269 270

/* The Xircom Rx and Tx buffer descriptors. */
struct xircom_rx_desc {
Linus Torvalds's avatar
Linus Torvalds committed
271 272 273 274 275
	s32 status;
	s32 length;
	u32 buffer1, buffer2;
};

Linus Torvalds's avatar
Linus Torvalds committed
276
struct xircom_tx_desc {
Linus Torvalds's avatar
Linus Torvalds committed
277 278 279 280 281
	s32 status;
	s32 length;
	u32 buffer1, buffer2;				/* We use only buffer 1.  */
};

Linus Torvalds's avatar
Linus Torvalds committed
282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299
enum tx_desc0_status_bits {
	Tx0DescOwned=0x80000000, Tx0DescError=0x8000, Tx0NoCarrier=0x0800,
	Tx0LateColl=0x0200, Tx0ManyColl=0x0100, Tx0Underflow=0x02,
};
enum tx_desc1_status_bits {
	Tx1ComplIntr=0x80000000, Tx1LastSeg=0x40000000, Tx1FirstSeg=0x20000000,
	Tx1SetupPkt=0x08000000, Tx1DisableCRC=0x04000000, Tx1RingWrap=0x02000000,
	Tx1ChainDesc=0x01000000, Tx1NoPad=0x800000, Tx1HashSetup=0x400000,
	Tx1WholePkt=(Tx1FirstSeg | Tx1LastSeg),
};
enum rx_desc0_status_bits {
	Rx0DescOwned=0x80000000, Rx0DescError=0x8000, Rx0NoSpace=0x4000,
	Rx0Runt=0x0800, Rx0McastPkt=0x0400, Rx0FirstSeg=0x0200, Rx0LastSeg=0x0100,
	Rx0HugeFrame=0x80, Rx0CRCError=0x02,
	Rx0WholePkt=(Rx0FirstSeg | Rx0LastSeg),
};
enum rx_desc1_status_bits {
	Rx1RingWrap=0x02000000, Rx1ChainDesc=0x01000000,
Linus Torvalds's avatar
Linus Torvalds committed
300 301
};

Linus Torvalds's avatar
Linus Torvalds committed
302 303 304
struct xircom_private {
	struct xircom_rx_desc rx_ring[RX_RING_SIZE];
	struct xircom_tx_desc tx_ring[TX_RING_SIZE];
Linus Torvalds's avatar
Linus Torvalds committed
305 306 307
	/* The saved address of a sent-in-place packet/buffer, for skfree(). */
	struct sk_buff* tx_skbuff[TX_RING_SIZE];
#ifdef CARDBUS
Linus Torvalds's avatar
Linus Torvalds committed
308
	/* The X3201-3 requires 4-byte aligned tx bufs */
Linus Torvalds's avatar
Linus Torvalds committed
309 310 311 312
	struct sk_buff* tx_aligned_skbuff[TX_RING_SIZE];
#endif
	/* The addresses of receive-in-place skbuffs. */
	struct sk_buff* rx_skbuff[RX_RING_SIZE];
Linus Torvalds's avatar
Linus Torvalds committed
313
	u16 setup_frame[PKT_SETUP_SZ / sizeof(u16)];	/* Pseudo-Tx frame to init address table. */
Linus Torvalds's avatar
Linus Torvalds committed
314 315 316 317 318
	int chip_id;
	struct net_device_stats stats;
	unsigned int cur_rx, cur_tx;		/* The next free ring entry */
	unsigned int dirty_rx, dirty_tx;	/* The ring entries to be free()ed. */
	unsigned int tx_full:1;				/* The Tx queue is full. */
Linus Torvalds's avatar
Linus Torvalds committed
319
	unsigned int speed100:1;
Linus Torvalds's avatar
Linus Torvalds committed
320
	unsigned int full_duplex:1;			/* Full-duplex operation requested. */
Linus Torvalds's avatar
Linus Torvalds committed
321
	unsigned int autoneg:1;
Linus Torvalds's avatar
Linus Torvalds committed
322 323 324 325 326 327 328 329 330 331
	unsigned int default_port:4;		/* Last dev->if_port value. */
	unsigned int open:1;
	unsigned int csr0;					/* CSR0 setting. */
	unsigned int csr6;					/* Current CSR6 control settings. */
	u16 to_advertise;					/* NWay capabilities advertised.  */
	u16 advertising[4];
	signed char phys[4], mii_cnt;		/* MII device addresses. */
	int saved_if_port;
	struct pci_dev *pdev;
	spinlock_t lock;
332 333 334
#ifdef CONFIG_PM
	u32 pci_state[16];
#endif
Linus Torvalds's avatar
Linus Torvalds committed
335 336 337 338
};

static int mdio_read(struct net_device *dev, int phy_id, int location);
static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
Linus Torvalds's avatar
Linus Torvalds committed
339 340 341 342 343 344 345
static void xircom_up(struct net_device *dev);
static void xircom_down(struct net_device *dev);
static int xircom_open(struct net_device *dev);
static void xircom_tx_timeout(struct net_device *dev);
static void xircom_init_ring(struct net_device *dev);
static int xircom_start_xmit(struct sk_buff *skb, struct net_device *dev);
static int xircom_rx(struct net_device *dev);
346
static void xircom_media_change(struct net_device *dev);
Jeff Garzik's avatar
Jeff Garzik committed
347
static irqreturn_t xircom_interrupt(int irq, void *dev_instance, struct pt_regs *regs);
Linus Torvalds's avatar
Linus Torvalds committed
348 349 350
static int xircom_close(struct net_device *dev);
static struct net_device_stats *xircom_get_stats(struct net_device *dev);
static int xircom_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
Linus Torvalds's avatar
Linus Torvalds committed
351
static void set_rx_mode(struct net_device *dev);
Linus Torvalds's avatar
Linus Torvalds committed
352 353
static void check_duplex(struct net_device *dev);

Linus Torvalds's avatar
Linus Torvalds committed
354 355 356

/* The Xircom cards are picky about when certain bits in CSR6 can be
   manipulated.  Keith Owens <kaos@ocs.com.au>. */
Linus Torvalds's avatar
Linus Torvalds committed
357
static void outl_CSR6(u32 newcsr6, long ioaddr)
Linus Torvalds's avatar
Linus Torvalds committed
358
{
Linus Torvalds's avatar
Linus Torvalds committed
359 360
	const int strict_bits =
		TxThresh10 | TxStoreForw | TxThreshMask | EnableTxRx | FullDuplexBit;
Linus Torvalds's avatar
Linus Torvalds committed
361
    int csr5, csr5_22_20, csr5_19_17, currcsr6, attempts = 200;
Jeff Garzik's avatar
Jeff Garzik committed
362
    unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
363 364
    save_flags(flags);
    cli();
Linus Torvalds's avatar
Linus Torvalds committed
365 366 367 368
	/* mask out the reserved bits that always read 0 on the Xircom cards */
	newcsr6 &= ~ReservedZeroMask;
	/* or in the reserved bits that always read 1 */
	newcsr6 |= ReservedOneMask;
Linus Torvalds's avatar
Linus Torvalds committed
369 370
    currcsr6 = inl(ioaddr + CSR6);
    if (((newcsr6 & strict_bits) == (currcsr6 & strict_bits)) ||
Linus Torvalds's avatar
Linus Torvalds committed
371
	((currcsr6 & ~EnableTxRx) == 0)) {
Linus Torvalds's avatar
Linus Torvalds committed
372 373 374 375 376
		outl(newcsr6, ioaddr + CSR6);	/* safe */
		restore_flags(flags);
		return;
    }
    /* make sure the transmitter and receiver are stopped first */
Linus Torvalds's avatar
Linus Torvalds committed
377
    currcsr6 &= ~EnableTxRx;
Linus Torvalds's avatar
Linus Torvalds committed
378 379 380 381 382 383 384 385 386 387
    while (1) {
		csr5 = inl(ioaddr + CSR5);
		if (csr5 == 0xffffffff)
			break;  /* cannot read csr5, card removed? */
		csr5_22_20 = csr5 & 0x700000;
		csr5_19_17 = csr5 & 0x0e0000;
		if ((csr5_22_20 == 0 || csr5_22_20 == 0x600000) &&
			(csr5_19_17 == 0 || csr5_19_17 == 0x80000 || csr5_19_17 == 0xc0000))
			break;  /* both are stopped or suspended */
		if (!--attempts) {
Linus Torvalds's avatar
Linus Torvalds committed
388
			printk(KERN_INFO DRV_NAME ": outl_CSR6 too many attempts,"
Linus Torvalds's avatar
Linus Torvalds committed
389 390 391 392 393 394 395 396 397 398 399 400
				   "csr5=0x%08x\n", csr5);
			outl(newcsr6, ioaddr + CSR6);  /* unsafe but do it anyway */
			restore_flags(flags);
			return;
		}
		outl(currcsr6, ioaddr + CSR6);
		udelay(1);
    }
    /* now it is safe to change csr6 */
    outl(newcsr6, ioaddr + CSR6);
    restore_flags(flags);
}
Linus Torvalds's avatar
Linus Torvalds committed
401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447


static void __devinit read_mac_address(struct net_device *dev)
{
	long ioaddr = dev->base_addr;
	int i, j;
	unsigned char tuple, link, data_id, data_count;

	/* Xircom has its address stored in the CIS;
	 * we access it through the boot rom interface for now
	 * this might not work, as the CIS is not parsed but I
	 * (danilo) use the offset I found on my card's CIS !!!
	 *
	 * Doug Ledford: I changed this routine around so that it
	 * walks the CIS memory space, parsing the config items, and
	 * finds the proper lan_node_id tuple and uses the data
	 * stored there.
	 */
	outl(1 << 12, ioaddr + CSR9); /* enable boot rom access */
	for (i = 0x100; i < 0x1f7; i += link+2) {
		outl(i, ioaddr + CSR10);
		tuple = inl(ioaddr + CSR9) & 0xff;
		outl(i + 1, ioaddr + CSR10);
		link = inl(ioaddr + CSR9) & 0xff;
		outl(i + 2, ioaddr + CSR10);
		data_id = inl(ioaddr + CSR9) & 0xff;
		outl(i + 3, ioaddr + CSR10);
		data_count = inl(ioaddr + CSR9) & 0xff;
		if ( (tuple == 0x22) &&
			 (data_id == 0x04) && (data_count == 0x06) ) {
			/*
			 * This is it.  We have the data we want.
			 */
			for (j = 0; j < 6; j++) {
				outl(i + j + 4, ioaddr + CSR10);
				dev->dev_addr[j] = inl(ioaddr + CSR9) & 0xff;
			}
			break;
		} else if (link == 0) {
			break;
		}
	}
}


/*
 * locate the MII interfaces and initialize them.
Linus Torvalds's avatar
Linus Torvalds committed
448 449
 * we disable full-duplex modes here,
 * because we don't know how to handle them.
Linus Torvalds's avatar
Linus Torvalds committed
450 451 452 453 454 455
 */
static void find_mii_transceivers(struct net_device *dev)
{
	struct xircom_private *tp = dev->priv;
	int phy, phy_idx;

Linus Torvalds's avatar
Linus Torvalds committed
456 457 458 459 460 461 462 463
	if (media_cap[tp->default_port] & MediaIsMII) {
		u16 media2advert[] = { 0x20, 0x40, 0x03e0, 0x60, 0x80, 0x100, 0x200 };
		tp->to_advertise = media2advert[tp->default_port - 9];
	} else
		tp->to_advertise =
			/*ADVERTISE_100BASE4 | ADVERTISE_100FULL |*/ ADVERTISE_100HALF |
			/*ADVERTISE_10FULL |*/ ADVERTISE_10HALF | ADVERTISE_CSMA;

Linus Torvalds's avatar
Linus Torvalds committed
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492
	/* Find the connected MII xcvrs.
	   Doing this in open() would allow detecting external xcvrs later,
	   but takes much time. */
	for (phy = 0, phy_idx = 0; phy < 32 && phy_idx < sizeof(tp->phys); phy++) {
		int mii_status = mdio_read(dev, phy, MII_BMSR);
		if ((mii_status & (BMSR_100BASE4 | BMSR_100HALF | BMSR_10HALF)) == BMSR_100BASE4 ||
			((mii_status & BMSR_100BASE4) == 0 &&
			 (mii_status & (BMSR_100FULL | BMSR_100HALF | BMSR_10FULL | BMSR_10HALF)) != 0)) {
			int mii_reg0 = mdio_read(dev, phy, MII_BMCR);
			int mii_advert = mdio_read(dev, phy, MII_ADVERTISE);
			int reg4 = ((mii_status >> 6) & tp->to_advertise) | ADVERTISE_CSMA;
			tp->phys[phy_idx] = phy;
			tp->advertising[phy_idx++] = reg4;
			printk(KERN_INFO "%s:  MII transceiver #%d "
				   "config %4.4x status %4.4x advertising %4.4x.\n",
				   dev->name, phy, mii_reg0, mii_status, mii_advert);
		}
	}
	tp->mii_cnt = phy_idx;
	if (phy_idx == 0) {
		printk(KERN_INFO "%s: ***WARNING***: No MII transceiver found!\n",
			   dev->name);
		tp->phys[0] = 0;
	}
}


/*
 * To quote Arjan van de Ven:
493
 *   transceiver_voodoo() enables the external UTP plug thingy.
Linus Torvalds's avatar
Linus Torvalds committed
494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534
 *   it's called voodoo as I stole this code and cannot cross-reference
 *   it with the specification.
 * Actually it seems to go like this:
 * - GPIO2 enables the MII itself so we can talk to it. The MII gets reset
 *   so any prior MII settings are lost.
 * - GPIO0 enables the TP port so the MII can talk to the network.
 * - a software reset will reset both GPIO pins.
 * I also moved the software reset here, because doing it in xircom_up()
 * required enabling the GPIO pins each time, which reset the MII each time.
 * Thus we couldn't control the MII -- which sucks because we don't know
 * how to handle full-duplex modes so we *must* disable them.
 */
static void transceiver_voodoo(struct net_device *dev)
{
	struct xircom_private *tp = dev->priv;
	long ioaddr = dev->base_addr;

	/* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
	outl(SoftwareReset, ioaddr + CSR0);
	udelay(2);

	/* Deassert reset. */
	outl(tp->csr0, ioaddr + CSR0);

	/* Reset the xcvr interface and turn on heartbeat. */
	outl(0x0008, ioaddr + CSR15);
	udelay(5);  /* The delays are Xircom-recommended to give the
				 * chipset time to reset the actual hardware
				 * on the PCMCIA card
				 */
	outl(0xa8050000, ioaddr + CSR15);
	udelay(5);
	outl(0xa00f0000, ioaddr + CSR15);
	udelay(5);

	outl_CSR6(0, ioaddr);
	//outl_CSR6(FullDuplexBit, ioaddr);
}


static int __devinit xircom_init_one(struct pci_dev *pdev, const struct pci_device_id *id)
Linus Torvalds's avatar
Linus Torvalds committed
535
{
Linus Torvalds's avatar
Linus Torvalds committed
536
	struct net_device *dev;
Linus Torvalds's avatar
Linus Torvalds committed
537 538 539 540
	struct xircom_private *tp;
	static int board_idx = -1;
	int chip_idx = id->driver_data;
	long ioaddr;
Linus Torvalds's avatar
Linus Torvalds committed
541
	int i;
Linus Torvalds's avatar
Linus Torvalds committed
542
	u8 chip_rev;
Linus Torvalds's avatar
Linus Torvalds committed
543

Linus Torvalds's avatar
Linus Torvalds committed
544 545 546 547 548 549
/* when built into the kernel, we only print version if device is found */
#ifndef MODULE
	static int printed_version;
	if (!printed_version++)
		printk(version);
#endif
Linus Torvalds's avatar
Linus Torvalds committed
550

551
	//printk(KERN_INFO "xircom_init_one(%s)\n", pci_name(pdev));
Linus Torvalds's avatar
Linus Torvalds committed
552

Linus Torvalds's avatar
Linus Torvalds committed
553
	board_idx++;
Linus Torvalds's avatar
Linus Torvalds committed
554

Linus Torvalds's avatar
Linus Torvalds committed
555 556
	if (pci_enable_device(pdev))
		return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
557

Linus Torvalds's avatar
Linus Torvalds committed
558
	pci_set_master(pdev);
Linus Torvalds's avatar
Linus Torvalds committed
559

Linus Torvalds's avatar
Linus Torvalds committed
560 561 562 563 564 565 566
	ioaddr = pci_resource_start(pdev, 0);
	dev = alloc_etherdev(sizeof(*tp));
	if (!dev) {
		printk (KERN_ERR DRV_NAME "%d: cannot alloc etherdev, aborting\n", board_idx);
		return -ENOMEM;
	}
	SET_MODULE_OWNER(dev);
567
	SET_NETDEV_DEV(dev, &pdev->dev);
Linus Torvalds's avatar
Linus Torvalds committed
568 569

	dev->base_addr = ioaddr;
Linus Torvalds's avatar
Linus Torvalds committed
570
	dev->irq = pdev->irq;
Linus Torvalds's avatar
Linus Torvalds committed
571

Linus Torvalds's avatar
Linus Torvalds committed
572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587
	if (pci_request_regions(pdev, dev->name)) {
		printk (KERN_ERR DRV_NAME " %d: cannot reserve PCI resources, aborting\n", board_idx);
		goto err_out_free_netdev;
	}

	/* Bring the chip out of sleep mode.
	   Caution: Snooze mode does not work with some boards! */
	if (xircom_tbl[chip_idx].flags & HAS_ACPI)
		pci_write_config_dword(pdev, PCI_POWERMGMT, 0);

	/* Stop the chip's Tx and Rx processes. */
	outl_CSR6(inl(ioaddr + CSR6) & ~EnableTxRx, ioaddr);
	/* Clear the missed-packet counter. */
	(volatile int)inl(ioaddr + CSR8);

	tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
588 589 590 591

	tp->lock = SPIN_LOCK_UNLOCKED;
	tp->pdev = pdev;
	tp->chip_id = chip_idx;
Linus Torvalds's avatar
Linus Torvalds committed
592 593 594
	/* BugFixes: The 21143-TD hangs with PCI Write-and-Invalidate cycles. */
	/* XXX: is this necessary for Xircom? */
	tp->csr0 = csr0 & ~EnableMWI;
Linus Torvalds's avatar
Linus Torvalds committed
595

Linus Torvalds's avatar
Linus Torvalds committed
596
	pci_set_drvdata(pdev, dev);
Linus Torvalds's avatar
Linus Torvalds committed
597 598

	/* The lower four bits are the media type. */
Linus Torvalds's avatar
Linus Torvalds committed
599
	if (board_idx >= 0 && board_idx < MAX_UNITS) {
Linus Torvalds's avatar
Linus Torvalds committed
600 601 602 603 604 605 606 607 608 609 610 611 612
		tp->default_port = options[board_idx] & 15;
		if ((options[board_idx] & 0x90) || full_duplex[board_idx] > 0)
			tp->full_duplex = 1;
		if (mtu[board_idx] > 0)
			dev->mtu = mtu[board_idx];
	}
	if (dev->mem_start)
		tp->default_port = dev->mem_start;
	if (tp->default_port) {
		if (media_cap[tp->default_port] & MediaAlwaysFD)
			tp->full_duplex = 1;
	}
	if (tp->full_duplex)
Linus Torvalds's avatar
Linus Torvalds committed
613 614 615 616 617 618 619 620 621 622 623
		tp->autoneg = 0;
	else
		tp->autoneg = 1;
	tp->speed100 = 1;

	/* The Xircom-specific entries in the device structure. */
	dev->open = &xircom_open;
	dev->hard_start_xmit = &xircom_start_xmit;
	dev->stop = &xircom_close;
	dev->get_stats = &xircom_get_stats;
	dev->do_ioctl = &xircom_ioctl;
Linus Torvalds's avatar
Linus Torvalds committed
624 625 626
#ifdef HAVE_MULTICAST
	dev->set_multicast_list = &set_rx_mode;
#endif
Linus Torvalds's avatar
Linus Torvalds committed
627
	dev->tx_timeout = xircom_tx_timeout;
Linus Torvalds's avatar
Linus Torvalds committed
628 629
	dev->watchdog_timeo = TX_TIMEOUT;

Linus Torvalds's avatar
Linus Torvalds committed
630
	transceiver_voodoo(dev);
Linus Torvalds's avatar
Linus Torvalds committed
631

Linus Torvalds's avatar
Linus Torvalds committed
632 633 634 635
	read_mac_address(dev);

	if (register_netdev(dev))
		goto err_out_cleardev;
Linus Torvalds's avatar
Linus Torvalds committed
636

Linus Torvalds's avatar
Linus Torvalds committed
637
	pci_read_config_byte(pdev, PCI_REVISION_ID, &chip_rev);
Linus Torvalds's avatar
Linus Torvalds committed
638
	printk(KERN_INFO "%s: %s rev %d at %#3lx,",
Linus Torvalds's avatar
Linus Torvalds committed
639
	       dev->name, xircom_tbl[chip_idx].chip_name, chip_rev, ioaddr);
Linus Torvalds's avatar
Linus Torvalds committed
640
	for (i = 0; i < 6; i++)
Linus Torvalds's avatar
Linus Torvalds committed
641
		printk("%c%2.2X", i ? ':' : ' ', dev->dev_addr[i]);
Linus Torvalds's avatar
Linus Torvalds committed
642 643 644 645 646 647 648 649
	printk(", IRQ %d.\n", dev->irq);

	if (xircom_tbl[chip_idx].flags & HAS_MII) {
		find_mii_transceivers(dev);
		check_duplex(dev);
	}

	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
650

Linus Torvalds's avatar
Linus Torvalds committed
651 652 653 654
err_out_cleardev:
	pci_set_drvdata(pdev, NULL);
	pci_release_regions(pdev);
err_out_free_netdev:
655
	free_netdev(dev);
Linus Torvalds's avatar
Linus Torvalds committed
656
	return -ENODEV;
Linus Torvalds's avatar
Linus Torvalds committed
657 658
}

Linus Torvalds's avatar
Linus Torvalds committed
659

Linus Torvalds's avatar
Linus Torvalds committed
660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714
/* MII transceiver control section.
   Read and write the MII registers using software-generated serial
   MDIO protocol.  See the MII specifications or DP83840A data sheet
   for details. */

/* The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
   met by back-to-back PCI I/O cycles, but we insert a delay to avoid
   "overclocking" issues or future 66Mhz PCI. */
#define mdio_delay() inl(mdio_addr)

/* Read and write the MII registers using software-generated serial
   MDIO protocol.  It is just different enough from the EEPROM protocol
   to not share code.  The maxium data clock rate is 2.5 Mhz. */
#define MDIO_SHIFT_CLK	0x10000
#define MDIO_DATA_WRITE0 0x00000
#define MDIO_DATA_WRITE1 0x20000
#define MDIO_ENB		0x00000		/* Ignore the 0x02000 databook setting. */
#define MDIO_ENB_IN		0x40000
#define MDIO_DATA_READ	0x80000

static int mdio_read(struct net_device *dev, int phy_id, int location)
{
	int i;
	int read_cmd = (0xf6 << 10) | (phy_id << 5) | location;
	int retval = 0;
	long ioaddr = dev->base_addr;
	long mdio_addr = ioaddr + CSR9;

	/* Establish sync by sending at least 32 logic ones. */
	for (i = 32; i >= 0; i--) {
		outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr);
		mdio_delay();
		outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
		mdio_delay();
	}
	/* Shift the read command bits out. */
	for (i = 15; i >= 0; i--) {
		int dataval = (read_cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;

		outl(MDIO_ENB | dataval, mdio_addr);
		mdio_delay();
		outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr);
		mdio_delay();
	}
	/* Read the two transition, 16 data, and wire-idle bits. */
	for (i = 19; i > 0; i--) {
		outl(MDIO_ENB_IN, mdio_addr);
		mdio_delay();
		retval = (retval << 1) | ((inl(mdio_addr) & MDIO_DATA_READ) ? 1 : 0);
		outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
		mdio_delay();
	}
	return (retval>>1) & 0xffff;
}

Linus Torvalds's avatar
Linus Torvalds committed
715

Linus Torvalds's avatar
Linus Torvalds committed
716 717 718
static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
{
	int i;
Linus Torvalds's avatar
Linus Torvalds committed
719
	int cmd = (0x5002 << 16) | (phy_id << 23) | (location << 18) | value;
Linus Torvalds's avatar
Linus Torvalds committed
720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
	long ioaddr = dev->base_addr;
	long mdio_addr = ioaddr + CSR9;

	/* Establish sync by sending 32 logic ones. */
	for (i = 32; i >= 0; i--) {
		outl(MDIO_ENB | MDIO_DATA_WRITE1, mdio_addr);
		mdio_delay();
		outl(MDIO_ENB | MDIO_DATA_WRITE1 | MDIO_SHIFT_CLK, mdio_addr);
		mdio_delay();
	}
	/* Shift the command bits out. */
	for (i = 31; i >= 0; i--) {
		int dataval = (cmd & (1 << i)) ? MDIO_DATA_WRITE1 : 0;
		outl(MDIO_ENB | dataval, mdio_addr);
		mdio_delay();
		outl(MDIO_ENB | dataval | MDIO_SHIFT_CLK, mdio_addr);
		mdio_delay();
	}
	/* Clear out extra bits. */
	for (i = 2; i > 0; i--) {
		outl(MDIO_ENB_IN, mdio_addr);
		mdio_delay();
		outl(MDIO_ENB_IN | MDIO_SHIFT_CLK, mdio_addr);
		mdio_delay();
	}
	return;
}

Linus Torvalds's avatar
Linus Torvalds committed
748

Linus Torvalds's avatar
Linus Torvalds committed
749
static void
Linus Torvalds's avatar
Linus Torvalds committed
750
xircom_up(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
751
{
Linus Torvalds's avatar
Linus Torvalds committed
752
	struct xircom_private *tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
753 754 755
	long ioaddr = dev->base_addr;
	int i;

756
	xircom_init_ring(dev);
Linus Torvalds's avatar
Linus Torvalds committed
757 758 759
	/* Clear the tx ring */
	for (i = 0; i < TX_RING_SIZE; i++) {
		tp->tx_skbuff[i] = 0;
Linus Torvalds's avatar
Linus Torvalds committed
760
		tp->tx_ring[i].status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
761 762
	}

Linus Torvalds's avatar
Linus Torvalds committed
763 764
	if (xircom_debug > 1)
		printk(KERN_DEBUG "%s: xircom_up() irq %d.\n", dev->name, dev->irq);
Linus Torvalds's avatar
Linus Torvalds committed
765 766 767 768 769 770 771 772

	outl(virt_to_bus(tp->rx_ring), ioaddr + CSR3);
	outl(virt_to_bus(tp->tx_ring), ioaddr + CSR4);

	tp->saved_if_port = dev->if_port;
	if (dev->if_port == 0)
		dev->if_port = tp->default_port;

Linus Torvalds's avatar
Linus Torvalds committed
773 774 775 776
	tp->csr6 = TxThresh10 /*| FullDuplexBit*/;						/* XXX: why 10 and not 100? */

	set_rx_mode(dev);

Linus Torvalds's avatar
Linus Torvalds committed
777
	/* Start the chip's Tx to process setup frame. */
Linus Torvalds's avatar
Linus Torvalds committed
778 779
	outl_CSR6(tp->csr6, ioaddr);
	outl_CSR6(tp->csr6 | EnableTx, ioaddr);
Linus Torvalds's avatar
Linus Torvalds committed
780

Linus Torvalds's avatar
Linus Torvalds committed
781 782
	/* Acknowledge all outstanding interrupts sources */
	outl(xircom_tbl[tp->chip_id].valid_intrs, ioaddr + CSR5);
Linus Torvalds's avatar
Linus Torvalds committed
783
	/* Enable interrupts by setting the interrupt mask. */
Linus Torvalds's avatar
Linus Torvalds committed
784 785 786 787 788 789 790
	outl(xircom_tbl[tp->chip_id].valid_intrs, ioaddr + CSR7);
	/* Enable Rx */
	outl_CSR6(tp->csr6 | EnableTxRx, ioaddr);
	/* Rx poll demand */
	outl(0, ioaddr + CSR2);

	/* Tell the net layer we're ready */
Linus Torvalds's avatar
Linus Torvalds committed
791 792
	netif_start_queue (dev);

793 794 795
	/* Check current media state */
	xircom_media_change(dev);

Linus Torvalds's avatar
Linus Torvalds committed
796 797
	if (xircom_debug > 2) {
		printk(KERN_DEBUG "%s: Done xircom_up(), CSR0 %8.8x, CSR5 %8.8x CSR6 %8.8x.\n",
Linus Torvalds's avatar
Linus Torvalds committed
798 799 800 801 802
			   dev->name, inl(ioaddr + CSR0), inl(ioaddr + CSR5),
			   inl(ioaddr + CSR6));
	}
}

Linus Torvalds's avatar
Linus Torvalds committed
803

Linus Torvalds's avatar
Linus Torvalds committed
804
static int
Linus Torvalds's avatar
Linus Torvalds committed
805
xircom_open(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
806
{
Linus Torvalds's avatar
Linus Torvalds committed
807
	struct xircom_private *tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
808

Linus Torvalds's avatar
Linus Torvalds committed
809
	if (request_irq(dev->irq, &xircom_interrupt, SA_SHIRQ, dev->name, dev))
Linus Torvalds's avatar
Linus Torvalds committed
810 811
		return -EAGAIN;

Linus Torvalds's avatar
Linus Torvalds committed
812
	xircom_up(dev);
Linus Torvalds's avatar
Linus Torvalds committed
813 814 815 816 817 818
	tp->open = 1;

	return 0;
}


Linus Torvalds's avatar
Linus Torvalds committed
819
static void xircom_tx_timeout(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
820
{
Linus Torvalds's avatar
Linus Torvalds committed
821
	struct xircom_private *tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
822 823 824 825
	long ioaddr = dev->base_addr;

	if (media_cap[dev->if_port] & MediaIsMII) {
		/* Do nothing -- the media monitor should handle this. */
Linus Torvalds's avatar
Linus Torvalds committed
826
		if (xircom_debug > 1)
Linus Torvalds's avatar
Linus Torvalds committed
827 828 829 830 831
			printk(KERN_WARNING "%s: Transmit timeout using MII device.\n",
				   dev->name);
	}

#if defined(way_too_many_messages)
Linus Torvalds's avatar
Linus Torvalds committed
832
	if (xircom_debug > 3) {
Linus Torvalds's avatar
Linus Torvalds committed
833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852 853 854 855 856 857
		int i;
		for (i = 0; i < RX_RING_SIZE; i++) {
			u8 *buf = (u8 *)(tp->rx_ring[i].buffer1);
			int j;
			printk(KERN_DEBUG "%2d: %8.8x %8.8x %8.8x %8.8x  "
				   "%2.2x %2.2x %2.2x.\n",
				   i, (unsigned int)tp->rx_ring[i].status,
				   (unsigned int)tp->rx_ring[i].length,
				   (unsigned int)tp->rx_ring[i].buffer1,
				   (unsigned int)tp->rx_ring[i].buffer2,
				   buf[0], buf[1], buf[2]);
			for (j = 0; buf[j] != 0xee && j < 1600; j++)
				if (j < 100) printk(" %2.2x", buf[j]);
			printk(" j=%d.\n", j);
		}
		printk(KERN_DEBUG "  Rx ring %8.8x: ", (int)tp->rx_ring);
		for (i = 0; i < RX_RING_SIZE; i++)
			printk(" %8.8x", (unsigned int)tp->rx_ring[i].status);
		printk("\n" KERN_DEBUG "  Tx ring %8.8x: ", (int)tp->tx_ring);
		for (i = 0; i < TX_RING_SIZE; i++)
			printk(" %8.8x", (unsigned int)tp->tx_ring[i].status);
		printk("\n");
	}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
858 859 860
	/* Stop and restart the chip's Tx/Rx processes . */
	outl_CSR6(tp->csr6 | EnableRx, ioaddr);
	outl_CSR6(tp->csr6 | EnableTxRx, ioaddr);
Linus Torvalds's avatar
Linus Torvalds committed
861 862 863 864 865 866 867 868
	/* Trigger an immediate transmit demand. */
	outl(0, ioaddr + CSR1);

	dev->trans_start = jiffies;
	netif_wake_queue (dev);
	tp->stats.tx_errors++;
}

Linus Torvalds's avatar
Linus Torvalds committed
869

Linus Torvalds's avatar
Linus Torvalds committed
870
/* Initialize the Rx and Tx rings, along with various 'dev' bits. */
Linus Torvalds's avatar
Linus Torvalds committed
871
static void xircom_init_ring(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
872
{
Linus Torvalds's avatar
Linus Torvalds committed
873
	struct xircom_private *tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
874 875 876 877 878 879 880
	int i;

	tp->tx_full = 0;
	tp->cur_rx = tp->cur_tx = 0;
	tp->dirty_rx = tp->dirty_tx = 0;

	for (i = 0; i < RX_RING_SIZE; i++) {
Linus Torvalds's avatar
Linus Torvalds committed
881
		tp->rx_ring[i].status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
882 883 884 885 886
		tp->rx_ring[i].length = PKT_BUF_SZ;
		tp->rx_ring[i].buffer2 = virt_to_bus(&tp->rx_ring[i+1]);
		tp->rx_skbuff[i] = NULL;
	}
	/* Mark the last entry as wrapping the ring. */
Linus Torvalds's avatar
Linus Torvalds committed
887
	tp->rx_ring[i-1].length = PKT_BUF_SZ | Rx1RingWrap;
Linus Torvalds's avatar
Linus Torvalds committed
888 889 890 891 892 893 894 895 896 897 898
	tp->rx_ring[i-1].buffer2 = virt_to_bus(&tp->rx_ring[0]);

	for (i = 0; i < RX_RING_SIZE; i++) {
		/* Note the receive buffer must be longword aligned.
		   dev_alloc_skb() provides 16 byte alignment.  But do *not*
		   use skb_reserve() to align the IP header! */
		struct sk_buff *skb = dev_alloc_skb(PKT_BUF_SZ);
		tp->rx_skbuff[i] = skb;
		if (skb == NULL)
			break;
		skb->dev = dev;			/* Mark as being used by this device. */
Linus Torvalds's avatar
Linus Torvalds committed
899
		tp->rx_ring[i].status = Rx0DescOwned;	/* Owned by Xircom chip */
Linus Torvalds's avatar
Linus Torvalds committed
900 901 902 903 904 905 906 907
		tp->rx_ring[i].buffer1 = virt_to_bus(skb->tail);
	}
	tp->dirty_rx = (unsigned int)(i - RX_RING_SIZE);

	/* The Tx buffer descriptor is filled in as needed, but we
	   do need to clear the ownership bit. */
	for (i = 0; i < TX_RING_SIZE; i++) {
		tp->tx_skbuff[i] = 0;
Linus Torvalds's avatar
Linus Torvalds committed
908
		tp->tx_ring[i].status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
909 910 911 912
		tp->tx_ring[i].buffer2 = virt_to_bus(&tp->tx_ring[i+1]);
#ifdef CARDBUS
		if (tp->chip_id == X3201_3)
			tp->tx_aligned_skbuff[i] = dev_alloc_skb(PKT_BUF_SZ);
Linus Torvalds's avatar
Linus Torvalds committed
913
#endif /* CARDBUS */
Linus Torvalds's avatar
Linus Torvalds committed
914 915 916 917
	}
	tp->tx_ring[i-1].buffer2 = virt_to_bus(&tp->tx_ring[0]);
}

Linus Torvalds's avatar
Linus Torvalds committed
918

Linus Torvalds's avatar
Linus Torvalds committed
919
static int
Linus Torvalds's avatar
Linus Torvalds committed
920
xircom_start_xmit(struct sk_buff *skb, struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
921
{
Linus Torvalds's avatar
Linus Torvalds committed
922
	struct xircom_private *tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941
	int entry;
	u32 flag;

	/* Caution: the write order is important here, set the base address
	   with the "ownership" bits last. */

	/* Calculate the next Tx descriptor entry. */
	entry = tp->cur_tx % TX_RING_SIZE;

	tp->tx_skbuff[entry] = skb;
#ifdef CARDBUS
	if (tp->chip_id == X3201_3) {
		memcpy(tp->tx_aligned_skbuff[entry]->data,skb->data,skb->len);
		tp->tx_ring[entry].buffer1 = virt_to_bus(tp->tx_aligned_skbuff[entry]->data);
	} else
#endif
		tp->tx_ring[entry].buffer1 = virt_to_bus(skb->data);

	if (tp->cur_tx - tp->dirty_tx < TX_RING_SIZE/2) {/* Typical path */
Linus Torvalds's avatar
Linus Torvalds committed
942
		flag = Tx1WholePkt; /* No interrupt */
Linus Torvalds's avatar
Linus Torvalds committed
943
	} else if (tp->cur_tx - tp->dirty_tx == TX_RING_SIZE/2) {
Linus Torvalds's avatar
Linus Torvalds committed
944
		flag = Tx1WholePkt | Tx1ComplIntr; /* Tx-done intr. */
Linus Torvalds's avatar
Linus Torvalds committed
945
	} else if (tp->cur_tx - tp->dirty_tx < TX_RING_SIZE - 2) {
Linus Torvalds's avatar
Linus Torvalds committed
946
		flag = Tx1WholePkt; /* No Tx-done intr. */
Linus Torvalds's avatar
Linus Torvalds committed
947 948
	} else {
		/* Leave room for set_rx_mode() to fill entries. */
Linus Torvalds's avatar
Linus Torvalds committed
949
		flag = Tx1WholePkt | Tx1ComplIntr; /* Tx-done intr. */
Linus Torvalds's avatar
Linus Torvalds committed
950 951
		tp->tx_full = 1;
	}
Linus Torvalds's avatar
Linus Torvalds committed
952 953
	if (entry == TX_RING_SIZE - 1)
		flag |= Tx1WholePkt | Tx1ComplIntr | Tx1RingWrap;
Linus Torvalds's avatar
Linus Torvalds committed
954 955

	tp->tx_ring[entry].length = skb->len | flag;
Linus Torvalds's avatar
Linus Torvalds committed
956
	tp->tx_ring[entry].status = Tx0DescOwned;	/* Pass ownership to the chip. */
Linus Torvalds's avatar
Linus Torvalds committed
957 958 959 960 961 962 963 964 965 966 967 968 969 970
	tp->cur_tx++;
	if (tp->tx_full)
		netif_stop_queue (dev);
	else
		netif_wake_queue (dev);

	/* Trigger an immediate transmit demand. */
	outl(0, dev->base_addr + CSR1);

	dev->trans_start = jiffies;

	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019

static void xircom_media_change(struct net_device *dev)
{
	struct xircom_private *tp = dev->priv;
	long ioaddr = dev->base_addr;
	u16 reg0, reg1, reg4, reg5;
	u32 csr6 = inl(ioaddr + CSR6), newcsr6;

	/* reset status first */
	mdio_read(dev, tp->phys[0], MII_BMCR);
	mdio_read(dev, tp->phys[0], MII_BMSR);

	reg0 = mdio_read(dev, tp->phys[0], MII_BMCR);
	reg1 = mdio_read(dev, tp->phys[0], MII_BMSR);

	if (reg1 & BMSR_LSTATUS) {
		/* link is up */
		if (reg0 & BMCR_ANENABLE) {
			/* autonegotiation is enabled */
			reg4 = mdio_read(dev, tp->phys[0], MII_ADVERTISE);
			reg5 = mdio_read(dev, tp->phys[0], MII_LPA);
			if (reg4 & ADVERTISE_100FULL && reg5 & LPA_100FULL) {
				tp->speed100 = 1;
				tp->full_duplex = 1;
			} else if (reg4 & ADVERTISE_100HALF && reg5 & LPA_100HALF) {
				tp->speed100 = 1;
				tp->full_duplex = 0;
			} else if (reg4 & ADVERTISE_10FULL && reg5 & LPA_10FULL) {
				tp->speed100 = 0;
				tp->full_duplex = 1;
			} else {
				tp->speed100 = 0;
				tp->full_duplex = 0;
			}
		} else {
			/* autonegotiation is disabled */
			if (reg0 & BMCR_SPEED100)
				tp->speed100 = 1;
			else
				tp->speed100 = 0;
			if (reg0 & BMCR_FULLDPLX)
				tp->full_duplex = 1;
			else
				tp->full_duplex = 0;
		}
		printk(KERN_DEBUG "%s: Link is up, running at %sMbit %s-duplex\n",
		       dev->name,
		       tp->speed100 ? "100" : "10",
		       tp->full_duplex ? "full" : "half");
1020
		netif_carrier_on(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1021 1022 1023 1024 1025 1026 1027
		newcsr6 = csr6 & ~FullDuplexBit;
		if (tp->full_duplex)
			newcsr6 |= FullDuplexBit;
		if (newcsr6 != csr6)
			outl_CSR6(newcsr6, ioaddr + CSR6);
	} else {
		printk(KERN_DEBUG "%s: Link is down\n", dev->name);
1028
		netif_carrier_off(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062
	}
}


static void check_duplex(struct net_device *dev)
{
	struct xircom_private *tp = dev->priv;
	u16 reg0;

	mdio_write(dev, tp->phys[0], MII_BMCR, BMCR_RESET);
	udelay(500);
	while (mdio_read(dev, tp->phys[0], MII_BMCR) & BMCR_RESET);

	reg0 = mdio_read(dev, tp->phys[0], MII_BMCR);
	mdio_write(dev, tp->phys[0], MII_ADVERTISE, tp->advertising[0]);

	if (tp->autoneg) {
		reg0 &= ~(BMCR_SPEED100 | BMCR_FULLDPLX);
		reg0 |= BMCR_ANENABLE | BMCR_ANRESTART;
	} else {
		reg0 &= ~(BMCR_ANENABLE | BMCR_ANRESTART);
		if (tp->speed100)
			reg0 |= BMCR_SPEED100;
		if (tp->full_duplex)
			reg0 |= BMCR_FULLDPLX;
		printk(KERN_DEBUG "%s: Link forced to %sMbit %s-duplex\n",
		       dev->name,
		       tp->speed100 ? "100" : "10",
		       tp->full_duplex ? "full" : "half");
	}
	mdio_write(dev, tp->phys[0], MII_BMCR, reg0);
}


Linus Torvalds's avatar
Linus Torvalds committed
1063 1064
/* The interrupt handler does all of the Rx thread work and cleans up
   after the Tx thread. */
Jeff Garzik's avatar
Jeff Garzik committed
1065
static irqreturn_t xircom_interrupt(int irq, void *dev_instance, struct pt_regs *regs)
Linus Torvalds's avatar
Linus Torvalds committed
1066
{
Linus Torvalds's avatar
Linus Torvalds committed
1067 1068
	struct net_device *dev = dev_instance;
	struct xircom_private *tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
1069 1070
	long ioaddr = dev->base_addr;
	int csr5, work_budget = max_interrupt_work;
Jeff Garzik's avatar
Jeff Garzik committed
1071
	int handled = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1072 1073 1074 1075 1076 1077 1078 1079

	spin_lock (&tp->lock);

	do {
		csr5 = inl(ioaddr + CSR5);
		/* Acknowledge all of the current interrupt sources ASAP. */
		outl(csr5 & 0x0001ffff, ioaddr + CSR5);

Linus Torvalds's avatar
Linus Torvalds committed
1080
		if (xircom_debug > 4)
Linus Torvalds's avatar
Linus Torvalds committed
1081 1082 1083 1084 1085 1086 1087 1088 1089
			printk(KERN_DEBUG "%s: interrupt  csr5=%#8.8x new csr5=%#8.8x.\n",
				   dev->name, csr5, inl(dev->base_addr + CSR5));

		if (csr5 == 0xffffffff)
			break;	/* all bits set, assume PCMCIA card removed */

		if ((csr5 & (NormalIntr|AbnormalIntr)) == 0)
			break;

Jeff Garzik's avatar
Jeff Garzik committed
1090 1091
		handled = 1;

Linus Torvalds's avatar
Linus Torvalds committed
1092
		if (csr5 & (RxIntr | RxNoBuf))
Linus Torvalds's avatar
Linus Torvalds committed
1093
			work_budget -= xircom_rx(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1094 1095 1096 1097 1098 1099 1100 1101 1102 1103 1104 1105 1106 1107 1108

		if (csr5 & (TxNoBuf | TxDied | TxIntr)) {
			unsigned int dirty_tx;

			for (dirty_tx = tp->dirty_tx; tp->cur_tx - dirty_tx > 0;
				 dirty_tx++) {
				int entry = dirty_tx % TX_RING_SIZE;
				int status = tp->tx_ring[entry].status;

				if (status < 0)
					break;			/* It still hasn't been Txed */
				/* Check for Rx filter setup frames. */
				if (tp->tx_skbuff[entry] == NULL)
				  continue;

Linus Torvalds's avatar
Linus Torvalds committed
1109
				if (status & Tx0DescError) {
Linus Torvalds's avatar
Linus Torvalds committed
1110 1111
					/* There was an major error, log it. */
#ifndef final_version
Linus Torvalds's avatar
Linus Torvalds committed
1112
					if (xircom_debug > 1)
Linus Torvalds's avatar
Linus Torvalds committed
1113 1114 1115 1116
						printk(KERN_DEBUG "%s: Transmit error, Tx status %8.8x.\n",
							   dev->name, status);
#endif
					tp->stats.tx_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
1117 1118 1119 1120 1121 1122
					if (status & Tx0ManyColl) {
						tp->stats.tx_aborted_errors++;
					}
					if (status & Tx0NoCarrier) tp->stats.tx_carrier_errors++;
					if (status & Tx0LateColl) tp->stats.tx_window_errors++;
					if (status & Tx0Underflow) tp->stats.tx_fifo_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141
				} else {
					tp->stats.tx_bytes += tp->tx_ring[entry].length & 0x7ff;
					tp->stats.collisions += (status >> 3) & 15;
					tp->stats.tx_packets++;
				}

				/* Free the original skb. */
				dev_kfree_skb_irq(tp->tx_skbuff[entry]);
				tp->tx_skbuff[entry] = 0;
			}

#ifndef final_version
			if (tp->cur_tx - dirty_tx > TX_RING_SIZE) {
				printk(KERN_ERR "%s: Out-of-sync dirty pointer, %d vs. %d, full=%d.\n",
					   dev->name, dirty_tx, tp->cur_tx, tp->tx_full);
				dirty_tx += TX_RING_SIZE;
			}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
1142
			if (tp->tx_full &&
Linus Torvalds's avatar
Linus Torvalds committed
1143 1144 1145
			    tp->cur_tx - dirty_tx  < TX_RING_SIZE - 2)
				/* The ring is no longer full */
				tp->tx_full = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1146

Linus Torvalds's avatar
Linus Torvalds committed
1147 1148 1149 1150 1151 1152 1153
			if (tp->tx_full)
				netif_stop_queue (dev);
			else
				netif_wake_queue (dev);

			tp->dirty_tx = dirty_tx;
			if (csr5 & TxDied) {
Linus Torvalds's avatar
Linus Torvalds committed
1154
				if (xircom_debug > 2)
Linus Torvalds's avatar
Linus Torvalds committed
1155 1156 1157
					printk(KERN_WARNING "%s: The transmitter stopped."
						   "  CSR5 is %x, CSR6 %x, new CSR6 %x.\n",
						   dev->name, csr5, inl(ioaddr + CSR6), tp->csr6);
Linus Torvalds's avatar
Linus Torvalds committed
1158 1159
				outl_CSR6(tp->csr6 | EnableRx, ioaddr);
				outl_CSR6(tp->csr6 | EnableTxRx, ioaddr);
Linus Torvalds's avatar
Linus Torvalds committed
1160 1161 1162 1163 1164
			}
		}

		/* Log errors. */
		if (csr5 & AbnormalIntr) {	/* Abnormal error summary bit. */
Linus Torvalds's avatar
Linus Torvalds committed
1165 1166
			if (csr5 & LinkChange)
				xircom_media_change(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1167
			if (csr5 & TxFIFOUnderflow) {
Linus Torvalds's avatar
Linus Torvalds committed
1168 1169
				if ((tp->csr6 & TxThreshMask) != TxThreshMask)
					tp->csr6 += (1 << TxThreshShift);	/* Bump up the Tx threshold */
Linus Torvalds's avatar
Linus Torvalds committed
1170
				else
Linus Torvalds's avatar
Linus Torvalds committed
1171
					tp->csr6 |= TxStoreForw;  /* Store-n-forward. */
Linus Torvalds's avatar
Linus Torvalds committed
1172
				/* Restart the transmit process. */
Linus Torvalds's avatar
Linus Torvalds committed
1173 1174
				outl_CSR6(tp->csr6 | EnableRx, ioaddr);
				outl_CSR6(tp->csr6 | EnableTxRx, ioaddr);
Linus Torvalds's avatar
Linus Torvalds committed
1175 1176 1177 1178
			}
			if (csr5 & RxDied) {		/* Missed a Rx frame. */
				tp->stats.rx_errors++;
				tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff;
Linus Torvalds's avatar
Linus Torvalds committed
1179
				outl_CSR6(tp->csr6 | EnableTxRx, ioaddr);
Linus Torvalds's avatar
Linus Torvalds committed
1180 1181 1182 1183 1184
			}
			/* Clear all error sources, included undocumented ones! */
			outl(0x0800f7ba, ioaddr + CSR5);
		}
		if (--work_budget < 0) {
Linus Torvalds's avatar
Linus Torvalds committed
1185
			if (xircom_debug > 1)
Linus Torvalds's avatar
Linus Torvalds committed
1186 1187 1188 1189 1190 1191 1192 1193
				printk(KERN_WARNING "%s: Too much work during an interrupt, "
					   "csr5=0x%8.8x.\n", dev->name, csr5);
			/* Acknowledge all interrupt sources. */
			outl(0x8001ffff, ioaddr + CSR5);
			break;
		}
	} while (1);

Linus Torvalds's avatar
Linus Torvalds committed
1194
	if (xircom_debug > 3)
Linus Torvalds's avatar
Linus Torvalds committed
1195 1196 1197 1198
		printk(KERN_DEBUG "%s: exiting interrupt, csr5=%#4.4x.\n",
			   dev->name, inl(ioaddr + CSR5));

	spin_unlock (&tp->lock);
Jeff Garzik's avatar
Jeff Garzik committed
1199
	return IRQ_RETVAL(handled);
Linus Torvalds's avatar
Linus Torvalds committed
1200 1201
}

Linus Torvalds's avatar
Linus Torvalds committed
1202

Linus Torvalds's avatar
Linus Torvalds committed
1203
static int
Linus Torvalds's avatar
Linus Torvalds committed
1204
xircom_rx(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1205
{
Linus Torvalds's avatar
Linus Torvalds committed
1206
	struct xircom_private *tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
1207 1208 1209 1210
	int entry = tp->cur_rx % RX_RING_SIZE;
	int rx_work_limit = tp->dirty_rx + RX_RING_SIZE - tp->cur_rx;
	int work_done = 0;

Linus Torvalds's avatar
Linus Torvalds committed
1211 1212
	if (xircom_debug > 4)
		printk(KERN_DEBUG " In xircom_rx(), entry %d %8.8x.\n", entry,
Linus Torvalds's avatar
Linus Torvalds committed
1213 1214 1215 1216 1217
			   tp->rx_ring[entry].status);
	/* If we own the next entry, it's a new packet. Send it up. */
	while (tp->rx_ring[entry].status >= 0) {
		s32 status = tp->rx_ring[entry].status;

Linus Torvalds's avatar
Linus Torvalds committed
1218 1219
		if (xircom_debug > 5)
			printk(KERN_DEBUG " In xircom_rx(), entry %d %8.8x.\n", entry,
Linus Torvalds's avatar
Linus Torvalds committed
1220 1221 1222 1223 1224
				   tp->rx_ring[entry].status);
		if (--rx_work_limit < 0)
			break;
		if ((status & 0x38008300) != 0x0300) {
			if ((status & 0x38000300) != 0x0300) {
Linus Torvalds's avatar
Linus Torvalds committed
1225
				/* Ignore earlier buffers. */
Linus Torvalds's avatar
Linus Torvalds committed
1226
				if ((status & 0xffff) != 0x7fff) {
Linus Torvalds's avatar
Linus Torvalds committed
1227
					if (xircom_debug > 1)
Linus Torvalds's avatar
Linus Torvalds committed
1228 1229 1230 1231 1232
						printk(KERN_WARNING "%s: Oversized Ethernet frame "
							   "spanned multiple buffers, status %8.8x!\n",
							   dev->name, status);
					tp->stats.rx_length_errors++;
				}
Linus Torvalds's avatar
Linus Torvalds committed
1233
			} else if (status & Rx0DescError) {
Linus Torvalds's avatar
Linus Torvalds committed
1234
				/* There was a fatal error. */
Linus Torvalds's avatar
Linus Torvalds committed
1235
				if (xircom_debug > 2)
Linus Torvalds's avatar
Linus Torvalds committed
1236 1237 1238
					printk(KERN_DEBUG "%s: Receive error, Rx status %8.8x.\n",
						   dev->name, status);
				tp->stats.rx_errors++; /* end of a packet.*/
Linus Torvalds's avatar
Linus Torvalds committed
1239 1240
				if (status & (Rx0Runt | Rx0HugeFrame)) tp->stats.rx_length_errors++;
				if (status & Rx0CRCError) tp->stats.rx_crc_errors++;
Linus Torvalds's avatar
Linus Torvalds committed
1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270
			}
		} else {
			/* Omit the four octet CRC from the length. */
			short pkt_len = ((status >> 16) & 0x7ff) - 4;
			struct sk_buff *skb;

#ifndef final_version
			if (pkt_len > 1518) {
				printk(KERN_WARNING "%s: Bogus packet size of %d (%#x).\n",
					   dev->name, pkt_len, pkt_len);
				pkt_len = 1518;
				tp->stats.rx_length_errors++;
			}
#endif
			/* Check if the packet is long enough to accept without copying
			   to a minimally-sized skbuff. */
			if (pkt_len < rx_copybreak
				&& (skb = dev_alloc_skb(pkt_len + 2)) != NULL) {
				skb->dev = dev;
				skb_reserve(skb, 2);	/* 16 byte align the IP header */
#if ! defined(__alpha__)
				eth_copy_and_sum(skb, bus_to_virt(tp->rx_ring[entry].buffer1),
								 pkt_len, 0);
				skb_put(skb, pkt_len);
#else
				memcpy(skb_put(skb, pkt_len),
					   bus_to_virt(tp->rx_ring[entry].buffer1), pkt_len);
#endif
				work_done++;
			} else { 	/* Pass up the skb already on the Rx ring. */
Linus Torvalds's avatar
Linus Torvalds committed
1271
				skb_put(skb = tp->rx_skbuff[entry], pkt_len);
Linus Torvalds's avatar
Linus Torvalds committed
1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294
				tp->rx_skbuff[entry] = NULL;
			}
			skb->protocol = eth_type_trans(skb, dev);
			netif_rx(skb);
			dev->last_rx = jiffies;
			tp->stats.rx_packets++;
			tp->stats.rx_bytes += pkt_len;
		}
		entry = (++tp->cur_rx) % RX_RING_SIZE;
	}

	/* Refill the Rx ring buffers. */
	for (; tp->cur_rx - tp->dirty_rx > 0; tp->dirty_rx++) {
		entry = tp->dirty_rx % RX_RING_SIZE;
		if (tp->rx_skbuff[entry] == NULL) {
			struct sk_buff *skb;
			skb = tp->rx_skbuff[entry] = dev_alloc_skb(PKT_BUF_SZ);
			if (skb == NULL)
				break;
			skb->dev = dev;			/* Mark as being used by this device. */
			tp->rx_ring[entry].buffer1 = virt_to_bus(skb->tail);
			work_done++;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1295
		tp->rx_ring[entry].status = Rx0DescOwned;
Linus Torvalds's avatar
Linus Torvalds committed
1296 1297 1298 1299 1300
	}

	return work_done;
}

Linus Torvalds's avatar
Linus Torvalds committed
1301

Linus Torvalds's avatar
Linus Torvalds committed
1302
static void
Linus Torvalds's avatar
Linus Torvalds committed
1303
xircom_down(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1304 1305
{
	long ioaddr = dev->base_addr;
Linus Torvalds's avatar
Linus Torvalds committed
1306
	struct xircom_private *tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
1307 1308

	/* Disable interrupts by clearing the interrupt mask. */
Linus Torvalds's avatar
Linus Torvalds committed
1309
	outl(0, ioaddr + CSR7);
Linus Torvalds's avatar
Linus Torvalds committed
1310
	/* Stop the chip's Tx and Rx processes. */
Linus Torvalds's avatar
Linus Torvalds committed
1311
	outl_CSR6(inl(ioaddr + CSR6) & ~EnableTxRx, ioaddr);
Linus Torvalds's avatar
Linus Torvalds committed
1312 1313 1314 1315 1316 1317 1318

	if (inl(ioaddr + CSR6) != 0xffffffff)
		tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff;

	dev->if_port = tp->saved_if_port;
}

Linus Torvalds's avatar
Linus Torvalds committed
1319

Linus Torvalds's avatar
Linus Torvalds committed
1320
static int
Linus Torvalds's avatar
Linus Torvalds committed
1321
xircom_close(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1322 1323
{
	long ioaddr = dev->base_addr;
Linus Torvalds's avatar
Linus Torvalds committed
1324
	struct xircom_private *tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
1325 1326
	int i;

Linus Torvalds's avatar
Linus Torvalds committed
1327
	if (xircom_debug > 1)
Linus Torvalds's avatar
Linus Torvalds committed
1328 1329 1330 1331 1332 1333
		printk(KERN_DEBUG "%s: Shutting down ethercard, status was %2.2x.\n",
			   dev->name, inl(ioaddr + CSR5));

	netif_stop_queue(dev);

	if (netif_device_present(dev))
Linus Torvalds's avatar
Linus Torvalds committed
1334
		xircom_down(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1335 1336 1337 1338 1339 1340 1341

	free_irq(dev->irq, dev);

	/* Free all the skbuffs in the Rx queue. */
	for (i = 0; i < RX_RING_SIZE; i++) {
		struct sk_buff *skb = tp->rx_skbuff[i];
		tp->rx_skbuff[i] = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1342
		tp->rx_ring[i].status = 0;		/* Not owned by Xircom chip. */
Linus Torvalds's avatar
Linus Torvalds committed
1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358
		tp->rx_ring[i].length = 0;
		tp->rx_ring[i].buffer1 = 0xBADF00D0; /* An invalid address. */
		if (skb) {
			dev_kfree_skb(skb);
		}
	}
	for (i = 0; i < TX_RING_SIZE; i++) {
		if (tp->tx_skbuff[i])
			dev_kfree_skb(tp->tx_skbuff[i]);
		tp->tx_skbuff[i] = 0;
	}

	tp->open = 0;
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
1359 1360

static struct net_device_stats *xircom_get_stats(struct net_device *dev)
Linus Torvalds's avatar
Linus Torvalds committed
1361
{
Linus Torvalds's avatar
Linus Torvalds committed
1362
	struct xircom_private *tp = dev->priv;
Linus Torvalds's avatar
Linus Torvalds committed
1363 1364 1365 1366 1367 1368 1369 1370
	long ioaddr = dev->base_addr;

	if (netif_device_present(dev))
		tp->stats.rx_missed_errors += inl(ioaddr + CSR8) & 0xffff;

	return &tp->stats;
}

Linus Torvalds's avatar
Linus Torvalds committed
1371

1372
static int xircom_ethtool_ioctl(struct net_device *dev, void __user *useraddr)
Linus Torvalds's avatar
Linus Torvalds committed
1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454 1455 1456 1457
{
	struct ethtool_cmd ecmd;
	struct xircom_private *tp = dev->priv;

	if (copy_from_user(&ecmd, useraddr, sizeof(ecmd)))
		return -EFAULT;

	switch (ecmd.cmd) {
	case ETHTOOL_GSET:
		ecmd.supported =
			SUPPORTED_10baseT_Half |
			SUPPORTED_10baseT_Full |
			SUPPORTED_100baseT_Half |
			SUPPORTED_100baseT_Full |
			SUPPORTED_Autoneg |
			SUPPORTED_MII;

		ecmd.advertising = ADVERTISED_MII;
		if (tp->advertising[0] & ADVERTISE_10HALF)
			ecmd.advertising |= ADVERTISED_10baseT_Half;
		if (tp->advertising[0] & ADVERTISE_10FULL)
			ecmd.advertising |= ADVERTISED_10baseT_Full;
		if (tp->advertising[0] & ADVERTISE_100HALF)
			ecmd.advertising |= ADVERTISED_100baseT_Half;
		if (tp->advertising[0] & ADVERTISE_100FULL)
			ecmd.advertising |= ADVERTISED_100baseT_Full;
		if (tp->autoneg) {
			ecmd.advertising |= ADVERTISED_Autoneg;
			ecmd.autoneg = AUTONEG_ENABLE;
		} else
			ecmd.autoneg = AUTONEG_DISABLE;

		ecmd.port = PORT_MII;
		ecmd.transceiver = XCVR_INTERNAL;
		ecmd.phy_address = tp->phys[0];
		ecmd.speed = tp->speed100 ? SPEED_100 : SPEED_10;
		ecmd.duplex = tp->full_duplex ? DUPLEX_FULL : DUPLEX_HALF;
		ecmd.maxtxpkt = TX_RING_SIZE / 2;
		ecmd.maxrxpkt = 0;

		if (copy_to_user(useraddr, &ecmd, sizeof(ecmd)))
			return -EFAULT;
		return 0;

	case ETHTOOL_SSET: {
		u16 autoneg, speed100, full_duplex;

		autoneg = (ecmd.autoneg == AUTONEG_ENABLE);
		speed100 = (ecmd.speed == SPEED_100);
		full_duplex = (ecmd.duplex == DUPLEX_FULL);

		tp->autoneg = autoneg;
		if (speed100 != tp->speed100 ||
		    full_duplex != tp->full_duplex) {
			tp->speed100 = speed100;
			tp->full_duplex = full_duplex;
			/* change advertising bits */
			tp->advertising[0] &= ~(ADVERTISE_10HALF |
					     ADVERTISE_10FULL |
					     ADVERTISE_100HALF |
					     ADVERTISE_100FULL |
					     ADVERTISE_100BASE4);
			if (speed100) {
				if (full_duplex)
					tp->advertising[0] |= ADVERTISE_100FULL;
				else
					tp->advertising[0] |= ADVERTISE_100HALF;
			} else {
				if (full_duplex)
					tp->advertising[0] |= ADVERTISE_10FULL;
				else
					tp->advertising[0] |= ADVERTISE_10HALF;
			}
		}
		check_duplex(dev);
		return 0;
	}

	case ETHTOOL_GDRVINFO: {
		struct ethtool_drvinfo info;
		memset(&info, 0, sizeof(info));
		info.cmd = ecmd.cmd;
		strcpy(info.driver, DRV_NAME);
		strcpy(info.version, DRV_VERSION);
		*info.fw_version = 0;
1458
		strcpy(info.bus_info, pci_name(tp->pdev));
Linus Torvalds's avatar
Linus Torvalds committed
1459 1460 1461 1462 1463 1464 1465 1466 1467 1468 1469
		if (copy_to_user(useraddr, &info, sizeof(info)))
		       return -EFAULT;
		return 0;
	}

	default:
		return -EOPNOTSUPP;
	}
}


Linus Torvalds's avatar
Linus Torvalds committed
1470
/* Provide ioctl() calls to examine the MII xcvr state. */
Linus Torvalds's avatar
Linus Torvalds committed
1471
static int xircom_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
Linus Torvalds's avatar
Linus Torvalds committed
1472
{
Linus Torvalds's avatar
Linus Torvalds committed
1473
	struct xircom_private *tp = dev->priv;
1474
	u16 *data = (u16 *)&rq->ifr_ifru;
Linus Torvalds's avatar
Linus Torvalds committed
1475
	int phy = tp->phys[0] & 0x1f;
Jeff Garzik's avatar
Jeff Garzik committed
1476
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
1477 1478

	switch(cmd) {
Linus Torvalds's avatar
Linus Torvalds committed
1479
	case SIOCETHTOOL:
1480
		return xircom_ethtool_ioctl(dev, rq->ifr_data);
Linus Torvalds's avatar
Linus Torvalds committed
1481 1482 1483

	/* Legacy mii-diag interface */
	case SIOCGMIIPHY:		/* Get address of MII PHY in use. */
Linus Torvalds's avatar
Linus Torvalds committed
1484 1485 1486 1487 1488
		if (tp->mii_cnt)
			data[0] = phy;
		else
			return -ENODEV;
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1489 1490 1491 1492 1493
	case SIOCGMIIREG:		/* Read MII PHY register. */
		save_flags(flags);
		cli();
		data[3] = mdio_read(dev, data[0] & 0x1f, data[1] & 0x1f);
		restore_flags(flags);
Linus Torvalds's avatar
Linus Torvalds committed
1494
		return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1495
	case SIOCSMIIREG:		/* Write MII PHY register. */
Linus Torvalds's avatar
Linus Torvalds committed
1496 1497
		if (!capable(CAP_NET_ADMIN))
			return -EPERM;
Linus Torvalds's avatar
Linus Torvalds committed
1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516
		save_flags(flags);
		cli();
		if (data[0] == tp->phys[0]) {
			u16 value = data[2];
			switch (data[1]) {
			case 0:
				if (value & (BMCR_RESET | BMCR_ANENABLE))
					/* Autonegotiation. */
					tp->autoneg = 1;
				else {
					tp->full_duplex = (value & BMCR_FULLDPLX) ? 1 : 0;
					tp->autoneg = 0;
				}
				break;
			case 4:
				tp->advertising[0] = value;
				break;
			}
			check_duplex(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1517
		}
Linus Torvalds's avatar
Linus Torvalds committed
1518 1519
		mdio_write(dev, data[0] & 0x1f, data[1] & 0x1f, data[2]);
		restore_flags(flags);
Linus Torvalds's avatar
Linus Torvalds committed
1520 1521 1522 1523 1524 1525 1526 1527
		return 0;
	default:
		return -EOPNOTSUPP;
	}

	return -EOPNOTSUPP;
}

Linus Torvalds's avatar
Linus Torvalds committed
1528 1529 1530 1531
/* Set or clear the multicast filter for this adaptor.
   Note that we only use exclusion around actually queueing the
   new frame, not around filling tp->setup_frame.  This is non-deterministic
   when re-entered but still correct. */
Linus Torvalds's avatar
Linus Torvalds committed
1532 1533
static void set_rx_mode(struct net_device *dev)
{
Linus Torvalds's avatar
Linus Torvalds committed
1534 1535
	struct xircom_private *tp = dev->priv;
	struct dev_mc_list *mclist;
Linus Torvalds's avatar
Linus Torvalds committed
1536
	long ioaddr = dev->base_addr;
Linus Torvalds's avatar
Linus Torvalds committed
1537 1538 1539 1540
	int csr6 = inl(ioaddr + CSR6);
	u16 *eaddrs, *setup_frm;
	u32 tx_flags;
	int i;
Linus Torvalds's avatar
Linus Torvalds committed
1541

Linus Torvalds's avatar
Linus Torvalds committed
1542 1543
	tp->csr6 &= ~(AllMultiBit | PromiscBit | HashFilterBit);
	csr6 &= ~(AllMultiBit | PromiscBit | HashFilterBit);
Linus Torvalds's avatar
Linus Torvalds committed
1544
	if (dev->flags & IFF_PROMISC) {			/* Set promiscuous. */
Linus Torvalds's avatar
Linus Torvalds committed
1545 1546 1547 1548 1549 1550
		tp->csr6 |= PromiscBit;
		csr6 |= PromiscBit;
		goto out;
	}

	if ((dev->mc_count > 1000) || (dev->flags & IFF_ALLMULTI)) {
Linus Torvalds's avatar
Linus Torvalds committed
1551
		/* Too many to filter well -- accept all multicasts. */
Linus Torvalds's avatar
Linus Torvalds committed
1552 1553 1554 1555
		tp->csr6 |= AllMultiBit;
		csr6 |= AllMultiBit;
		goto out;
	}
Linus Torvalds's avatar
Linus Torvalds committed
1556

Linus Torvalds's avatar
Linus Torvalds committed
1557
	tx_flags = Tx1WholePkt | Tx1SetupPkt | PKT_SETUP_SZ;
Linus Torvalds's avatar
Linus Torvalds committed
1558

Linus Torvalds's avatar
Linus Torvalds committed
1559 1560 1561
	/* Note that only the low-address shortword of setup_frame is valid! */
	setup_frm = tp->setup_frame;
	mclist = dev->mc_list;
Linus Torvalds's avatar
Linus Torvalds committed
1562

Linus Torvalds's avatar
Linus Torvalds committed
1563 1564 1565 1566 1567
	/* Fill the first entry with our physical address. */
	eaddrs = (u16 *)dev->dev_addr;
	*setup_frm = cpu_to_le16(eaddrs[0]); setup_frm += 2;
	*setup_frm = cpu_to_le16(eaddrs[1]); setup_frm += 2;
	*setup_frm = cpu_to_le16(eaddrs[2]); setup_frm += 2;
Linus Torvalds's avatar
Linus Torvalds committed
1568

Linus Torvalds's avatar
Linus Torvalds committed
1569 1570 1571
	if (dev->mc_count > 14) { /* Must use a multicast hash table. */
		u32 *hash_table = (u32 *)(tp->setup_frame + 4 * 12);
		u32 hash, hash2;
Linus Torvalds's avatar
Linus Torvalds committed
1572

Linus Torvalds's avatar
Linus Torvalds committed
1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595
		tx_flags |= Tx1HashSetup;
		tp->csr6 |= HashFilterBit;
		csr6 |= HashFilterBit;

		/* Fill the unused 3 entries with the broadcast address.
		   At least one entry *must* contain the broadcast address!!!*/
		for (i = 0; i < 3; i++) {
			*setup_frm = 0xffff; setup_frm += 2;
			*setup_frm = 0xffff; setup_frm += 2;
			*setup_frm = 0xffff; setup_frm += 2;
		}

		/* Truly brain-damaged hash filter layout */
		/* XXX: not sure if I should take the last or the first 9 bits */
		for (i = 0; i < dev->mc_count; i++, mclist = mclist->next) {
			u32 *hptr;
			hash = ether_crc(ETH_ALEN, mclist->dmi_addr) & 0x1ff;
			if (hash < 384) {
				hash2 = hash + ((hash >> 4) << 4) +
					((hash >> 5) << 5);
			} else {
				hash -= 384;
				hash2 = 64 + hash + (hash >> 4) * 80;
Linus Torvalds's avatar
Linus Torvalds committed
1596
			}
Linus Torvalds's avatar
Linus Torvalds committed
1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614
			hptr = &hash_table[hash2 & ~0x1f];
			*hptr |= cpu_to_le32(1 << (hash2 & 0x1f));
		}
	} else {
		/* We have <= 14 mcast addresses so we can use Xircom's
		   wonderful 16-address perfect filter. */
		for (i = 0; i < dev->mc_count; i++, mclist = mclist->next) {
			eaddrs = (u16 *)mclist->dmi_addr;
			*setup_frm = cpu_to_le16(eaddrs[0]); setup_frm += 2;
			*setup_frm = cpu_to_le16(eaddrs[1]); setup_frm += 2;
			*setup_frm = cpu_to_le16(eaddrs[2]); setup_frm += 2;
		}
		/* Fill the unused entries with the broadcast address.
		   At least one entry *must* contain the broadcast address!!!*/
		for (; i < 15; i++) {
			*setup_frm = 0xffff; setup_frm += 2;
			*setup_frm = 0xffff; setup_frm += 2;
			*setup_frm = 0xffff; setup_frm += 2;
Linus Torvalds's avatar
Linus Torvalds committed
1615 1616 1617
		}
	}

Linus Torvalds's avatar
Linus Torvalds committed
1618 1619 1620 1621 1622 1623 1624 1625
	/* Now add this frame to the Tx list. */
	if (tp->cur_tx - tp->dirty_tx > TX_RING_SIZE - 2) {
		/* Same setup recently queued, we need not add it. */
		/* XXX: Huh? All it means is that the Tx list is full...*/
	} else {
		unsigned long flags;
		unsigned int entry;
		int dummy = -1;
Linus Torvalds's avatar
Linus Torvalds committed
1626

Linus Torvalds's avatar
Linus Torvalds committed
1627 1628
		save_flags(flags); cli();
		entry = tp->cur_tx++ % TX_RING_SIZE;
Linus Torvalds's avatar
Linus Torvalds committed
1629

Linus Torvalds's avatar
Linus Torvalds committed
1630 1631 1632 1633 1634 1635 1636 1637 1638 1639
		if (entry != 0) {
			/* Avoid a chip errata by prefixing a dummy entry. */
			tp->tx_skbuff[entry] = 0;
			tp->tx_ring[entry].length =
				(entry == TX_RING_SIZE - 1) ? Tx1RingWrap : 0;
			tp->tx_ring[entry].buffer1 = 0;
			/* race with chip, set Tx0DescOwned later */
			dummy = entry;
			entry = tp->cur_tx++ % TX_RING_SIZE;
		}
Linus Torvalds's avatar
Linus Torvalds committed
1640

Linus Torvalds's avatar
Linus Torvalds committed
1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656
		tp->tx_skbuff[entry] = 0;
		/* Put the setup frame on the Tx list. */
		if (entry == TX_RING_SIZE - 1)
			tx_flags |= Tx1RingWrap;		/* Wrap ring. */
		tp->tx_ring[entry].length = tx_flags;
		tp->tx_ring[entry].buffer1 = virt_to_bus(tp->setup_frame);
		tp->tx_ring[entry].status = Tx0DescOwned;
		if (tp->cur_tx - tp->dirty_tx >= TX_RING_SIZE - 2) {
			tp->tx_full = 1;
			netif_stop_queue (dev);
		}
		if (dummy >= 0)
			tp->tx_ring[dummy].status = Tx0DescOwned;
		restore_flags(flags);
		/* Trigger an immediate transmit demand. */
		outl(0, ioaddr + CSR1);
Linus Torvalds's avatar
Linus Torvalds committed
1657
	}
Linus Torvalds's avatar
Linus Torvalds committed
1658 1659 1660

out:
	outl_CSR6(csr6, ioaddr);
Linus Torvalds's avatar
Linus Torvalds committed
1661 1662
}

Linus Torvalds's avatar
Linus Torvalds committed
1663

1664
static struct pci_device_id xircom_pci_table[] = {
Linus Torvalds's avatar
Linus Torvalds committed
1665 1666 1667 1668 1669 1670 1671 1672
  { 0x115D, 0x0003, PCI_ANY_ID, PCI_ANY_ID, 0, 0, X3201_3 },
  {0},
};
MODULE_DEVICE_TABLE(pci, xircom_pci_table);


#ifdef CONFIG_PM
static int xircom_suspend(struct pci_dev *pdev, u32 state)
Linus Torvalds's avatar
Linus Torvalds committed
1673
{
Linus Torvalds's avatar
Linus Torvalds committed
1674
	struct net_device *dev = pci_get_drvdata(pdev);
Linus Torvalds's avatar
Linus Torvalds committed
1675 1676 1677 1678
	struct xircom_private *tp = dev->priv;
	printk(KERN_INFO "xircom_suspend(%s)\n", dev->name);
	if (tp->open)
		xircom_down(dev);
1679 1680 1681 1682 1683

	pci_save_state(pdev, tp->pci_state);
	pci_disable_device(pdev);
	pci_set_power_state(pdev, 3);

Linus Torvalds's avatar
Linus Torvalds committed
1684
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1685 1686
}

Linus Torvalds's avatar
Linus Torvalds committed
1687 1688

static int xircom_resume(struct pci_dev *pdev)
Linus Torvalds's avatar
Linus Torvalds committed
1689
{
Linus Torvalds's avatar
Linus Torvalds committed
1690
	struct net_device *dev = pci_get_drvdata(pdev);
Linus Torvalds's avatar
Linus Torvalds committed
1691 1692 1693
	struct xircom_private *tp = dev->priv;
	printk(KERN_INFO "xircom_resume(%s)\n", dev->name);

1694 1695 1696 1697
	pci_set_power_state(pdev,0);
	pci_enable_device(pdev);
	pci_restore_state(pdev, tp->pci_state);

Linus Torvalds's avatar
Linus Torvalds committed
1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708
	/* Bring the chip out of sleep mode.
	   Caution: Snooze mode does not work with some boards! */
	if (xircom_tbl[tp->chip_id].flags & HAS_ACPI)
		pci_write_config_dword(tp->pdev, PCI_POWERMGMT, 0);

	transceiver_voodoo(dev);
	if (xircom_tbl[tp->chip_id].flags & HAS_MII)
		check_duplex(dev);

	if (tp->open)
		xircom_up(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1709
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1710
}
Linus Torvalds's avatar
Linus Torvalds committed
1711
#endif /* CONFIG_PM */
Linus Torvalds's avatar
Linus Torvalds committed
1712

Linus Torvalds's avatar
Linus Torvalds committed
1713 1714

static void __devexit xircom_remove_one(struct pci_dev *pdev)
Linus Torvalds's avatar
Linus Torvalds committed
1715
{
Linus Torvalds's avatar
Linus Torvalds committed
1716
	struct net_device *dev = pci_get_drvdata(pdev);
Linus Torvalds's avatar
Linus Torvalds committed
1717

Linus Torvalds's avatar
Linus Torvalds committed
1718
	printk(KERN_INFO "xircom_remove_one(%s)\n", dev->name);
Linus Torvalds's avatar
Linus Torvalds committed
1719
	unregister_netdev(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1720
	pci_release_regions(pdev);
1721
	free_netdev(dev);
Linus Torvalds's avatar
Linus Torvalds committed
1722
	pci_set_drvdata(pdev, NULL);
Linus Torvalds's avatar
Linus Torvalds committed
1723 1724
}

Linus Torvalds's avatar
Linus Torvalds committed
1725 1726

static struct pci_driver xircom_driver = {
1727 1728 1729 1730
	.name		= DRV_NAME,
	.id_table	= xircom_pci_table,
	.probe		= xircom_init_one,
	.remove		= __devexit_p(xircom_remove_one),
Linus Torvalds's avatar
Linus Torvalds committed
1731
#ifdef CONFIG_PM
1732 1733
	.suspend	= xircom_suspend,
	.resume		= xircom_resume
Linus Torvalds's avatar
Linus Torvalds committed
1734
#endif /* CONFIG_PM */
Linus Torvalds's avatar
Linus Torvalds committed
1735 1736
};

Linus Torvalds's avatar
Linus Torvalds committed
1737 1738

static int __init xircom_init(void)
Linus Torvalds's avatar
Linus Torvalds committed
1739
{
Linus Torvalds's avatar
Linus Torvalds committed
1740 1741 1742 1743 1744
/* when a module, this is printed whether or not devices are found in probe */
#ifdef MODULE
	printk(version);
#endif
	return pci_module_init(&xircom_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1745 1746
}

Linus Torvalds's avatar
Linus Torvalds committed
1747 1748

static void __exit xircom_exit(void)
Linus Torvalds's avatar
Linus Torvalds committed
1749
{
Linus Torvalds's avatar
Linus Torvalds committed
1750
	pci_unregister_driver(&xircom_driver);
Linus Torvalds's avatar
Linus Torvalds committed
1751 1752
}

Linus Torvalds's avatar
Linus Torvalds committed
1753 1754
module_init(xircom_init)
module_exit(xircom_exit)
Linus Torvalds's avatar
Linus Torvalds committed
1755 1756 1757 1758 1759 1760 1761 1762

/*
 * Local variables:
 *  c-indent-level: 4
 *  c-basic-offset: 4
 *  tab-width: 4
 * End:
 */