1 /* de2104x.c: A Linux PCI Ethernet driver for Intel/Digital 21040/1 chips. */
2 /*
3 	Copyright 2001,2003 Jeff Garzik <jgarzik@pobox.com>
4 
5 	Copyright 1994, 1995 Digital Equipment Corporation.	    [de4x5.c]
6 	Written/copyright 1994-2001 by Donald Becker.		    [tulip.c]
7 
8 	This software may be used and distributed according to the terms of
9 	the GNU General Public License (GPL), incorporated herein by reference.
10 	Drivers based on or derived from this code fall under the GPL and must
11 	retain the authorship, copyright and license notice.  This file is not
12 	a complete program and may only be used when the entire operating
13 	system is licensed under the GPL.
14 
15 	See the file COPYING in this distribution for more information.
16 
17 	TODO, in rough priority order:
18 	* Support forcing media type with a module parameter,
19 	  like dl2k.c/sundance.c
20 	* Constants (module parms?) for Rx work limit
21 	* Complete reset on PciErr
22 	* Jumbo frames / dev->change_mtu
23 	* Adjust Rx FIFO threshold and Max Rx DMA burst on Rx FIFO error
24 	* Adjust Tx FIFO threshold and Max Tx DMA burst on Tx FIFO error
25 	* Implement Tx software interrupt mitigation via
26 	  Tx descriptor bit
27 
28  */
29 
30 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
31 
32 #define DRV_NAME		"de2104x"
33 #define DRV_VERSION		"0.7"
34 #define DRV_RELDATE		"Mar 17, 2004"
35 
36 #include <linux/module.h>
37 #include <linux/kernel.h>
38 #include <linux/netdevice.h>
39 #include <linux/etherdevice.h>
40 #include <linux/init.h>
41 #include <linux/interrupt.h>
42 #include <linux/pci.h>
43 #include <linux/delay.h>
44 #include <linux/ethtool.h>
45 #include <linux/compiler.h>
46 #include <linux/rtnetlink.h>
47 #include <linux/crc32.h>
48 #include <linux/slab.h>
49 
50 #include <asm/io.h>
51 #include <asm/irq.h>
52 #include <linux/uaccess.h>
53 #include <asm/unaligned.h>
54 
55 /* These identify the driver base version and may not be removed. */
56 static char version[] =
57 "PCI Ethernet driver v" DRV_VERSION " (" DRV_RELDATE ")";
58 
59 MODULE_AUTHOR("Jeff Garzik <jgarzik@pobox.com>");
60 MODULE_DESCRIPTION("Intel/Digital 21040/1 series PCI Ethernet driver");
61 MODULE_LICENSE("GPL");
62 MODULE_VERSION(DRV_VERSION);
63 
64 static int debug = -1;
65 module_param (debug, int, 0);
66 MODULE_PARM_DESC (debug, "de2104x bitmapped message enable number");
67 
68 /* Set the copy breakpoint for the copy-only-tiny-buffer Rx structure. */
69 #if defined(__alpha__) || defined(__arm__) || defined(__hppa__) || \
70         defined(CONFIG_SPARC) || defined(__ia64__) ||		   \
71         defined(__sh__) || defined(__mips__)
72 static int rx_copybreak = 1518;
73 #else
74 static int rx_copybreak = 100;
75 #endif
76 module_param (rx_copybreak, int, 0);
77 MODULE_PARM_DESC (rx_copybreak, "de2104x Breakpoint at which Rx packets are copied");
78 
79 #define DE_DEF_MSG_ENABLE	(NETIF_MSG_DRV		| \
80 				 NETIF_MSG_PROBE 	| \
81 				 NETIF_MSG_LINK		| \
82 				 NETIF_MSG_IFDOWN	| \
83 				 NETIF_MSG_IFUP		| \
84 				 NETIF_MSG_RX_ERR	| \
85 				 NETIF_MSG_TX_ERR)
86 
87 /* Descriptor skip length in 32 bit longwords. */
88 #ifndef CONFIG_DE2104X_DSL
89 #define DSL			0
90 #else
91 #define DSL			CONFIG_DE2104X_DSL
92 #endif
93 
94 #define DE_RX_RING_SIZE		64
95 #define DE_TX_RING_SIZE		64
96 #define DE_RING_BYTES		\
97 		((sizeof(struct de_desc) * DE_RX_RING_SIZE) +	\
98 		(sizeof(struct de_desc) * DE_TX_RING_SIZE))
99 #define NEXT_TX(N)		(((N) + 1) & (DE_TX_RING_SIZE - 1))
100 #define NEXT_RX(N)		(((N) + 1) & (DE_RX_RING_SIZE - 1))
101 #define TX_BUFFS_AVAIL(CP)					\
102 	(((CP)->tx_tail <= (CP)->tx_head) ?			\
103 	  (CP)->tx_tail + (DE_TX_RING_SIZE - 1) - (CP)->tx_head :	\
104 	  (CP)->tx_tail - (CP)->tx_head - 1)
105 
106 #define PKT_BUF_SZ		1536	/* Size of each temporary Rx buffer.*/
107 #define RX_OFFSET		2
108 
109 #define DE_SETUP_SKB		((struct sk_buff *) 1)
110 #define DE_DUMMY_SKB		((struct sk_buff *) 2)
111 #define DE_SETUP_FRAME_WORDS	96
112 #define DE_EEPROM_WORDS		256
113 #define DE_EEPROM_SIZE		(DE_EEPROM_WORDS * sizeof(u16))
114 #define DE_MAX_MEDIA		5
115 
116 #define DE_MEDIA_TP_AUTO	0
117 #define DE_MEDIA_BNC		1
118 #define DE_MEDIA_AUI		2
119 #define DE_MEDIA_TP		3
120 #define DE_MEDIA_TP_FD		4
121 #define DE_MEDIA_INVALID	DE_MAX_MEDIA
122 #define DE_MEDIA_FIRST		0
123 #define DE_MEDIA_LAST		(DE_MAX_MEDIA - 1)
124 #define DE_AUI_BNC		(SUPPORTED_AUI | SUPPORTED_BNC)
125 
126 #define DE_TIMER_LINK		(60 * HZ)
127 #define DE_TIMER_NO_LINK	(5 * HZ)
128 
129 #define DE_NUM_REGS		16
130 #define DE_REGS_SIZE		(DE_NUM_REGS * sizeof(u32))
131 #define DE_REGS_VER		1
132 
133 /* Time in jiffies before concluding the transmitter is hung. */
134 #define TX_TIMEOUT		(6*HZ)
135 
136 /* This is a mysterious value that can be written to CSR11 in the 21040 (only)
137    to support a pre-NWay full-duplex signaling mechanism using short frames.
138    No one knows what it should be, but if left at its default value some
139    10base2(!) packets trigger a full-duplex-request interrupt. */
140 #define FULL_DUPLEX_MAGIC	0x6969
141 
142 enum {
143 	/* NIC registers */
144 	BusMode			= 0x00,
145 	TxPoll			= 0x08,
146 	RxPoll			= 0x10,
147 	RxRingAddr		= 0x18,
148 	TxRingAddr		= 0x20,
149 	MacStatus		= 0x28,
150 	MacMode			= 0x30,
151 	IntrMask		= 0x38,
152 	RxMissed		= 0x40,
153 	ROMCmd			= 0x48,
154 	CSR11			= 0x58,
155 	SIAStatus		= 0x60,
156 	CSR13			= 0x68,
157 	CSR14			= 0x70,
158 	CSR15			= 0x78,
159 	PCIPM			= 0x40,
160 
161 	/* BusMode bits */
162 	CmdReset		= (1 << 0),
163 	CacheAlign16		= 0x00008000,
164 	BurstLen4		= 0x00000400,
165 	DescSkipLen		= (DSL << 2),
166 
167 	/* Rx/TxPoll bits */
168 	NormalTxPoll		= (1 << 0),
169 	NormalRxPoll		= (1 << 0),
170 
171 	/* Tx/Rx descriptor status bits */
172 	DescOwn			= (1 << 31),
173 	RxError			= (1 << 15),
174 	RxErrLong		= (1 << 7),
175 	RxErrCRC		= (1 << 1),
176 	RxErrFIFO		= (1 << 0),
177 	RxErrRunt		= (1 << 11),
178 	RxErrFrame		= (1 << 14),
179 	RingEnd			= (1 << 25),
180 	FirstFrag		= (1 << 29),
181 	LastFrag		= (1 << 30),
182 	TxError			= (1 << 15),
183 	TxFIFOUnder		= (1 << 1),
184 	TxLinkFail		= (1 << 2) | (1 << 10) | (1 << 11),
185 	TxMaxCol		= (1 << 8),
186 	TxOWC			= (1 << 9),
187 	TxJabber		= (1 << 14),
188 	SetupFrame		= (1 << 27),
189 	TxSwInt			= (1 << 31),
190 
191 	/* MacStatus bits */
192 	IntrOK			= (1 << 16),
193 	IntrErr			= (1 << 15),
194 	RxIntr			= (1 << 6),
195 	RxEmpty			= (1 << 7),
196 	TxIntr			= (1 << 0),
197 	TxEmpty			= (1 << 2),
198 	PciErr			= (1 << 13),
199 	TxState			= (1 << 22) | (1 << 21) | (1 << 20),
200 	RxState			= (1 << 19) | (1 << 18) | (1 << 17),
201 	LinkFail		= (1 << 12),
202 	LinkPass		= (1 << 4),
203 	RxStopped		= (1 << 8),
204 	TxStopped		= (1 << 1),
205 
206 	/* MacMode bits */
207 	TxEnable		= (1 << 13),
208 	RxEnable		= (1 << 1),
209 	RxTx			= TxEnable | RxEnable,
210 	FullDuplex		= (1 << 9),
211 	AcceptAllMulticast	= (1 << 7),
212 	AcceptAllPhys		= (1 << 6),
213 	BOCnt			= (1 << 5),
214 	MacModeClear		= (1<<12) | (1<<11) | (1<<10) | (1<<8) | (1<<3) |
215 				  RxTx | BOCnt | AcceptAllPhys | AcceptAllMulticast,
216 
217 	/* ROMCmd bits */
218 	EE_SHIFT_CLK		= 0x02,	/* EEPROM shift clock. */
219 	EE_CS			= 0x01,	/* EEPROM chip select. */
220 	EE_DATA_WRITE		= 0x04,	/* Data from the Tulip to EEPROM. */
221 	EE_WRITE_0		= 0x01,
222 	EE_WRITE_1		= 0x05,
223 	EE_DATA_READ		= 0x08,	/* Data from the EEPROM chip. */
224 	EE_ENB			= (0x4800 | EE_CS),
225 
226 	/* The EEPROM commands include the alway-set leading bit. */
227 	EE_READ_CMD		= 6,
228 
229 	/* RxMissed bits */
230 	RxMissedOver		= (1 << 16),
231 	RxMissedMask		= 0xffff,
232 
233 	/* SROM-related bits */
234 	SROMC0InfoLeaf		= 27,
235 	MediaBlockMask		= 0x3f,
236 	MediaCustomCSRs		= (1 << 6),
237 
238 	/* PCIPM bits */
239 	PM_Sleep		= (1 << 31),
240 	PM_Snooze		= (1 << 30),
241 	PM_Mask			= PM_Sleep | PM_Snooze,
242 
243 	/* SIAStatus bits */
244 	NWayState		= (1 << 14) | (1 << 13) | (1 << 12),
245 	NWayRestart		= (1 << 12),
246 	NonselPortActive	= (1 << 9),
247 	SelPortActive		= (1 << 8),
248 	LinkFailStatus		= (1 << 2),
249 	NetCxnErr		= (1 << 1),
250 };
251 
252 static const u32 de_intr_mask =
253 	IntrOK | IntrErr | RxIntr | RxEmpty | TxIntr | TxEmpty |
254 	LinkPass | LinkFail | PciErr;
255 
256 /*
257  * Set the programmable burst length to 4 longwords for all:
258  * DMA errors result without these values. Cache align 16 long.
259  */
260 static const u32 de_bus_mode = CacheAlign16 | BurstLen4 | DescSkipLen;
261 
262 struct de_srom_media_block {
263 	u8			opts;
264 	u16			csr13;
265 	u16			csr14;
266 	u16			csr15;
267 } __packed;
268 
269 struct de_srom_info_leaf {
270 	u16			default_media;
271 	u8			n_blocks;
272 	u8			unused;
273 } __packed;
274 
275 struct de_desc {
276 	__le32			opts1;
277 	__le32			opts2;
278 	__le32			addr1;
279 	__le32			addr2;
280 #if DSL
281 	__le32			skip[DSL];
282 #endif
283 };
284 
285 struct media_info {
286 	u16			type;	/* DE_MEDIA_xxx */
287 	u16			csr13;
288 	u16			csr14;
289 	u16			csr15;
290 };
291 
292 struct ring_info {
293 	struct sk_buff		*skb;
294 	dma_addr_t		mapping;
295 };
296 
297 struct de_private {
298 	unsigned		tx_head;
299 	unsigned		tx_tail;
300 	unsigned		rx_tail;
301 
302 	void			__iomem *regs;
303 	struct net_device	*dev;
304 	spinlock_t		lock;
305 
306 	struct de_desc		*rx_ring;
307 	struct de_desc		*tx_ring;
308 	struct ring_info	tx_skb[DE_TX_RING_SIZE];
309 	struct ring_info	rx_skb[DE_RX_RING_SIZE];
310 	unsigned		rx_buf_sz;
311 	dma_addr_t		ring_dma;
312 
313 	u32			msg_enable;
314 
315 	struct pci_dev		*pdev;
316 
317 	u16			setup_frame[DE_SETUP_FRAME_WORDS];
318 
319 	u32			media_type;
320 	u32			media_supported;
321 	u32			media_advertise;
322 	struct media_info	media[DE_MAX_MEDIA];
323 	struct timer_list	media_timer;
324 
325 	u8			*ee_data;
326 	unsigned		board_idx;
327 	unsigned		de21040 : 1;
328 	unsigned		media_lock : 1;
329 };
330 
331 
332 static void de_set_rx_mode (struct net_device *dev);
333 static void de_tx (struct de_private *de);
334 static void de_clean_rings (struct de_private *de);
335 static void de_media_interrupt (struct de_private *de, u32 status);
336 static void de21040_media_timer (struct timer_list *t);
337 static void de21041_media_timer (struct timer_list *t);
338 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media);
339 
340 
341 static const struct pci_device_id de_pci_tbl[] = {
342 	{ PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP,
343 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0 },
344 	{ PCI_VENDOR_ID_DEC, PCI_DEVICE_ID_DEC_TULIP_PLUS,
345 	  PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1 },
346 	{ },
347 };
348 MODULE_DEVICE_TABLE(pci, de_pci_tbl);
349 
350 static const char * const media_name[DE_MAX_MEDIA] = {
351 	"10baseT auto",
352 	"BNC",
353 	"AUI",
354 	"10baseT-HD",
355 	"10baseT-FD"
356 };
357 
358 /* 21040 transceiver register settings:
359  * TP AUTO(unused), BNC(unused), AUI, TP, TP FD*/
360 static u16 t21040_csr13[] = { 0, 0, 0x8F09, 0x8F01, 0x8F01, };
361 static u16 t21040_csr14[] = { 0, 0, 0x0705, 0xFFFF, 0xFFFD, };
362 static u16 t21040_csr15[] = { 0, 0, 0x0006, 0x0000, 0x0000, };
363 
364 /* 21041 transceiver register settings: TP AUTO, BNC, AUI, TP, TP FD*/
365 static u16 t21041_csr13[] = { 0xEF01, 0xEF09, 0xEF09, 0xEF01, 0xEF09, };
366 static u16 t21041_csr14[] = { 0xFFFF, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
367 /* If on-chip autonegotiation is broken, use half-duplex (FF3F) instead */
368 static u16 t21041_csr14_brk[] = { 0xFF3F, 0xF7FD, 0xF7FD, 0x7F3F, 0x7F3D, };
369 static u16 t21041_csr15[] = { 0x0008, 0x0006, 0x000E, 0x0008, 0x0008, };
370 
371 
372 #define dr32(reg)	ioread32(de->regs + (reg))
373 #define dw32(reg, val)	iowrite32((val), de->regs + (reg))
374 
375 
376 static void de_rx_err_acct (struct de_private *de, unsigned rx_tail,
377 			    u32 status, u32 len)
378 {
379 	netif_dbg(de, rx_err, de->dev,
380 		  "rx err, slot %d status 0x%x len %d\n",
381 		  rx_tail, status, len);
382 
383 	if ((status & 0x38000300) != 0x0300) {
384 		/* Ingore earlier buffers. */
385 		if ((status & 0xffff) != 0x7fff) {
386 			netif_warn(de, rx_err, de->dev,
387 				   "Oversized Ethernet frame spanned multiple buffers, status %08x!\n",
388 				   status);
389 			de->dev->stats.rx_length_errors++;
390 		}
391 	} else if (status & RxError) {
392 		/* There was a fatal error. */
393 		de->dev->stats.rx_errors++; /* end of a packet.*/
394 		if (status & 0x0890) de->dev->stats.rx_length_errors++;
395 		if (status & RxErrCRC) de->dev->stats.rx_crc_errors++;
396 		if (status & RxErrFIFO) de->dev->stats.rx_fifo_errors++;
397 	}
398 }
399 
400 static void de_rx (struct de_private *de)
401 {
402 	unsigned rx_tail = de->rx_tail;
403 	unsigned rx_work = DE_RX_RING_SIZE;
404 	unsigned drop = 0;
405 	int rc;
406 
407 	while (--rx_work) {
408 		u32 status, len;
409 		dma_addr_t mapping;
410 		struct sk_buff *skb, *copy_skb;
411 		unsigned copying_skb, buflen;
412 
413 		skb = de->rx_skb[rx_tail].skb;
414 		BUG_ON(!skb);
415 		rmb();
416 		status = le32_to_cpu(de->rx_ring[rx_tail].opts1);
417 		if (status & DescOwn)
418 			break;
419 
420 		len = ((status >> 16) & 0x7ff) - 4;
421 		mapping = de->rx_skb[rx_tail].mapping;
422 
423 		if (unlikely(drop)) {
424 			de->dev->stats.rx_dropped++;
425 			goto rx_next;
426 		}
427 
428 		if (unlikely((status & 0x38008300) != 0x0300)) {
429 			de_rx_err_acct(de, rx_tail, status, len);
430 			goto rx_next;
431 		}
432 
433 		copying_skb = (len <= rx_copybreak);
434 
435 		netif_dbg(de, rx_status, de->dev,
436 			  "rx slot %d status 0x%x len %d copying? %d\n",
437 			  rx_tail, status, len, copying_skb);
438 
439 		buflen = copying_skb ? (len + RX_OFFSET) : de->rx_buf_sz;
440 		copy_skb = netdev_alloc_skb(de->dev, buflen);
441 		if (unlikely(!copy_skb)) {
442 			de->dev->stats.rx_dropped++;
443 			drop = 1;
444 			rx_work = 100;
445 			goto rx_next;
446 		}
447 
448 		if (!copying_skb) {
449 			pci_unmap_single(de->pdev, mapping,
450 					 buflen, PCI_DMA_FROMDEVICE);
451 			skb_put(skb, len);
452 
453 			mapping =
454 			de->rx_skb[rx_tail].mapping =
455 				pci_map_single(de->pdev, copy_skb->data,
456 					       buflen, PCI_DMA_FROMDEVICE);
457 			de->rx_skb[rx_tail].skb = copy_skb;
458 		} else {
459 			pci_dma_sync_single_for_cpu(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
460 			skb_reserve(copy_skb, RX_OFFSET);
461 			skb_copy_from_linear_data(skb, skb_put(copy_skb, len),
462 						  len);
463 			pci_dma_sync_single_for_device(de->pdev, mapping, len, PCI_DMA_FROMDEVICE);
464 
465 			/* We'll reuse the original ring buffer. */
466 			skb = copy_skb;
467 		}
468 
469 		skb->protocol = eth_type_trans (skb, de->dev);
470 
471 		de->dev->stats.rx_packets++;
472 		de->dev->stats.rx_bytes += skb->len;
473 		rc = netif_rx (skb);
474 		if (rc == NET_RX_DROP)
475 			drop = 1;
476 
477 rx_next:
478 		if (rx_tail == (DE_RX_RING_SIZE - 1))
479 			de->rx_ring[rx_tail].opts2 =
480 				cpu_to_le32(RingEnd | de->rx_buf_sz);
481 		else
482 			de->rx_ring[rx_tail].opts2 = cpu_to_le32(de->rx_buf_sz);
483 		de->rx_ring[rx_tail].addr1 = cpu_to_le32(mapping);
484 		wmb();
485 		de->rx_ring[rx_tail].opts1 = cpu_to_le32(DescOwn);
486 		rx_tail = NEXT_RX(rx_tail);
487 	}
488 
489 	if (!rx_work)
490 		netdev_warn(de->dev, "rx work limit reached\n");
491 
492 	de->rx_tail = rx_tail;
493 }
494 
495 static irqreturn_t de_interrupt (int irq, void *dev_instance)
496 {
497 	struct net_device *dev = dev_instance;
498 	struct de_private *de = netdev_priv(dev);
499 	u32 status;
500 
501 	status = dr32(MacStatus);
502 	if ((!(status & (IntrOK|IntrErr))) || (status == 0xFFFF))
503 		return IRQ_NONE;
504 
505 	netif_dbg(de, intr, dev, "intr, status %08x mode %08x desc %u/%u/%u\n",
506 		  status, dr32(MacMode),
507 		  de->rx_tail, de->tx_head, de->tx_tail);
508 
509 	dw32(MacStatus, status);
510 
511 	if (status & (RxIntr | RxEmpty)) {
512 		de_rx(de);
513 		if (status & RxEmpty)
514 			dw32(RxPoll, NormalRxPoll);
515 	}
516 
517 	spin_lock(&de->lock);
518 
519 	if (status & (TxIntr | TxEmpty))
520 		de_tx(de);
521 
522 	if (status & (LinkPass | LinkFail))
523 		de_media_interrupt(de, status);
524 
525 	spin_unlock(&de->lock);
526 
527 	if (status & PciErr) {
528 		u16 pci_status;
529 
530 		pci_read_config_word(de->pdev, PCI_STATUS, &pci_status);
531 		pci_write_config_word(de->pdev, PCI_STATUS, pci_status);
532 		netdev_err(de->dev,
533 			   "PCI bus error, status=%08x, PCI status=%04x\n",
534 			   status, pci_status);
535 	}
536 
537 	return IRQ_HANDLED;
538 }
539 
540 static void de_tx (struct de_private *de)
541 {
542 	unsigned tx_head = de->tx_head;
543 	unsigned tx_tail = de->tx_tail;
544 
545 	while (tx_tail != tx_head) {
546 		struct sk_buff *skb;
547 		u32 status;
548 
549 		rmb();
550 		status = le32_to_cpu(de->tx_ring[tx_tail].opts1);
551 		if (status & DescOwn)
552 			break;
553 
554 		skb = de->tx_skb[tx_tail].skb;
555 		BUG_ON(!skb);
556 		if (unlikely(skb == DE_DUMMY_SKB))
557 			goto next;
558 
559 		if (unlikely(skb == DE_SETUP_SKB)) {
560 			pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
561 					 sizeof(de->setup_frame), PCI_DMA_TODEVICE);
562 			goto next;
563 		}
564 
565 		pci_unmap_single(de->pdev, de->tx_skb[tx_tail].mapping,
566 				 skb->len, PCI_DMA_TODEVICE);
567 
568 		if (status & LastFrag) {
569 			if (status & TxError) {
570 				netif_dbg(de, tx_err, de->dev,
571 					  "tx err, status 0x%x\n",
572 					  status);
573 				de->dev->stats.tx_errors++;
574 				if (status & TxOWC)
575 					de->dev->stats.tx_window_errors++;
576 				if (status & TxMaxCol)
577 					de->dev->stats.tx_aborted_errors++;
578 				if (status & TxLinkFail)
579 					de->dev->stats.tx_carrier_errors++;
580 				if (status & TxFIFOUnder)
581 					de->dev->stats.tx_fifo_errors++;
582 			} else {
583 				de->dev->stats.tx_packets++;
584 				de->dev->stats.tx_bytes += skb->len;
585 				netif_dbg(de, tx_done, de->dev,
586 					  "tx done, slot %d\n", tx_tail);
587 			}
588 			dev_kfree_skb_irq(skb);
589 		}
590 
591 next:
592 		de->tx_skb[tx_tail].skb = NULL;
593 
594 		tx_tail = NEXT_TX(tx_tail);
595 	}
596 
597 	de->tx_tail = tx_tail;
598 
599 	if (netif_queue_stopped(de->dev) && (TX_BUFFS_AVAIL(de) > (DE_TX_RING_SIZE / 4)))
600 		netif_wake_queue(de->dev);
601 }
602 
603 static netdev_tx_t de_start_xmit (struct sk_buff *skb,
604 					struct net_device *dev)
605 {
606 	struct de_private *de = netdev_priv(dev);
607 	unsigned int entry, tx_free;
608 	u32 mapping, len, flags = FirstFrag | LastFrag;
609 	struct de_desc *txd;
610 
611 	spin_lock_irq(&de->lock);
612 
613 	tx_free = TX_BUFFS_AVAIL(de);
614 	if (tx_free == 0) {
615 		netif_stop_queue(dev);
616 		spin_unlock_irq(&de->lock);
617 		return NETDEV_TX_BUSY;
618 	}
619 	tx_free--;
620 
621 	entry = de->tx_head;
622 
623 	txd = &de->tx_ring[entry];
624 
625 	len = skb->len;
626 	mapping = pci_map_single(de->pdev, skb->data, len, PCI_DMA_TODEVICE);
627 	if (entry == (DE_TX_RING_SIZE - 1))
628 		flags |= RingEnd;
629 	if (!tx_free || (tx_free == (DE_TX_RING_SIZE / 2)))
630 		flags |= TxSwInt;
631 	flags |= len;
632 	txd->opts2 = cpu_to_le32(flags);
633 	txd->addr1 = cpu_to_le32(mapping);
634 
635 	de->tx_skb[entry].skb = skb;
636 	de->tx_skb[entry].mapping = mapping;
637 	wmb();
638 
639 	txd->opts1 = cpu_to_le32(DescOwn);
640 	wmb();
641 
642 	de->tx_head = NEXT_TX(entry);
643 	netif_dbg(de, tx_queued, dev, "tx queued, slot %d, skblen %d\n",
644 		  entry, skb->len);
645 
646 	if (tx_free == 0)
647 		netif_stop_queue(dev);
648 
649 	spin_unlock_irq(&de->lock);
650 
651 	/* Trigger an immediate transmit demand. */
652 	dw32(TxPoll, NormalTxPoll);
653 
654 	return NETDEV_TX_OK;
655 }
656 
657 /* Set or clear the multicast filter for this adaptor.
658    Note that we only use exclusion around actually queueing the
659    new frame, not around filling de->setup_frame.  This is non-deterministic
660    when re-entered but still correct. */
661 
662 static void build_setup_frame_hash(u16 *setup_frm, struct net_device *dev)
663 {
664 	struct de_private *de = netdev_priv(dev);
665 	u16 hash_table[32];
666 	struct netdev_hw_addr *ha;
667 	int i;
668 	u16 *eaddrs;
669 
670 	memset(hash_table, 0, sizeof(hash_table));
671 	__set_bit_le(255, hash_table);			/* Broadcast entry */
672 	/* This should work on big-endian machines as well. */
673 	netdev_for_each_mc_addr(ha, dev) {
674 		int index = ether_crc_le(ETH_ALEN, ha->addr) & 0x1ff;
675 
676 		__set_bit_le(index, hash_table);
677 	}
678 
679 	for (i = 0; i < 32; i++) {
680 		*setup_frm++ = hash_table[i];
681 		*setup_frm++ = hash_table[i];
682 	}
683 	setup_frm = &de->setup_frame[13*6];
684 
685 	/* Fill the final entry with our physical address. */
686 	eaddrs = (u16 *)dev->dev_addr;
687 	*setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
688 	*setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
689 	*setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
690 }
691 
692 static void build_setup_frame_perfect(u16 *setup_frm, struct net_device *dev)
693 {
694 	struct de_private *de = netdev_priv(dev);
695 	struct netdev_hw_addr *ha;
696 	u16 *eaddrs;
697 
698 	/* We have <= 14 addresses so we can use the wonderful
699 	   16 address perfect filtering of the Tulip. */
700 	netdev_for_each_mc_addr(ha, dev) {
701 		eaddrs = (u16 *) ha->addr;
702 		*setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
703 		*setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
704 		*setup_frm++ = *eaddrs; *setup_frm++ = *eaddrs++;
705 	}
706 	/* Fill the unused entries with the broadcast address. */
707 	memset(setup_frm, 0xff, (15 - netdev_mc_count(dev)) * 12);
708 	setup_frm = &de->setup_frame[15*6];
709 
710 	/* Fill the final entry with our physical address. */
711 	eaddrs = (u16 *)dev->dev_addr;
712 	*setup_frm++ = eaddrs[0]; *setup_frm++ = eaddrs[0];
713 	*setup_frm++ = eaddrs[1]; *setup_frm++ = eaddrs[1];
714 	*setup_frm++ = eaddrs[2]; *setup_frm++ = eaddrs[2];
715 }
716 
717 
718 static void __de_set_rx_mode (struct net_device *dev)
719 {
720 	struct de_private *de = netdev_priv(dev);
721 	u32 macmode;
722 	unsigned int entry;
723 	u32 mapping;
724 	struct de_desc *txd;
725 	struct de_desc *dummy_txd = NULL;
726 
727 	macmode = dr32(MacMode) & ~(AcceptAllMulticast | AcceptAllPhys);
728 
729 	if (dev->flags & IFF_PROMISC) {	/* Set promiscuous. */
730 		macmode |= AcceptAllMulticast | AcceptAllPhys;
731 		goto out;
732 	}
733 
734 	if ((netdev_mc_count(dev) > 1000) || (dev->flags & IFF_ALLMULTI)) {
735 		/* Too many to filter well -- accept all multicasts. */
736 		macmode |= AcceptAllMulticast;
737 		goto out;
738 	}
739 
740 	/* Note that only the low-address shortword of setup_frame is valid!
741 	   The values are doubled for big-endian architectures. */
742 	if (netdev_mc_count(dev) > 14)	/* Must use a multicast hash table. */
743 		build_setup_frame_hash (de->setup_frame, dev);
744 	else
745 		build_setup_frame_perfect (de->setup_frame, dev);
746 
747 	/*
748 	 * Now add this frame to the Tx list.
749 	 */
750 
751 	entry = de->tx_head;
752 
753 	/* Avoid a chip errata by prefixing a dummy entry. */
754 	if (entry != 0) {
755 		de->tx_skb[entry].skb = DE_DUMMY_SKB;
756 
757 		dummy_txd = &de->tx_ring[entry];
758 		dummy_txd->opts2 = (entry == (DE_TX_RING_SIZE - 1)) ?
759 				   cpu_to_le32(RingEnd) : 0;
760 		dummy_txd->addr1 = 0;
761 
762 		/* Must set DescOwned later to avoid race with chip */
763 
764 		entry = NEXT_TX(entry);
765 	}
766 
767 	de->tx_skb[entry].skb = DE_SETUP_SKB;
768 	de->tx_skb[entry].mapping = mapping =
769 	    pci_map_single (de->pdev, de->setup_frame,
770 			    sizeof (de->setup_frame), PCI_DMA_TODEVICE);
771 
772 	/* Put the setup frame on the Tx list. */
773 	txd = &de->tx_ring[entry];
774 	if (entry == (DE_TX_RING_SIZE - 1))
775 		txd->opts2 = cpu_to_le32(SetupFrame | RingEnd | sizeof (de->setup_frame));
776 	else
777 		txd->opts2 = cpu_to_le32(SetupFrame | sizeof (de->setup_frame));
778 	txd->addr1 = cpu_to_le32(mapping);
779 	wmb();
780 
781 	txd->opts1 = cpu_to_le32(DescOwn);
782 	wmb();
783 
784 	if (dummy_txd) {
785 		dummy_txd->opts1 = cpu_to_le32(DescOwn);
786 		wmb();
787 	}
788 
789 	de->tx_head = NEXT_TX(entry);
790 
791 	if (TX_BUFFS_AVAIL(de) == 0)
792 		netif_stop_queue(dev);
793 
794 	/* Trigger an immediate transmit demand. */
795 	dw32(TxPoll, NormalTxPoll);
796 
797 out:
798 	if (macmode != dr32(MacMode))
799 		dw32(MacMode, macmode);
800 }
801 
802 static void de_set_rx_mode (struct net_device *dev)
803 {
804 	unsigned long flags;
805 	struct de_private *de = netdev_priv(dev);
806 
807 	spin_lock_irqsave (&de->lock, flags);
808 	__de_set_rx_mode(dev);
809 	spin_unlock_irqrestore (&de->lock, flags);
810 }
811 
812 static inline void de_rx_missed(struct de_private *de, u32 rx_missed)
813 {
814 	if (unlikely(rx_missed & RxMissedOver))
815 		de->dev->stats.rx_missed_errors += RxMissedMask;
816 	else
817 		de->dev->stats.rx_missed_errors += (rx_missed & RxMissedMask);
818 }
819 
820 static void __de_get_stats(struct de_private *de)
821 {
822 	u32 tmp = dr32(RxMissed); /* self-clearing */
823 
824 	de_rx_missed(de, tmp);
825 }
826 
827 static struct net_device_stats *de_get_stats(struct net_device *dev)
828 {
829 	struct de_private *de = netdev_priv(dev);
830 
831 	/* The chip only need report frame silently dropped. */
832 	spin_lock_irq(&de->lock);
833  	if (netif_running(dev) && netif_device_present(dev))
834  		__de_get_stats(de);
835 	spin_unlock_irq(&de->lock);
836 
837 	return &dev->stats;
838 }
839 
840 static inline int de_is_running (struct de_private *de)
841 {
842 	return (dr32(MacStatus) & (RxState | TxState)) ? 1 : 0;
843 }
844 
845 static void de_stop_rxtx (struct de_private *de)
846 {
847 	u32 macmode;
848 	unsigned int i = 1300/100;
849 
850 	macmode = dr32(MacMode);
851 	if (macmode & RxTx) {
852 		dw32(MacMode, macmode & ~RxTx);
853 		dr32(MacMode);
854 	}
855 
856 	/* wait until in-flight frame completes.
857 	 * Max time @ 10BT: 1500*8b/10Mbps == 1200us (+ 100us margin)
858 	 * Typically expect this loop to end in < 50 us on 100BT.
859 	 */
860 	while (--i) {
861 		if (!de_is_running(de))
862 			return;
863 		udelay(100);
864 	}
865 
866 	netdev_warn(de->dev, "timeout expired, stopping DMA\n");
867 }
868 
869 static inline void de_start_rxtx (struct de_private *de)
870 {
871 	u32 macmode;
872 
873 	macmode = dr32(MacMode);
874 	if ((macmode & RxTx) != RxTx) {
875 		dw32(MacMode, macmode | RxTx);
876 		dr32(MacMode);
877 	}
878 }
879 
880 static void de_stop_hw (struct de_private *de)
881 {
882 
883 	udelay(5);
884 	dw32(IntrMask, 0);
885 
886 	de_stop_rxtx(de);
887 
888 	dw32(MacStatus, dr32(MacStatus));
889 
890 	udelay(10);
891 
892 	de->rx_tail = 0;
893 	de->tx_head = de->tx_tail = 0;
894 }
895 
896 static void de_link_up(struct de_private *de)
897 {
898 	if (!netif_carrier_ok(de->dev)) {
899 		netif_carrier_on(de->dev);
900 		netif_info(de, link, de->dev, "link up, media %s\n",
901 			   media_name[de->media_type]);
902 	}
903 }
904 
905 static void de_link_down(struct de_private *de)
906 {
907 	if (netif_carrier_ok(de->dev)) {
908 		netif_carrier_off(de->dev);
909 		netif_info(de, link, de->dev, "link down\n");
910 	}
911 }
912 
913 static void de_set_media (struct de_private *de)
914 {
915 	unsigned media = de->media_type;
916 	u32 macmode = dr32(MacMode);
917 
918 	if (de_is_running(de))
919 		netdev_warn(de->dev, "chip is running while changing media!\n");
920 
921 	if (de->de21040)
922 		dw32(CSR11, FULL_DUPLEX_MAGIC);
923 	dw32(CSR13, 0); /* Reset phy */
924 	dw32(CSR14, de->media[media].csr14);
925 	dw32(CSR15, de->media[media].csr15);
926 	dw32(CSR13, de->media[media].csr13);
927 
928 	/* must delay 10ms before writing to other registers,
929 	 * especially CSR6
930 	 */
931 	mdelay(10);
932 
933 	if (media == DE_MEDIA_TP_FD)
934 		macmode |= FullDuplex;
935 	else
936 		macmode &= ~FullDuplex;
937 
938 	netif_info(de, link, de->dev, "set link %s\n", media_name[media]);
939 	netif_info(de, hw, de->dev, "mode 0x%x, sia 0x%x,0x%x,0x%x,0x%x\n",
940 		   dr32(MacMode), dr32(SIAStatus),
941 		   dr32(CSR13), dr32(CSR14), dr32(CSR15));
942 	netif_info(de, hw, de->dev, "set mode 0x%x, set sia 0x%x,0x%x,0x%x\n",
943 		   macmode, de->media[media].csr13,
944 		   de->media[media].csr14, de->media[media].csr15);
945 	if (macmode != dr32(MacMode))
946 		dw32(MacMode, macmode);
947 }
948 
949 static void de_next_media (struct de_private *de, const u32 *media,
950 			   unsigned int n_media)
951 {
952 	unsigned int i;
953 
954 	for (i = 0; i < n_media; i++) {
955 		if (de_ok_to_advertise(de, media[i])) {
956 			de->media_type = media[i];
957 			return;
958 		}
959 	}
960 }
961 
962 static void de21040_media_timer (struct timer_list *t)
963 {
964 	struct de_private *de = from_timer(de, t, media_timer);
965 	struct net_device *dev = de->dev;
966 	u32 status = dr32(SIAStatus);
967 	unsigned int carrier;
968 	unsigned long flags;
969 
970 	carrier = (status & NetCxnErr) ? 0 : 1;
971 
972 	if (carrier) {
973 		if (de->media_type != DE_MEDIA_AUI && (status & LinkFailStatus))
974 			goto no_link_yet;
975 
976 		de->media_timer.expires = jiffies + DE_TIMER_LINK;
977 		add_timer(&de->media_timer);
978 		if (!netif_carrier_ok(dev))
979 			de_link_up(de);
980 		else
981 			netif_info(de, timer, dev, "%s link ok, status %x\n",
982 				   media_name[de->media_type], status);
983 		return;
984 	}
985 
986 	de_link_down(de);
987 
988 	if (de->media_lock)
989 		return;
990 
991 	if (de->media_type == DE_MEDIA_AUI) {
992 		static const u32 next_state = DE_MEDIA_TP;
993 		de_next_media(de, &next_state, 1);
994 	} else {
995 		static const u32 next_state = DE_MEDIA_AUI;
996 		de_next_media(de, &next_state, 1);
997 	}
998 
999 	spin_lock_irqsave(&de->lock, flags);
1000 	de_stop_rxtx(de);
1001 	spin_unlock_irqrestore(&de->lock, flags);
1002 	de_set_media(de);
1003 	de_start_rxtx(de);
1004 
1005 no_link_yet:
1006 	de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1007 	add_timer(&de->media_timer);
1008 
1009 	netif_info(de, timer, dev, "no link, trying media %s, status %x\n",
1010 		   media_name[de->media_type], status);
1011 }
1012 
1013 static unsigned int de_ok_to_advertise (struct de_private *de, u32 new_media)
1014 {
1015 	switch (new_media) {
1016 	case DE_MEDIA_TP_AUTO:
1017 		if (!(de->media_advertise & ADVERTISED_Autoneg))
1018 			return 0;
1019 		if (!(de->media_advertise & (ADVERTISED_10baseT_Half | ADVERTISED_10baseT_Full)))
1020 			return 0;
1021 		break;
1022 	case DE_MEDIA_BNC:
1023 		if (!(de->media_advertise & ADVERTISED_BNC))
1024 			return 0;
1025 		break;
1026 	case DE_MEDIA_AUI:
1027 		if (!(de->media_advertise & ADVERTISED_AUI))
1028 			return 0;
1029 		break;
1030 	case DE_MEDIA_TP:
1031 		if (!(de->media_advertise & ADVERTISED_10baseT_Half))
1032 			return 0;
1033 		break;
1034 	case DE_MEDIA_TP_FD:
1035 		if (!(de->media_advertise & ADVERTISED_10baseT_Full))
1036 			return 0;
1037 		break;
1038 	}
1039 
1040 	return 1;
1041 }
1042 
1043 static void de21041_media_timer (struct timer_list *t)
1044 {
1045 	struct de_private *de = from_timer(de, t, media_timer);
1046 	struct net_device *dev = de->dev;
1047 	u32 status = dr32(SIAStatus);
1048 	unsigned int carrier;
1049 	unsigned long flags;
1050 
1051 	/* clear port active bits */
1052 	dw32(SIAStatus, NonselPortActive | SelPortActive);
1053 
1054 	carrier = (status & NetCxnErr) ? 0 : 1;
1055 
1056 	if (carrier) {
1057 		if ((de->media_type == DE_MEDIA_TP_AUTO ||
1058 		     de->media_type == DE_MEDIA_TP ||
1059 		     de->media_type == DE_MEDIA_TP_FD) &&
1060 		    (status & LinkFailStatus))
1061 			goto no_link_yet;
1062 
1063 		de->media_timer.expires = jiffies + DE_TIMER_LINK;
1064 		add_timer(&de->media_timer);
1065 		if (!netif_carrier_ok(dev))
1066 			de_link_up(de);
1067 		else
1068 			netif_info(de, timer, dev,
1069 				   "%s link ok, mode %x status %x\n",
1070 				   media_name[de->media_type],
1071 				   dr32(MacMode), status);
1072 		return;
1073 	}
1074 
1075 	de_link_down(de);
1076 
1077 	/* if media type locked, don't switch media */
1078 	if (de->media_lock)
1079 		goto set_media;
1080 
1081 	/* if activity detected, use that as hint for new media type */
1082 	if (status & NonselPortActive) {
1083 		unsigned int have_media = 1;
1084 
1085 		/* if AUI/BNC selected, then activity is on TP port */
1086 		if (de->media_type == DE_MEDIA_AUI ||
1087 		    de->media_type == DE_MEDIA_BNC) {
1088 			if (de_ok_to_advertise(de, DE_MEDIA_TP_AUTO))
1089 				de->media_type = DE_MEDIA_TP_AUTO;
1090 			else
1091 				have_media = 0;
1092 		}
1093 
1094 		/* TP selected.  If there is only TP and BNC, then it's BNC */
1095 		else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_BNC) &&
1096 			 de_ok_to_advertise(de, DE_MEDIA_BNC))
1097 			de->media_type = DE_MEDIA_BNC;
1098 
1099 		/* TP selected.  If there is only TP and AUI, then it's AUI */
1100 		else if (((de->media_supported & DE_AUI_BNC) == SUPPORTED_AUI) &&
1101 			 de_ok_to_advertise(de, DE_MEDIA_AUI))
1102 			de->media_type = DE_MEDIA_AUI;
1103 
1104 		/* otherwise, ignore the hint */
1105 		else
1106 			have_media = 0;
1107 
1108 		if (have_media)
1109 			goto set_media;
1110 	}
1111 
1112 	/*
1113 	 * Absent or ambiguous activity hint, move to next advertised
1114 	 * media state.  If de->media_type is left unchanged, this
1115 	 * simply resets the PHY and reloads the current media settings.
1116 	 */
1117 	if (de->media_type == DE_MEDIA_AUI) {
1118 		static const u32 next_states[] = {
1119 			DE_MEDIA_BNC, DE_MEDIA_TP_AUTO
1120 		};
1121 		de_next_media(de, next_states, ARRAY_SIZE(next_states));
1122 	} else if (de->media_type == DE_MEDIA_BNC) {
1123 		static const u32 next_states[] = {
1124 			DE_MEDIA_TP_AUTO, DE_MEDIA_AUI
1125 		};
1126 		de_next_media(de, next_states, ARRAY_SIZE(next_states));
1127 	} else {
1128 		static const u32 next_states[] = {
1129 			DE_MEDIA_AUI, DE_MEDIA_BNC, DE_MEDIA_TP_AUTO
1130 		};
1131 		de_next_media(de, next_states, ARRAY_SIZE(next_states));
1132 	}
1133 
1134 set_media:
1135 	spin_lock_irqsave(&de->lock, flags);
1136 	de_stop_rxtx(de);
1137 	spin_unlock_irqrestore(&de->lock, flags);
1138 	de_set_media(de);
1139 	de_start_rxtx(de);
1140 
1141 no_link_yet:
1142 	de->media_timer.expires = jiffies + DE_TIMER_NO_LINK;
1143 	add_timer(&de->media_timer);
1144 
1145 	netif_info(de, timer, dev, "no link, trying media %s, status %x\n",
1146 		   media_name[de->media_type], status);
1147 }
1148 
1149 static void de_media_interrupt (struct de_private *de, u32 status)
1150 {
1151 	if (status & LinkPass) {
1152 		/* Ignore if current media is AUI or BNC and we can't use TP */
1153 		if ((de->media_type == DE_MEDIA_AUI ||
1154 		     de->media_type == DE_MEDIA_BNC) &&
1155 		    (de->media_lock ||
1156 		     !de_ok_to_advertise(de, DE_MEDIA_TP_AUTO)))
1157 			return;
1158 		/* If current media is not TP, change it to TP */
1159 		if ((de->media_type == DE_MEDIA_AUI ||
1160 		     de->media_type == DE_MEDIA_BNC)) {
1161 			de->media_type = DE_MEDIA_TP_AUTO;
1162 			de_stop_rxtx(de);
1163 			de_set_media(de);
1164 			de_start_rxtx(de);
1165 		}
1166 		de_link_up(de);
1167 		mod_timer(&de->media_timer, jiffies + DE_TIMER_LINK);
1168 		return;
1169 	}
1170 
1171 	BUG_ON(!(status & LinkFail));
1172 	/* Mark the link as down only if current media is TP */
1173 	if (netif_carrier_ok(de->dev) && de->media_type != DE_MEDIA_AUI &&
1174 	    de->media_type != DE_MEDIA_BNC) {
1175 		de_link_down(de);
1176 		mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1177 	}
1178 }
1179 
1180 static int de_reset_mac (struct de_private *de)
1181 {
1182 	u32 status, tmp;
1183 
1184 	/*
1185 	 * Reset MAC.  de4x5.c and tulip.c examined for "advice"
1186 	 * in this area.
1187 	 */
1188 
1189 	if (dr32(BusMode) == 0xffffffff)
1190 		return -EBUSY;
1191 
1192 	/* Reset the chip, holding bit 0 set at least 50 PCI cycles. */
1193 	dw32 (BusMode, CmdReset);
1194 	mdelay (1);
1195 
1196 	dw32 (BusMode, de_bus_mode);
1197 	mdelay (1);
1198 
1199 	for (tmp = 0; tmp < 5; tmp++) {
1200 		dr32 (BusMode);
1201 		mdelay (1);
1202 	}
1203 
1204 	mdelay (1);
1205 
1206 	status = dr32(MacStatus);
1207 	if (status & (RxState | TxState))
1208 		return -EBUSY;
1209 	if (status == 0xffffffff)
1210 		return -ENODEV;
1211 	return 0;
1212 }
1213 
1214 static void de_adapter_wake (struct de_private *de)
1215 {
1216 	u32 pmctl;
1217 
1218 	if (de->de21040)
1219 		return;
1220 
1221 	pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1222 	if (pmctl & PM_Mask) {
1223 		pmctl &= ~PM_Mask;
1224 		pci_write_config_dword(de->pdev, PCIPM, pmctl);
1225 
1226 		/* de4x5.c delays, so we do too */
1227 		msleep(10);
1228 	}
1229 }
1230 
1231 static void de_adapter_sleep (struct de_private *de)
1232 {
1233 	u32 pmctl;
1234 
1235 	if (de->de21040)
1236 		return;
1237 
1238 	dw32(CSR13, 0); /* Reset phy */
1239 	pci_read_config_dword(de->pdev, PCIPM, &pmctl);
1240 	pmctl |= PM_Sleep;
1241 	pci_write_config_dword(de->pdev, PCIPM, pmctl);
1242 }
1243 
1244 static int de_init_hw (struct de_private *de)
1245 {
1246 	struct net_device *dev = de->dev;
1247 	u32 macmode;
1248 	int rc;
1249 
1250 	de_adapter_wake(de);
1251 
1252 	macmode = dr32(MacMode) & ~MacModeClear;
1253 
1254 	rc = de_reset_mac(de);
1255 	if (rc)
1256 		return rc;
1257 
1258 	de_set_media(de); /* reset phy */
1259 
1260 	dw32(RxRingAddr, de->ring_dma);
1261 	dw32(TxRingAddr, de->ring_dma + (sizeof(struct de_desc) * DE_RX_RING_SIZE));
1262 
1263 	dw32(MacMode, RxTx | macmode);
1264 
1265 	dr32(RxMissed); /* self-clearing */
1266 
1267 	dw32(IntrMask, de_intr_mask);
1268 
1269 	de_set_rx_mode(dev);
1270 
1271 	return 0;
1272 }
1273 
1274 static int de_refill_rx (struct de_private *de)
1275 {
1276 	unsigned i;
1277 
1278 	for (i = 0; i < DE_RX_RING_SIZE; i++) {
1279 		struct sk_buff *skb;
1280 
1281 		skb = netdev_alloc_skb(de->dev, de->rx_buf_sz);
1282 		if (!skb)
1283 			goto err_out;
1284 
1285 		de->rx_skb[i].mapping = pci_map_single(de->pdev,
1286 			skb->data, de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1287 		de->rx_skb[i].skb = skb;
1288 
1289 		de->rx_ring[i].opts1 = cpu_to_le32(DescOwn);
1290 		if (i == (DE_RX_RING_SIZE - 1))
1291 			de->rx_ring[i].opts2 =
1292 				cpu_to_le32(RingEnd | de->rx_buf_sz);
1293 		else
1294 			de->rx_ring[i].opts2 = cpu_to_le32(de->rx_buf_sz);
1295 		de->rx_ring[i].addr1 = cpu_to_le32(de->rx_skb[i].mapping);
1296 		de->rx_ring[i].addr2 = 0;
1297 	}
1298 
1299 	return 0;
1300 
1301 err_out:
1302 	de_clean_rings(de);
1303 	return -ENOMEM;
1304 }
1305 
1306 static int de_init_rings (struct de_private *de)
1307 {
1308 	memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1309 	de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1310 
1311 	de->rx_tail = 0;
1312 	de->tx_head = de->tx_tail = 0;
1313 
1314 	return de_refill_rx (de);
1315 }
1316 
1317 static int de_alloc_rings (struct de_private *de)
1318 {
1319 	de->rx_ring = pci_alloc_consistent(de->pdev, DE_RING_BYTES, &de->ring_dma);
1320 	if (!de->rx_ring)
1321 		return -ENOMEM;
1322 	de->tx_ring = &de->rx_ring[DE_RX_RING_SIZE];
1323 	return de_init_rings(de);
1324 }
1325 
1326 static void de_clean_rings (struct de_private *de)
1327 {
1328 	unsigned i;
1329 
1330 	memset(de->rx_ring, 0, sizeof(struct de_desc) * DE_RX_RING_SIZE);
1331 	de->rx_ring[DE_RX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1332 	wmb();
1333 	memset(de->tx_ring, 0, sizeof(struct de_desc) * DE_TX_RING_SIZE);
1334 	de->tx_ring[DE_TX_RING_SIZE - 1].opts2 = cpu_to_le32(RingEnd);
1335 	wmb();
1336 
1337 	for (i = 0; i < DE_RX_RING_SIZE; i++) {
1338 		if (de->rx_skb[i].skb) {
1339 			pci_unmap_single(de->pdev, de->rx_skb[i].mapping,
1340 					 de->rx_buf_sz, PCI_DMA_FROMDEVICE);
1341 			dev_kfree_skb(de->rx_skb[i].skb);
1342 		}
1343 	}
1344 
1345 	for (i = 0; i < DE_TX_RING_SIZE; i++) {
1346 		struct sk_buff *skb = de->tx_skb[i].skb;
1347 		if ((skb) && (skb != DE_DUMMY_SKB)) {
1348 			if (skb != DE_SETUP_SKB) {
1349 				de->dev->stats.tx_dropped++;
1350 				pci_unmap_single(de->pdev,
1351 					de->tx_skb[i].mapping,
1352 					skb->len, PCI_DMA_TODEVICE);
1353 				dev_kfree_skb(skb);
1354 			} else {
1355 				pci_unmap_single(de->pdev,
1356 					de->tx_skb[i].mapping,
1357 					sizeof(de->setup_frame),
1358 					PCI_DMA_TODEVICE);
1359 			}
1360 		}
1361 	}
1362 
1363 	memset(&de->rx_skb, 0, sizeof(struct ring_info) * DE_RX_RING_SIZE);
1364 	memset(&de->tx_skb, 0, sizeof(struct ring_info) * DE_TX_RING_SIZE);
1365 }
1366 
1367 static void de_free_rings (struct de_private *de)
1368 {
1369 	de_clean_rings(de);
1370 	pci_free_consistent(de->pdev, DE_RING_BYTES, de->rx_ring, de->ring_dma);
1371 	de->rx_ring = NULL;
1372 	de->tx_ring = NULL;
1373 }
1374 
1375 static int de_open (struct net_device *dev)
1376 {
1377 	struct de_private *de = netdev_priv(dev);
1378 	const int irq = de->pdev->irq;
1379 	int rc;
1380 
1381 	netif_dbg(de, ifup, dev, "enabling interface\n");
1382 
1383 	de->rx_buf_sz = (dev->mtu <= 1500 ? PKT_BUF_SZ : dev->mtu + 32);
1384 
1385 	rc = de_alloc_rings(de);
1386 	if (rc) {
1387 		netdev_err(dev, "ring allocation failure, err=%d\n", rc);
1388 		return rc;
1389 	}
1390 
1391 	dw32(IntrMask, 0);
1392 
1393 	rc = request_irq(irq, de_interrupt, IRQF_SHARED, dev->name, dev);
1394 	if (rc) {
1395 		netdev_err(dev, "IRQ %d request failure, err=%d\n", irq, rc);
1396 		goto err_out_free;
1397 	}
1398 
1399 	rc = de_init_hw(de);
1400 	if (rc) {
1401 		netdev_err(dev, "h/w init failure, err=%d\n", rc);
1402 		goto err_out_free_irq;
1403 	}
1404 
1405 	netif_start_queue(dev);
1406 	mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1407 
1408 	return 0;
1409 
1410 err_out_free_irq:
1411 	free_irq(irq, dev);
1412 err_out_free:
1413 	de_free_rings(de);
1414 	return rc;
1415 }
1416 
1417 static int de_close (struct net_device *dev)
1418 {
1419 	struct de_private *de = netdev_priv(dev);
1420 	unsigned long flags;
1421 
1422 	netif_dbg(de, ifdown, dev, "disabling interface\n");
1423 
1424 	del_timer_sync(&de->media_timer);
1425 
1426 	spin_lock_irqsave(&de->lock, flags);
1427 	de_stop_hw(de);
1428 	netif_stop_queue(dev);
1429 	netif_carrier_off(dev);
1430 	spin_unlock_irqrestore(&de->lock, flags);
1431 
1432 	free_irq(de->pdev->irq, dev);
1433 
1434 	de_free_rings(de);
1435 	de_adapter_sleep(de);
1436 	return 0;
1437 }
1438 
1439 static void de_tx_timeout (struct net_device *dev)
1440 {
1441 	struct de_private *de = netdev_priv(dev);
1442 	const int irq = de->pdev->irq;
1443 
1444 	netdev_dbg(dev, "NIC status %08x mode %08x sia %08x desc %u/%u/%u\n",
1445 		   dr32(MacStatus), dr32(MacMode), dr32(SIAStatus),
1446 		   de->rx_tail, de->tx_head, de->tx_tail);
1447 
1448 	del_timer_sync(&de->media_timer);
1449 
1450 	disable_irq(irq);
1451 	spin_lock_irq(&de->lock);
1452 
1453 	de_stop_hw(de);
1454 	netif_stop_queue(dev);
1455 	netif_carrier_off(dev);
1456 
1457 	spin_unlock_irq(&de->lock);
1458 	enable_irq(irq);
1459 
1460 	/* Update the error counts. */
1461 	__de_get_stats(de);
1462 
1463 	synchronize_irq(irq);
1464 	de_clean_rings(de);
1465 
1466 	de_init_rings(de);
1467 
1468 	de_init_hw(de);
1469 
1470 	netif_wake_queue(dev);
1471 }
1472 
1473 static void __de_get_regs(struct de_private *de, u8 *buf)
1474 {
1475 	int i;
1476 	u32 *rbuf = (u32 *)buf;
1477 
1478 	/* read all CSRs */
1479 	for (i = 0; i < DE_NUM_REGS; i++)
1480 		rbuf[i] = dr32(i * 8);
1481 
1482 	/* handle self-clearing RxMissed counter, CSR8 */
1483 	de_rx_missed(de, rbuf[8]);
1484 }
1485 
1486 static void __de_get_link_ksettings(struct de_private *de,
1487 				    struct ethtool_link_ksettings *cmd)
1488 {
1489 	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.supported,
1490 						de->media_supported);
1491 	cmd->base.phy_address = 0;
1492 	ethtool_convert_legacy_u32_to_link_mode(cmd->link_modes.advertising,
1493 						de->media_advertise);
1494 
1495 	switch (de->media_type) {
1496 	case DE_MEDIA_AUI:
1497 		cmd->base.port = PORT_AUI;
1498 		break;
1499 	case DE_MEDIA_BNC:
1500 		cmd->base.port = PORT_BNC;
1501 		break;
1502 	default:
1503 		cmd->base.port = PORT_TP;
1504 		break;
1505 	}
1506 
1507 	cmd->base.speed = 10;
1508 
1509 	if (dr32(MacMode) & FullDuplex)
1510 		cmd->base.duplex = DUPLEX_FULL;
1511 	else
1512 		cmd->base.duplex = DUPLEX_HALF;
1513 
1514 	if (de->media_lock)
1515 		cmd->base.autoneg = AUTONEG_DISABLE;
1516 	else
1517 		cmd->base.autoneg = AUTONEG_ENABLE;
1518 
1519 	/* ignore maxtxpkt, maxrxpkt for now */
1520 }
1521 
1522 static int __de_set_link_ksettings(struct de_private *de,
1523 				   const struct ethtool_link_ksettings *cmd)
1524 {
1525 	u32 new_media;
1526 	unsigned int media_lock;
1527 	u8 duplex = cmd->base.duplex;
1528 	u8 port = cmd->base.port;
1529 	u8 autoneg = cmd->base.autoneg;
1530 	u32 advertising;
1531 
1532 	ethtool_convert_link_mode_to_legacy_u32(&advertising,
1533 						cmd->link_modes.advertising);
1534 
1535 	if (cmd->base.speed != 10)
1536 		return -EINVAL;
1537 	if (duplex != DUPLEX_HALF && duplex != DUPLEX_FULL)
1538 		return -EINVAL;
1539 	if (port != PORT_TP && port != PORT_AUI && port != PORT_BNC)
1540 		return -EINVAL;
1541 	if (de->de21040 && port == PORT_BNC)
1542 		return -EINVAL;
1543 	if (autoneg != AUTONEG_DISABLE && autoneg != AUTONEG_ENABLE)
1544 		return -EINVAL;
1545 	if (advertising & ~de->media_supported)
1546 		return -EINVAL;
1547 	if (autoneg == AUTONEG_ENABLE &&
1548 	    (!(advertising & ADVERTISED_Autoneg)))
1549 		return -EINVAL;
1550 
1551 	switch (port) {
1552 	case PORT_AUI:
1553 		new_media = DE_MEDIA_AUI;
1554 		if (!(advertising & ADVERTISED_AUI))
1555 			return -EINVAL;
1556 		break;
1557 	case PORT_BNC:
1558 		new_media = DE_MEDIA_BNC;
1559 		if (!(advertising & ADVERTISED_BNC))
1560 			return -EINVAL;
1561 		break;
1562 	default:
1563 		if (autoneg == AUTONEG_ENABLE)
1564 			new_media = DE_MEDIA_TP_AUTO;
1565 		else if (duplex == DUPLEX_FULL)
1566 			new_media = DE_MEDIA_TP_FD;
1567 		else
1568 			new_media = DE_MEDIA_TP;
1569 		if (!(advertising & ADVERTISED_TP))
1570 			return -EINVAL;
1571 		if (!(advertising & (ADVERTISED_10baseT_Full |
1572 				     ADVERTISED_10baseT_Half)))
1573 			return -EINVAL;
1574 		break;
1575 	}
1576 
1577 	media_lock = (autoneg == AUTONEG_ENABLE) ? 0 : 1;
1578 
1579 	if ((new_media == de->media_type) &&
1580 	    (media_lock == de->media_lock) &&
1581 	    (advertising == de->media_advertise))
1582 		return 0; /* nothing to change */
1583 
1584 	de_link_down(de);
1585 	mod_timer(&de->media_timer, jiffies + DE_TIMER_NO_LINK);
1586 	de_stop_rxtx(de);
1587 
1588 	de->media_type = new_media;
1589 	de->media_lock = media_lock;
1590 	de->media_advertise = advertising;
1591 	de_set_media(de);
1592 	if (netif_running(de->dev))
1593 		de_start_rxtx(de);
1594 
1595 	return 0;
1596 }
1597 
1598 static void de_get_drvinfo (struct net_device *dev,struct ethtool_drvinfo *info)
1599 {
1600 	struct de_private *de = netdev_priv(dev);
1601 
1602 	strlcpy(info->driver, DRV_NAME, sizeof(info->driver));
1603 	strlcpy(info->version, DRV_VERSION, sizeof(info->version));
1604 	strlcpy(info->bus_info, pci_name(de->pdev), sizeof(info->bus_info));
1605 }
1606 
1607 static int de_get_regs_len(struct net_device *dev)
1608 {
1609 	return DE_REGS_SIZE;
1610 }
1611 
1612 static int de_get_link_ksettings(struct net_device *dev,
1613 				 struct ethtool_link_ksettings *cmd)
1614 {
1615 	struct de_private *de = netdev_priv(dev);
1616 
1617 	spin_lock_irq(&de->lock);
1618 	__de_get_link_ksettings(de, cmd);
1619 	spin_unlock_irq(&de->lock);
1620 
1621 	return 0;
1622 }
1623 
1624 static int de_set_link_ksettings(struct net_device *dev,
1625 				 const struct ethtool_link_ksettings *cmd)
1626 {
1627 	struct de_private *de = netdev_priv(dev);
1628 	int rc;
1629 
1630 	spin_lock_irq(&de->lock);
1631 	rc = __de_set_link_ksettings(de, cmd);
1632 	spin_unlock_irq(&de->lock);
1633 
1634 	return rc;
1635 }
1636 
1637 static u32 de_get_msglevel(struct net_device *dev)
1638 {
1639 	struct de_private *de = netdev_priv(dev);
1640 
1641 	return de->msg_enable;
1642 }
1643 
1644 static void de_set_msglevel(struct net_device *dev, u32 msglvl)
1645 {
1646 	struct de_private *de = netdev_priv(dev);
1647 
1648 	de->msg_enable = msglvl;
1649 }
1650 
1651 static int de_get_eeprom(struct net_device *dev,
1652 			 struct ethtool_eeprom *eeprom, u8 *data)
1653 {
1654 	struct de_private *de = netdev_priv(dev);
1655 
1656 	if (!de->ee_data)
1657 		return -EOPNOTSUPP;
1658 	if ((eeprom->offset != 0) || (eeprom->magic != 0) ||
1659 	    (eeprom->len != DE_EEPROM_SIZE))
1660 		return -EINVAL;
1661 	memcpy(data, de->ee_data, eeprom->len);
1662 
1663 	return 0;
1664 }
1665 
1666 static int de_nway_reset(struct net_device *dev)
1667 {
1668 	struct de_private *de = netdev_priv(dev);
1669 	u32 status;
1670 
1671 	if (de->media_type != DE_MEDIA_TP_AUTO)
1672 		return -EINVAL;
1673 	if (netif_carrier_ok(de->dev))
1674 		de_link_down(de);
1675 
1676 	status = dr32(SIAStatus);
1677 	dw32(SIAStatus, (status & ~NWayState) | NWayRestart);
1678 	netif_info(de, link, dev, "link nway restart, status %x,%x\n",
1679 		   status, dr32(SIAStatus));
1680 	return 0;
1681 }
1682 
1683 static void de_get_regs(struct net_device *dev, struct ethtool_regs *regs,
1684 			void *data)
1685 {
1686 	struct de_private *de = netdev_priv(dev);
1687 
1688 	regs->version = (DE_REGS_VER << 2) | de->de21040;
1689 
1690 	spin_lock_irq(&de->lock);
1691 	__de_get_regs(de, data);
1692 	spin_unlock_irq(&de->lock);
1693 }
1694 
1695 static const struct ethtool_ops de_ethtool_ops = {
1696 	.get_link		= ethtool_op_get_link,
1697 	.get_drvinfo		= de_get_drvinfo,
1698 	.get_regs_len		= de_get_regs_len,
1699 	.get_msglevel		= de_get_msglevel,
1700 	.set_msglevel		= de_set_msglevel,
1701 	.get_eeprom		= de_get_eeprom,
1702 	.nway_reset		= de_nway_reset,
1703 	.get_regs		= de_get_regs,
1704 	.get_link_ksettings	= de_get_link_ksettings,
1705 	.set_link_ksettings	= de_set_link_ksettings,
1706 };
1707 
1708 static void de21040_get_mac_address(struct de_private *de)
1709 {
1710 	unsigned i;
1711 
1712 	dw32 (ROMCmd, 0);	/* Reset the pointer with a dummy write. */
1713 	udelay(5);
1714 
1715 	for (i = 0; i < 6; i++) {
1716 		int value, boguscnt = 100000;
1717 		do {
1718 			value = dr32(ROMCmd);
1719 			rmb();
1720 		} while (value < 0 && --boguscnt > 0);
1721 		de->dev->dev_addr[i] = value;
1722 		udelay(1);
1723 		if (boguscnt <= 0)
1724 			pr_warn("timeout reading 21040 MAC address byte %u\n",
1725 				i);
1726 	}
1727 }
1728 
1729 static void de21040_get_media_info(struct de_private *de)
1730 {
1731 	unsigned int i;
1732 
1733 	de->media_type = DE_MEDIA_TP;
1734 	de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full |
1735 			       SUPPORTED_10baseT_Half | SUPPORTED_AUI;
1736 	de->media_advertise = de->media_supported;
1737 
1738 	for (i = 0; i < DE_MAX_MEDIA; i++) {
1739 		switch (i) {
1740 		case DE_MEDIA_AUI:
1741 		case DE_MEDIA_TP:
1742 		case DE_MEDIA_TP_FD:
1743 			de->media[i].type = i;
1744 			de->media[i].csr13 = t21040_csr13[i];
1745 			de->media[i].csr14 = t21040_csr14[i];
1746 			de->media[i].csr15 = t21040_csr15[i];
1747 			break;
1748 		default:
1749 			de->media[i].type = DE_MEDIA_INVALID;
1750 			break;
1751 		}
1752 	}
1753 }
1754 
1755 /* Note: this routine returns extra data bits for size detection. */
1756 static unsigned tulip_read_eeprom(void __iomem *regs, int location,
1757 				  int addr_len)
1758 {
1759 	int i;
1760 	unsigned retval = 0;
1761 	void __iomem *ee_addr = regs + ROMCmd;
1762 	int read_cmd = location | (EE_READ_CMD << addr_len);
1763 
1764 	writel(EE_ENB & ~EE_CS, ee_addr);
1765 	writel(EE_ENB, ee_addr);
1766 
1767 	/* Shift the read command bits out. */
1768 	for (i = 4 + addr_len; i >= 0; i--) {
1769 		short dataval = (read_cmd & (1 << i)) ? EE_DATA_WRITE : 0;
1770 		writel(EE_ENB | dataval, ee_addr);
1771 		readl(ee_addr);
1772 		writel(EE_ENB | dataval | EE_SHIFT_CLK, ee_addr);
1773 		readl(ee_addr);
1774 		retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1775 	}
1776 	writel(EE_ENB, ee_addr);
1777 	readl(ee_addr);
1778 
1779 	for (i = 16; i > 0; i--) {
1780 		writel(EE_ENB | EE_SHIFT_CLK, ee_addr);
1781 		readl(ee_addr);
1782 		retval = (retval << 1) | ((readl(ee_addr) & EE_DATA_READ) ? 1 : 0);
1783 		writel(EE_ENB, ee_addr);
1784 		readl(ee_addr);
1785 	}
1786 
1787 	/* Terminate the EEPROM access. */
1788 	writel(EE_ENB & ~EE_CS, ee_addr);
1789 	return retval;
1790 }
1791 
1792 static void de21041_get_srom_info(struct de_private *de)
1793 {
1794 	unsigned i, sa_offset = 0, ofs;
1795 	u8 ee_data[DE_EEPROM_SIZE + 6] = {};
1796 	unsigned ee_addr_size = tulip_read_eeprom(de->regs, 0xff, 8) & 0x40000 ? 8 : 6;
1797 	struct de_srom_info_leaf *il;
1798 	void *bufp;
1799 
1800 	/* download entire eeprom */
1801 	for (i = 0; i < DE_EEPROM_WORDS; i++)
1802 		((__le16 *)ee_data)[i] =
1803 			cpu_to_le16(tulip_read_eeprom(de->regs, i, ee_addr_size));
1804 
1805 	/* DEC now has a specification but early board makers
1806 	   just put the address in the first EEPROM locations. */
1807 	/* This does  memcmp(eedata, eedata+16, 8) */
1808 
1809 #ifndef CONFIG_MIPS_COBALT
1810 
1811 	for (i = 0; i < 8; i ++)
1812 		if (ee_data[i] != ee_data[16+i])
1813 			sa_offset = 20;
1814 
1815 #endif
1816 
1817 	/* store MAC address */
1818 	for (i = 0; i < 6; i ++)
1819 		de->dev->dev_addr[i] = ee_data[i + sa_offset];
1820 
1821 	/* get offset of controller 0 info leaf.  ignore 2nd byte. */
1822 	ofs = ee_data[SROMC0InfoLeaf];
1823 	if (ofs >= (sizeof(ee_data) - sizeof(struct de_srom_info_leaf) - sizeof(struct de_srom_media_block)))
1824 		goto bad_srom;
1825 
1826 	/* get pointer to info leaf */
1827 	il = (struct de_srom_info_leaf *) &ee_data[ofs];
1828 
1829 	/* paranoia checks */
1830 	if (il->n_blocks == 0)
1831 		goto bad_srom;
1832 	if ((sizeof(ee_data) - ofs) <
1833 	    (sizeof(struct de_srom_info_leaf) + (sizeof(struct de_srom_media_block) * il->n_blocks)))
1834 		goto bad_srom;
1835 
1836 	/* get default media type */
1837 	switch (get_unaligned(&il->default_media)) {
1838 	case 0x0001:  de->media_type = DE_MEDIA_BNC; break;
1839 	case 0x0002:  de->media_type = DE_MEDIA_AUI; break;
1840 	case 0x0204:  de->media_type = DE_MEDIA_TP_FD; break;
1841 	default: de->media_type = DE_MEDIA_TP_AUTO; break;
1842 	}
1843 
1844 	if (netif_msg_probe(de))
1845 		pr_info("de%d: SROM leaf offset %u, default media %s\n",
1846 		       de->board_idx, ofs, media_name[de->media_type]);
1847 
1848 	/* init SIA register values to defaults */
1849 	for (i = 0; i < DE_MAX_MEDIA; i++) {
1850 		de->media[i].type = DE_MEDIA_INVALID;
1851 		de->media[i].csr13 = 0xffff;
1852 		de->media[i].csr14 = 0xffff;
1853 		de->media[i].csr15 = 0xffff;
1854 	}
1855 
1856 	/* parse media blocks to see what medias are supported,
1857 	 * and if any custom CSR values are provided
1858 	 */
1859 	bufp = ((void *)il) + sizeof(*il);
1860 	for (i = 0; i < il->n_blocks; i++) {
1861 		struct de_srom_media_block *ib = bufp;
1862 		unsigned idx;
1863 
1864 		/* index based on media type in media block */
1865 		switch(ib->opts & MediaBlockMask) {
1866 		case 0: /* 10baseT */
1867 			de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Half
1868 					  | SUPPORTED_Autoneg;
1869 			idx = DE_MEDIA_TP;
1870 			de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1871 			break;
1872 		case 1: /* BNC */
1873 			de->media_supported |= SUPPORTED_BNC;
1874 			idx = DE_MEDIA_BNC;
1875 			break;
1876 		case 2: /* AUI */
1877 			de->media_supported |= SUPPORTED_AUI;
1878 			idx = DE_MEDIA_AUI;
1879 			break;
1880 		case 4: /* 10baseT-FD */
1881 			de->media_supported |= SUPPORTED_TP | SUPPORTED_10baseT_Full
1882 					  | SUPPORTED_Autoneg;
1883 			idx = DE_MEDIA_TP_FD;
1884 			de->media[DE_MEDIA_TP_AUTO].type = DE_MEDIA_TP_AUTO;
1885 			break;
1886 		default:
1887 			goto bad_srom;
1888 		}
1889 
1890 		de->media[idx].type = idx;
1891 
1892 		if (netif_msg_probe(de))
1893 			pr_info("de%d:   media block #%u: %s",
1894 				de->board_idx, i,
1895 				media_name[de->media[idx].type]);
1896 
1897 		bufp += sizeof (ib->opts);
1898 
1899 		if (ib->opts & MediaCustomCSRs) {
1900 			de->media[idx].csr13 = get_unaligned(&ib->csr13);
1901 			de->media[idx].csr14 = get_unaligned(&ib->csr14);
1902 			de->media[idx].csr15 = get_unaligned(&ib->csr15);
1903 			bufp += sizeof(ib->csr13) + sizeof(ib->csr14) +
1904 				sizeof(ib->csr15);
1905 
1906 			if (netif_msg_probe(de))
1907 				pr_cont(" (%x,%x,%x)\n",
1908 					de->media[idx].csr13,
1909 					de->media[idx].csr14,
1910 					de->media[idx].csr15);
1911 
1912 		} else {
1913 			if (netif_msg_probe(de))
1914 				pr_cont("\n");
1915 		}
1916 
1917 		if (bufp > ((void *)&ee_data[DE_EEPROM_SIZE - 3]))
1918 			break;
1919 	}
1920 
1921 	de->media_advertise = de->media_supported;
1922 
1923 fill_defaults:
1924 	/* fill in defaults, for cases where custom CSRs not used */
1925 	for (i = 0; i < DE_MAX_MEDIA; i++) {
1926 		if (de->media[i].csr13 == 0xffff)
1927 			de->media[i].csr13 = t21041_csr13[i];
1928 		if (de->media[i].csr14 == 0xffff) {
1929 			/* autonegotiation is broken at least on some chip
1930 			   revisions - rev. 0x21 works, 0x11 does not */
1931 			if (de->pdev->revision < 0x20)
1932 				de->media[i].csr14 = t21041_csr14_brk[i];
1933 			else
1934 				de->media[i].csr14 = t21041_csr14[i];
1935 		}
1936 		if (de->media[i].csr15 == 0xffff)
1937 			de->media[i].csr15 = t21041_csr15[i];
1938 	}
1939 
1940 	de->ee_data = kmemdup(&ee_data[0], DE_EEPROM_SIZE, GFP_KERNEL);
1941 
1942 	return;
1943 
1944 bad_srom:
1945 	/* for error cases, it's ok to assume we support all these */
1946 	for (i = 0; i < DE_MAX_MEDIA; i++)
1947 		de->media[i].type = i;
1948 	de->media_supported =
1949 		SUPPORTED_10baseT_Half |
1950 		SUPPORTED_10baseT_Full |
1951 		SUPPORTED_Autoneg |
1952 		SUPPORTED_TP |
1953 		SUPPORTED_AUI |
1954 		SUPPORTED_BNC;
1955 	goto fill_defaults;
1956 }
1957 
1958 static const struct net_device_ops de_netdev_ops = {
1959 	.ndo_open		= de_open,
1960 	.ndo_stop		= de_close,
1961 	.ndo_set_rx_mode	= de_set_rx_mode,
1962 	.ndo_start_xmit		= de_start_xmit,
1963 	.ndo_get_stats		= de_get_stats,
1964 	.ndo_tx_timeout 	= de_tx_timeout,
1965 	.ndo_set_mac_address 	= eth_mac_addr,
1966 	.ndo_validate_addr	= eth_validate_addr,
1967 };
1968 
1969 static int de_init_one(struct pci_dev *pdev, const struct pci_device_id *ent)
1970 {
1971 	struct net_device *dev;
1972 	struct de_private *de;
1973 	int rc;
1974 	void __iomem *regs;
1975 	unsigned long pciaddr;
1976 	static int board_idx = -1;
1977 
1978 	board_idx++;
1979 
1980 #ifndef MODULE
1981 	if (board_idx == 0)
1982 		pr_info("%s\n", version);
1983 #endif
1984 
1985 	/* allocate a new ethernet device structure, and fill in defaults */
1986 	dev = alloc_etherdev(sizeof(struct de_private));
1987 	if (!dev)
1988 		return -ENOMEM;
1989 
1990 	dev->netdev_ops = &de_netdev_ops;
1991 	SET_NETDEV_DEV(dev, &pdev->dev);
1992 	dev->ethtool_ops = &de_ethtool_ops;
1993 	dev->watchdog_timeo = TX_TIMEOUT;
1994 
1995 	de = netdev_priv(dev);
1996 	de->de21040 = ent->driver_data == 0 ? 1 : 0;
1997 	de->pdev = pdev;
1998 	de->dev = dev;
1999 	de->msg_enable = (debug < 0 ? DE_DEF_MSG_ENABLE : debug);
2000 	de->board_idx = board_idx;
2001 	spin_lock_init (&de->lock);
2002 	timer_setup(&de->media_timer,
2003 		    de->de21040 ? de21040_media_timer : de21041_media_timer,
2004 		    0);
2005 
2006 	netif_carrier_off(dev);
2007 
2008 	/* wake up device, assign resources */
2009 	rc = pci_enable_device(pdev);
2010 	if (rc)
2011 		goto err_out_free;
2012 
2013 	/* reserve PCI resources to ensure driver atomicity */
2014 	rc = pci_request_regions(pdev, DRV_NAME);
2015 	if (rc)
2016 		goto err_out_disable;
2017 
2018 	/* check for invalid IRQ value */
2019 	if (pdev->irq < 2) {
2020 		rc = -EIO;
2021 		pr_err("invalid irq (%d) for pci dev %s\n",
2022 		       pdev->irq, pci_name(pdev));
2023 		goto err_out_res;
2024 	}
2025 
2026 	/* obtain and check validity of PCI I/O address */
2027 	pciaddr = pci_resource_start(pdev, 1);
2028 	if (!pciaddr) {
2029 		rc = -EIO;
2030 		pr_err("no MMIO resource for pci dev %s\n", pci_name(pdev));
2031 		goto err_out_res;
2032 	}
2033 	if (pci_resource_len(pdev, 1) < DE_REGS_SIZE) {
2034 		rc = -EIO;
2035 		pr_err("MMIO resource (%llx) too small on pci dev %s\n",
2036 		       (unsigned long long)pci_resource_len(pdev, 1),
2037 		       pci_name(pdev));
2038 		goto err_out_res;
2039 	}
2040 
2041 	/* remap CSR registers */
2042 	regs = ioremap_nocache(pciaddr, DE_REGS_SIZE);
2043 	if (!regs) {
2044 		rc = -EIO;
2045 		pr_err("Cannot map PCI MMIO (%llx@%lx) on pci dev %s\n",
2046 		       (unsigned long long)pci_resource_len(pdev, 1),
2047 		       pciaddr, pci_name(pdev));
2048 		goto err_out_res;
2049 	}
2050 	de->regs = regs;
2051 
2052 	de_adapter_wake(de);
2053 
2054 	/* make sure hardware is not running */
2055 	rc = de_reset_mac(de);
2056 	if (rc) {
2057 		pr_err("Cannot reset MAC, pci dev %s\n", pci_name(pdev));
2058 		goto err_out_iomap;
2059 	}
2060 
2061 	/* get MAC address, initialize default media type and
2062 	 * get list of supported media
2063 	 */
2064 	if (de->de21040) {
2065 		de21040_get_mac_address(de);
2066 		de21040_get_media_info(de);
2067 	} else {
2068 		de21041_get_srom_info(de);
2069 	}
2070 
2071 	/* register new network interface with kernel */
2072 	rc = register_netdev(dev);
2073 	if (rc)
2074 		goto err_out_iomap;
2075 
2076 	/* print info about board and interface just registered */
2077 	netdev_info(dev, "%s at %p, %pM, IRQ %d\n",
2078 		    de->de21040 ? "21040" : "21041",
2079 		    regs, dev->dev_addr, pdev->irq);
2080 
2081 	pci_set_drvdata(pdev, dev);
2082 
2083 	/* enable busmastering */
2084 	pci_set_master(pdev);
2085 
2086 	/* put adapter to sleep */
2087 	de_adapter_sleep(de);
2088 
2089 	return 0;
2090 
2091 err_out_iomap:
2092 	kfree(de->ee_data);
2093 	iounmap(regs);
2094 err_out_res:
2095 	pci_release_regions(pdev);
2096 err_out_disable:
2097 	pci_disable_device(pdev);
2098 err_out_free:
2099 	free_netdev(dev);
2100 	return rc;
2101 }
2102 
2103 static void de_remove_one(struct pci_dev *pdev)
2104 {
2105 	struct net_device *dev = pci_get_drvdata(pdev);
2106 	struct de_private *de = netdev_priv(dev);
2107 
2108 	BUG_ON(!dev);
2109 	unregister_netdev(dev);
2110 	kfree(de->ee_data);
2111 	iounmap(de->regs);
2112 	pci_release_regions(pdev);
2113 	pci_disable_device(pdev);
2114 	free_netdev(dev);
2115 }
2116 
2117 #ifdef CONFIG_PM
2118 
2119 static int de_suspend (struct pci_dev *pdev, pm_message_t state)
2120 {
2121 	struct net_device *dev = pci_get_drvdata (pdev);
2122 	struct de_private *de = netdev_priv(dev);
2123 
2124 	rtnl_lock();
2125 	if (netif_running (dev)) {
2126 		const int irq = pdev->irq;
2127 
2128 		del_timer_sync(&de->media_timer);
2129 
2130 		disable_irq(irq);
2131 		spin_lock_irq(&de->lock);
2132 
2133 		de_stop_hw(de);
2134 		netif_stop_queue(dev);
2135 		netif_device_detach(dev);
2136 		netif_carrier_off(dev);
2137 
2138 		spin_unlock_irq(&de->lock);
2139 		enable_irq(irq);
2140 
2141 		/* Update the error counts. */
2142 		__de_get_stats(de);
2143 
2144 		synchronize_irq(irq);
2145 		de_clean_rings(de);
2146 
2147 		de_adapter_sleep(de);
2148 		pci_disable_device(pdev);
2149 	} else {
2150 		netif_device_detach(dev);
2151 	}
2152 	rtnl_unlock();
2153 	return 0;
2154 }
2155 
2156 static int de_resume (struct pci_dev *pdev)
2157 {
2158 	struct net_device *dev = pci_get_drvdata (pdev);
2159 	struct de_private *de = netdev_priv(dev);
2160 	int retval = 0;
2161 
2162 	rtnl_lock();
2163 	if (netif_device_present(dev))
2164 		goto out;
2165 	if (!netif_running(dev))
2166 		goto out_attach;
2167 	if ((retval = pci_enable_device(pdev))) {
2168 		netdev_err(dev, "pci_enable_device failed in resume\n");
2169 		goto out;
2170 	}
2171 	pci_set_master(pdev);
2172 	de_init_rings(de);
2173 	de_init_hw(de);
2174 out_attach:
2175 	netif_device_attach(dev);
2176 out:
2177 	rtnl_unlock();
2178 	return 0;
2179 }
2180 
2181 #endif /* CONFIG_PM */
2182 
2183 static struct pci_driver de_driver = {
2184 	.name		= DRV_NAME,
2185 	.id_table	= de_pci_tbl,
2186 	.probe		= de_init_one,
2187 	.remove		= de_remove_one,
2188 #ifdef CONFIG_PM
2189 	.suspend	= de_suspend,
2190 	.resume		= de_resume,
2191 #endif
2192 };
2193 
2194 static int __init de_init (void)
2195 {
2196 #ifdef MODULE
2197 	pr_info("%s\n", version);
2198 #endif
2199 	return pci_register_driver(&de_driver);
2200 }
2201 
2202 static void __exit de_exit (void)
2203 {
2204 	pci_unregister_driver (&de_driver);
2205 }
2206 
2207 module_init(de_init);
2208 module_exit(de_exit);
2209