1 /* sundance.c: A Linux device driver for the Sundance ST201 "Alta". */
2 /*
3 	Written 1999-2000 by Donald Becker.
4 
5 	This software may be used and distributed according to the terms of
6 	the GNU General Public License (GPL), incorporated herein by reference.
7 	Drivers based on or derived from this code fall under the GPL and must
8 	retain the authorship, copyright and license notice.  This file is not
9 	a complete program and may only be used when the entire operating
10 	system is licensed under the GPL.
11 
12 	The author may be reached as becker@scyld.com, or C/O
13 	Scyld Computing Corporation
14 	410 Severn Ave., Suite 210
15 	Annapolis MD 21403
16 
17 	Support and updates available at
18 	http://www.scyld.com/network/sundance.html
19 	[link no longer provides useful info -jgarzik]
20 	Archives of the mailing list are still available at
21 	https://www.beowulf.org/pipermail/netdrivers/
22 
23 */
24 
25 #define DRV_NAME	"sundance"
26 
27 /* The user-configurable values.
28    These may be modified when a driver module is loaded.*/
29 static int debug = 1;			/* 1 normal messages, 0 quiet .. 7 verbose. */
30 /* Maximum number of multicast addresses to filter (vs. rx-all-multicast).
31    Typical is a 64 element hash table based on the Ethernet CRC.  */
32 static const int multicast_filter_limit = 32;
33 
34 /* Set the copy breakpoint for the copy-only-tiny-frames scheme.
35    Setting to > 1518 effectively disables this feature.
36    This chip can receive into offset buffers, so the Alpha does not
37    need a copy-align. */
38 static int rx_copybreak;
39 static int flowctrl=1;
40 
41 /* media[] specifies the media type the NIC operates at.
42 		 autosense	Autosensing active media.
43 		 10mbps_hd 	10Mbps half duplex.
44 		 10mbps_fd 	10Mbps full duplex.
45 		 100mbps_hd 	100Mbps half duplex.
46 		 100mbps_fd 	100Mbps full duplex.
47 		 0		Autosensing active media.
48 		 1	 	10Mbps half duplex.
49 		 2	 	10Mbps full duplex.
50 		 3	 	100Mbps half duplex.
51 		 4	 	100Mbps full duplex.
52 */
53 #define MAX_UNITS 8
54 static char *media[MAX_UNITS];
55 
56 
57 /* Operational parameters that are set at compile time. */
58 
59 /* Keep the ring sizes a power of two for compile efficiency.
60    The compiler will convert <unsigned>'%'<2^N> into a bit mask.
61    Making the Tx ring too large decreases the effectiveness of channel
62    bonding and packet priority, and more than 128 requires modifying the
63    Tx error recovery.
64    Large receive rings merely waste memory. */
65 #define TX_RING_SIZE	32
66 #define TX_QUEUE_LEN	(TX_RING_SIZE - 1) /* Limit ring entries actually used.  */
67 #define RX_RING_SIZE	64
68 #define RX_BUDGET	32
69 #define TX_TOTAL_SIZE	TX_RING_SIZE*sizeof(struct netdev_desc)
70 #define RX_TOTAL_SIZE	RX_RING_SIZE*sizeof(struct netdev_desc)
71 
72 /* Operational parameters that usually are not changed. */
73 /* Time in jiffies before concluding the transmitter is hung. */
74 #define TX_TIMEOUT  (4*HZ)
75 #define PKT_BUF_SZ		1536	/* Size of each temporary Rx buffer.*/
76 
77 /* Include files, designed to support most kernel versions 2.0.0 and later. */
78 #include <linux/module.h>
79 #include <linux/kernel.h>
80 #include <linux/string.h>
81 #include <linux/timer.h>
82 #include <linux/errno.h>
83 #include <linux/ioport.h>
84 #include <linux/interrupt.h>
85 #include <linux/pci.h>
86 #include <linux/netdevice.h>
87 #include <linux/etherdevice.h>
88 #include <linux/skbuff.h>
89 #include <linux/init.h>
90 #include <linux/bitops.h>
91 #include <linux/uaccess.h>
92 #include <asm/processor.h>		/* Processor type for cache alignment. */
93 #include <asm/io.h>
94 #include <linux/delay.h>
95 #include <linux/spinlock.h>
96 #include <linux/dma-mapping.h>
97 #include <linux/crc32.h>
98 #include <linux/ethtool.h>
99 #include <linux/mii.h>
100 
101 MODULE_AUTHOR("Donald Becker <becker@scyld.com>");
102 MODULE_DESCRIPTION("Sundance Alta Ethernet driver");
103 MODULE_LICENSE("GPL");
104 
105 module_param(debug, int, 0);
106 module_param(rx_copybreak, int, 0);
107 module_param_array(media, charp, NULL, 0);
108 module_param(flowctrl, int, 0);
109 MODULE_PARM_DESC(debug, "Sundance Alta debug level (0-5)");
110 MODULE_PARM_DESC(rx_copybreak, "Sundance Alta copy breakpoint for copy-only-tiny-frames");
111 MODULE_PARM_DESC(flowctrl, "Sundance Alta flow control [0|1]");
112 
113 /*
114 				Theory of Operation
115 
116 I. Board Compatibility
117 
118 This driver is designed for the Sundance Technologies "Alta" ST201 chip.
119 
120 II. Board-specific settings
121 
122 III. Driver operation
123 
124 IIIa. Ring buffers
125 
126 This driver uses two statically allocated fixed-size descriptor lists
127 formed into rings by a branch from the final descriptor to the beginning of
128 the list.  The ring sizes are set at compile time by RX/TX_RING_SIZE.
129 Some chips explicitly use only 2^N sized rings, while others use a
130 'next descriptor' pointer that the driver forms into rings.
131 
132 IIIb/c. Transmit/Receive Structure
133 
134 This driver uses a zero-copy receive and transmit scheme.
135 The driver allocates full frame size skbuffs for the Rx ring buffers at
136 open() time and passes the skb->data field to the chip as receive data
137 buffers.  When an incoming frame is less than RX_COPYBREAK bytes long,
138 a fresh skbuff is allocated and the frame is copied to the new skbuff.
139 When the incoming frame is larger, the skbuff is passed directly up the
140 protocol stack.  Buffers consumed this way are replaced by newly allocated
141 skbuffs in a later phase of receives.
142 
143 The RX_COPYBREAK value is chosen to trade-off the memory wasted by
144 using a full-sized skbuff for small frames vs. the copying costs of larger
145 frames.  New boards are typically used in generously configured machines
146 and the underfilled buffers have negligible impact compared to the benefit of
147 a single allocation size, so the default value of zero results in never
148 copying packets.  When copying is done, the cost is usually mitigated by using
149 a combined copy/checksum routine.  Copying also preloads the cache, which is
150 most useful with small frames.
151 
152 A subtle aspect of the operation is that the IP header at offset 14 in an
153 ethernet frame isn't longword aligned for further processing.
154 Unaligned buffers are permitted by the Sundance hardware, so
155 frames are received into the skbuff at an offset of "+2", 16-byte aligning
156 the IP header.
157 
158 IIId. Synchronization
159 
160 The driver runs as two independent, single-threaded flows of control.  One
161 is the send-packet routine, which enforces single-threaded use by the
162 dev->tbusy flag.  The other thread is the interrupt handler, which is single
163 threaded by the hardware and interrupt handling software.
164 
165 The send packet thread has partial control over the Tx ring and 'dev->tbusy'
166 flag.  It sets the tbusy flag whenever it's queuing a Tx packet. If the next
167 queue slot is empty, it clears the tbusy flag when finished otherwise it sets
168 the 'lp->tx_full' flag.
169 
170 The interrupt handler has exclusive control over the Rx ring and records stats
171 from the Tx ring.  After reaping the stats, it marks the Tx queue entry as
172 empty by incrementing the dirty_tx mark. Iff the 'lp->tx_full' flag is set, it
173 clears both the tx_full and tbusy flags.
174 
175 IV. Notes
176 
177 IVb. References
178 
179 The Sundance ST201 datasheet, preliminary version.
180 The Kendin KS8723 datasheet, preliminary version.
181 The ICplus IP100 datasheet, preliminary version.
182 http://www.scyld.com/expert/100mbps.html
183 http://www.scyld.com/expert/NWay.html
184 
185 IVc. Errata
186 
187 */
188 
189 /* Work-around for Kendin chip bugs. */
190 #ifndef CONFIG_SUNDANCE_MMIO
191 #define USE_IO_OPS 1
192 #endif
193 
194 static const struct pci_device_id sundance_pci_tbl[] = {
195 	{ 0x1186, 0x1002, 0x1186, 0x1002, 0, 0, 0 },
196 	{ 0x1186, 0x1002, 0x1186, 0x1003, 0, 0, 1 },
197 	{ 0x1186, 0x1002, 0x1186, 0x1012, 0, 0, 2 },
198 	{ 0x1186, 0x1002, 0x1186, 0x1040, 0, 0, 3 },
199 	{ 0x1186, 0x1002, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4 },
200 	{ 0x13F0, 0x0201, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5 },
201 	{ 0x13F0, 0x0200, PCI_ANY_ID, PCI_ANY_ID, 0, 0, 6 },
202 	{ }
203 };
204 MODULE_DEVICE_TABLE(pci, sundance_pci_tbl);
205 
206 enum {
207 	netdev_io_size = 128
208 };
209 
210 struct pci_id_info {
211         const char *name;
212 };
213 static const struct pci_id_info pci_id_tbl[] = {
214 	{"D-Link DFE-550TX FAST Ethernet Adapter"},
215 	{"D-Link DFE-550FX 100Mbps Fiber-optics Adapter"},
216 	{"D-Link DFE-580TX 4 port Server Adapter"},
217 	{"D-Link DFE-530TXS FAST Ethernet Adapter"},
218 	{"D-Link DL10050-based FAST Ethernet Adapter"},
219 	{"Sundance Technology Alta"},
220 	{"IC Plus Corporation IP100A FAST Ethernet Adapter"},
221 	{ }	/* terminate list. */
222 };
223 
224 /* This driver was written to use PCI memory space, however x86-oriented
225    hardware often uses I/O space accesses. */
226 
227 /* Offsets to the device registers.
228    Unlike software-only systems, device drivers interact with complex hardware.
229    It's not useful to define symbolic names for every register bit in the
230    device.  The name can only partially document the semantics and make
231    the driver longer and more difficult to read.
232    In general, only the important configuration values or bits changed
233    multiple times should be defined symbolically.
234 */
235 enum alta_offsets {
236 	DMACtrl = 0x00,
237 	TxListPtr = 0x04,
238 	TxDMABurstThresh = 0x08,
239 	TxDMAUrgentThresh = 0x09,
240 	TxDMAPollPeriod = 0x0a,
241 	RxDMAStatus = 0x0c,
242 	RxListPtr = 0x10,
243 	DebugCtrl0 = 0x1a,
244 	DebugCtrl1 = 0x1c,
245 	RxDMABurstThresh = 0x14,
246 	RxDMAUrgentThresh = 0x15,
247 	RxDMAPollPeriod = 0x16,
248 	LEDCtrl = 0x1a,
249 	ASICCtrl = 0x30,
250 	EEData = 0x34,
251 	EECtrl = 0x36,
252 	FlashAddr = 0x40,
253 	FlashData = 0x44,
254 	WakeEvent = 0x45,
255 	TxStatus = 0x46,
256 	TxFrameId = 0x47,
257 	DownCounter = 0x18,
258 	IntrClear = 0x4a,
259 	IntrEnable = 0x4c,
260 	IntrStatus = 0x4e,
261 	MACCtrl0 = 0x50,
262 	MACCtrl1 = 0x52,
263 	StationAddr = 0x54,
264 	MaxFrameSize = 0x5A,
265 	RxMode = 0x5c,
266 	MIICtrl = 0x5e,
267 	MulticastFilter0 = 0x60,
268 	MulticastFilter1 = 0x64,
269 	RxOctetsLow = 0x68,
270 	RxOctetsHigh = 0x6a,
271 	TxOctetsLow = 0x6c,
272 	TxOctetsHigh = 0x6e,
273 	TxFramesOK = 0x70,
274 	RxFramesOK = 0x72,
275 	StatsCarrierError = 0x74,
276 	StatsLateColl = 0x75,
277 	StatsMultiColl = 0x76,
278 	StatsOneColl = 0x77,
279 	StatsTxDefer = 0x78,
280 	RxMissed = 0x79,
281 	StatsTxXSDefer = 0x7a,
282 	StatsTxAbort = 0x7b,
283 	StatsBcastTx = 0x7c,
284 	StatsBcastRx = 0x7d,
285 	StatsMcastTx = 0x7e,
286 	StatsMcastRx = 0x7f,
287 	/* Aliased and bogus values! */
288 	RxStatus = 0x0c,
289 };
290 
291 #define ASIC_HI_WORD(x)	((x) + 2)
292 
293 enum ASICCtrl_HiWord_bit {
294 	GlobalReset = 0x0001,
295 	RxReset = 0x0002,
296 	TxReset = 0x0004,
297 	DMAReset = 0x0008,
298 	FIFOReset = 0x0010,
299 	NetworkReset = 0x0020,
300 	HostReset = 0x0040,
301 	ResetBusy = 0x0400,
302 };
303 
304 /* Bits in the interrupt status/mask registers. */
305 enum intr_status_bits {
306 	IntrSummary=0x0001, IntrPCIErr=0x0002, IntrMACCtrl=0x0008,
307 	IntrTxDone=0x0004, IntrRxDone=0x0010, IntrRxStart=0x0020,
308 	IntrDrvRqst=0x0040,
309 	StatsMax=0x0080, LinkChange=0x0100,
310 	IntrTxDMADone=0x0200, IntrRxDMADone=0x0400,
311 };
312 
313 /* Bits in the RxMode register. */
314 enum rx_mode_bits {
315 	AcceptAllIPMulti=0x20, AcceptMultiHash=0x10, AcceptAll=0x08,
316 	AcceptBroadcast=0x04, AcceptMulticast=0x02, AcceptMyPhys=0x01,
317 };
318 /* Bits in MACCtrl. */
319 enum mac_ctrl0_bits {
320 	EnbFullDuplex=0x20, EnbRcvLargeFrame=0x40,
321 	EnbFlowCtrl=0x100, EnbPassRxCRC=0x200,
322 };
323 enum mac_ctrl1_bits {
324 	StatsEnable=0x0020,	StatsDisable=0x0040, StatsEnabled=0x0080,
325 	TxEnable=0x0100, TxDisable=0x0200, TxEnabled=0x0400,
326 	RxEnable=0x0800, RxDisable=0x1000, RxEnabled=0x2000,
327 };
328 
329 /* Bits in WakeEvent register. */
330 enum wake_event_bits {
331 	WakePktEnable = 0x01,
332 	MagicPktEnable = 0x02,
333 	LinkEventEnable = 0x04,
334 	WolEnable = 0x80,
335 };
336 
337 /* The Rx and Tx buffer descriptors. */
338 /* Note that using only 32 bit fields simplifies conversion to big-endian
339    architectures. */
340 struct netdev_desc {
341 	__le32 next_desc;
342 	__le32 status;
343 	struct desc_frag { __le32 addr, length; } frag;
344 };
345 
346 /* Bits in netdev_desc.status */
347 enum desc_status_bits {
348 	DescOwn=0x8000,
349 	DescEndPacket=0x4000,
350 	DescEndRing=0x2000,
351 	LastFrag=0x80000000,
352 	DescIntrOnTx=0x8000,
353 	DescIntrOnDMADone=0x80000000,
354 	DisableAlign = 0x00000001,
355 };
356 
357 #define PRIV_ALIGN	15 	/* Required alignment mask */
358 /* Use  __attribute__((aligned (L1_CACHE_BYTES)))  to maintain alignment
359    within the structure. */
360 #define MII_CNT		4
361 struct netdev_private {
362 	/* Descriptor rings first for alignment. */
363 	struct netdev_desc *rx_ring;
364 	struct netdev_desc *tx_ring;
365 	struct sk_buff* rx_skbuff[RX_RING_SIZE];
366 	struct sk_buff* tx_skbuff[TX_RING_SIZE];
367         dma_addr_t tx_ring_dma;
368         dma_addr_t rx_ring_dma;
369 	struct timer_list timer;		/* Media monitoring timer. */
370 	struct net_device *ndev;		/* backpointer */
371 	/* ethtool extra stats */
372 	struct {
373 		u64 tx_multiple_collisions;
374 		u64 tx_single_collisions;
375 		u64 tx_late_collisions;
376 		u64 tx_deferred;
377 		u64 tx_deferred_excessive;
378 		u64 tx_aborted;
379 		u64 tx_bcasts;
380 		u64 rx_bcasts;
381 		u64 tx_mcasts;
382 		u64 rx_mcasts;
383 	} xstats;
384 	/* Frequently used values: keep some adjacent for cache effect. */
385 	spinlock_t lock;
386 	int msg_enable;
387 	int chip_id;
388 	unsigned int cur_rx, dirty_rx;		/* Producer/consumer ring indices */
389 	unsigned int rx_buf_sz;			/* Based on MTU+slack. */
390 	struct netdev_desc *last_tx;		/* Last Tx descriptor used. */
391 	unsigned int cur_tx, dirty_tx;
392 	/* These values are keep track of the transceiver/media in use. */
393 	unsigned int flowctrl:1;
394 	unsigned int default_port:4;		/* Last dev->if_port value. */
395 	unsigned int an_enable:1;
396 	unsigned int speed;
397 	unsigned int wol_enabled:1;			/* Wake on LAN enabled */
398 	struct tasklet_struct rx_tasklet;
399 	struct tasklet_struct tx_tasklet;
400 	int budget;
401 	int cur_task;
402 	/* Multicast and receive mode. */
403 	spinlock_t mcastlock;			/* SMP lock multicast updates. */
404 	u16 mcast_filter[4];
405 	/* MII transceiver section. */
406 	struct mii_if_info mii_if;
407 	int mii_preamble_required;
408 	unsigned char phys[MII_CNT];		/* MII device addresses, only first one used. */
409 	struct pci_dev *pci_dev;
410 	void __iomem *base;
411 	spinlock_t statlock;
412 };
413 
414 /* The station address location in the EEPROM. */
415 #define EEPROM_SA_OFFSET	0x10
416 #define DEFAULT_INTR (IntrRxDMADone | IntrPCIErr | \
417 			IntrDrvRqst | IntrTxDone | StatsMax | \
418 			LinkChange)
419 
420 static int  change_mtu(struct net_device *dev, int new_mtu);
421 static int  eeprom_read(void __iomem *ioaddr, int location);
422 static int  mdio_read(struct net_device *dev, int phy_id, int location);
423 static void mdio_write(struct net_device *dev, int phy_id, int location, int value);
424 static int  mdio_wait_link(struct net_device *dev, int wait);
425 static int  netdev_open(struct net_device *dev);
426 static void check_duplex(struct net_device *dev);
427 static void netdev_timer(struct timer_list *t);
428 static void tx_timeout(struct net_device *dev, unsigned int txqueue);
429 static void init_ring(struct net_device *dev);
430 static netdev_tx_t start_tx(struct sk_buff *skb, struct net_device *dev);
431 static int reset_tx (struct net_device *dev);
432 static irqreturn_t intr_handler(int irq, void *dev_instance);
433 static void rx_poll(struct tasklet_struct *t);
434 static void tx_poll(struct tasklet_struct *t);
435 static void refill_rx (struct net_device *dev);
436 static void netdev_error(struct net_device *dev, int intr_status);
437 static void netdev_error(struct net_device *dev, int intr_status);
438 static void set_rx_mode(struct net_device *dev);
439 static int __set_mac_addr(struct net_device *dev);
440 static int sundance_set_mac_addr(struct net_device *dev, void *data);
441 static struct net_device_stats *get_stats(struct net_device *dev);
442 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd);
443 static int  netdev_close(struct net_device *dev);
444 static const struct ethtool_ops ethtool_ops;
445 
sundance_reset(struct net_device * dev,unsigned long reset_cmd)446 static void sundance_reset(struct net_device *dev, unsigned long reset_cmd)
447 {
448 	struct netdev_private *np = netdev_priv(dev);
449 	void __iomem *ioaddr = np->base + ASICCtrl;
450 	int countdown;
451 
452 	/* ST201 documentation states ASICCtrl is a 32bit register */
453 	iowrite32 (reset_cmd | ioread32 (ioaddr), ioaddr);
454 	/* ST201 documentation states reset can take up to 1 ms */
455 	countdown = 10 + 1;
456 	while (ioread32 (ioaddr) & (ResetBusy << 16)) {
457 		if (--countdown == 0) {
458 			printk(KERN_WARNING "%s : reset not completed !!\n", dev->name);
459 			break;
460 		}
461 		udelay(100);
462 	}
463 }
464 
465 #ifdef CONFIG_NET_POLL_CONTROLLER
sundance_poll_controller(struct net_device * dev)466 static void sundance_poll_controller(struct net_device *dev)
467 {
468 	struct netdev_private *np = netdev_priv(dev);
469 
470 	disable_irq(np->pci_dev->irq);
471 	intr_handler(np->pci_dev->irq, dev);
472 	enable_irq(np->pci_dev->irq);
473 }
474 #endif
475 
476 static const struct net_device_ops netdev_ops = {
477 	.ndo_open		= netdev_open,
478 	.ndo_stop		= netdev_close,
479 	.ndo_start_xmit		= start_tx,
480 	.ndo_get_stats 		= get_stats,
481 	.ndo_set_rx_mode	= set_rx_mode,
482 	.ndo_eth_ioctl		= netdev_ioctl,
483 	.ndo_tx_timeout		= tx_timeout,
484 	.ndo_change_mtu		= change_mtu,
485 	.ndo_set_mac_address 	= sundance_set_mac_addr,
486 	.ndo_validate_addr	= eth_validate_addr,
487 #ifdef CONFIG_NET_POLL_CONTROLLER
488 	.ndo_poll_controller 	= sundance_poll_controller,
489 #endif
490 };
491 
sundance_probe1(struct pci_dev * pdev,const struct pci_device_id * ent)492 static int sundance_probe1(struct pci_dev *pdev,
493 			   const struct pci_device_id *ent)
494 {
495 	struct net_device *dev;
496 	struct netdev_private *np;
497 	static int card_idx;
498 	int chip_idx = ent->driver_data;
499 	int irq;
500 	int i;
501 	void __iomem *ioaddr;
502 	u16 mii_ctl;
503 	void *ring_space;
504 	dma_addr_t ring_dma;
505 #ifdef USE_IO_OPS
506 	int bar = 0;
507 #else
508 	int bar = 1;
509 #endif
510 	int phy, phy_end, phy_idx = 0;
511 	__le16 addr[ETH_ALEN / 2];
512 
513 	if (pci_enable_device(pdev))
514 		return -EIO;
515 	pci_set_master(pdev);
516 
517 	irq = pdev->irq;
518 
519 	dev = alloc_etherdev(sizeof(*np));
520 	if (!dev)
521 		return -ENOMEM;
522 	SET_NETDEV_DEV(dev, &pdev->dev);
523 
524 	if (pci_request_regions(pdev, DRV_NAME))
525 		goto err_out_netdev;
526 
527 	ioaddr = pci_iomap(pdev, bar, netdev_io_size);
528 	if (!ioaddr)
529 		goto err_out_res;
530 
531 	for (i = 0; i < 3; i++)
532 		addr[i] =
533 			cpu_to_le16(eeprom_read(ioaddr, i + EEPROM_SA_OFFSET));
534 	eth_hw_addr_set(dev, (u8 *)addr);
535 
536 	np = netdev_priv(dev);
537 	np->ndev = dev;
538 	np->base = ioaddr;
539 	np->pci_dev = pdev;
540 	np->chip_id = chip_idx;
541 	np->msg_enable = (1 << debug) - 1;
542 	spin_lock_init(&np->lock);
543 	spin_lock_init(&np->statlock);
544 	tasklet_setup(&np->rx_tasklet, rx_poll);
545 	tasklet_setup(&np->tx_tasklet, tx_poll);
546 
547 	ring_space = dma_alloc_coherent(&pdev->dev, TX_TOTAL_SIZE,
548 			&ring_dma, GFP_KERNEL);
549 	if (!ring_space)
550 		goto err_out_cleardev;
551 	np->tx_ring = (struct netdev_desc *)ring_space;
552 	np->tx_ring_dma = ring_dma;
553 
554 	ring_space = dma_alloc_coherent(&pdev->dev, RX_TOTAL_SIZE,
555 			&ring_dma, GFP_KERNEL);
556 	if (!ring_space)
557 		goto err_out_unmap_tx;
558 	np->rx_ring = (struct netdev_desc *)ring_space;
559 	np->rx_ring_dma = ring_dma;
560 
561 	np->mii_if.dev = dev;
562 	np->mii_if.mdio_read = mdio_read;
563 	np->mii_if.mdio_write = mdio_write;
564 	np->mii_if.phy_id_mask = 0x1f;
565 	np->mii_if.reg_num_mask = 0x1f;
566 
567 	/* The chip-specific entries in the device structure. */
568 	dev->netdev_ops = &netdev_ops;
569 	dev->ethtool_ops = &ethtool_ops;
570 	dev->watchdog_timeo = TX_TIMEOUT;
571 
572 	/* MTU range: 68 - 8191 */
573 	dev->min_mtu = ETH_MIN_MTU;
574 	dev->max_mtu = 8191;
575 
576 	pci_set_drvdata(pdev, dev);
577 
578 	i = register_netdev(dev);
579 	if (i)
580 		goto err_out_unmap_rx;
581 
582 	printk(KERN_INFO "%s: %s at %p, %pM, IRQ %d.\n",
583 	       dev->name, pci_id_tbl[chip_idx].name, ioaddr,
584 	       dev->dev_addr, irq);
585 
586 	np->phys[0] = 1;		/* Default setting */
587 	np->mii_preamble_required++;
588 
589 	/*
590 	 * It seems some phys doesn't deal well with address 0 being accessed
591 	 * first
592 	 */
593 	if (sundance_pci_tbl[np->chip_id].device == 0x0200) {
594 		phy = 0;
595 		phy_end = 31;
596 	} else {
597 		phy = 1;
598 		phy_end = 32;	/* wraps to zero, due to 'phy & 0x1f' */
599 	}
600 	for (; phy <= phy_end && phy_idx < MII_CNT; phy++) {
601 		int phyx = phy & 0x1f;
602 		int mii_status = mdio_read(dev, phyx, MII_BMSR);
603 		if (mii_status != 0xffff  &&  mii_status != 0x0000) {
604 			np->phys[phy_idx++] = phyx;
605 			np->mii_if.advertising = mdio_read(dev, phyx, MII_ADVERTISE);
606 			if ((mii_status & 0x0040) == 0)
607 				np->mii_preamble_required++;
608 			printk(KERN_INFO "%s: MII PHY found at address %d, status "
609 				   "0x%4.4x advertising %4.4x.\n",
610 				   dev->name, phyx, mii_status, np->mii_if.advertising);
611 		}
612 	}
613 	np->mii_preamble_required--;
614 
615 	if (phy_idx == 0) {
616 		printk(KERN_INFO "%s: No MII transceiver found, aborting.  ASIC status %x\n",
617 			   dev->name, ioread32(ioaddr + ASICCtrl));
618 		goto err_out_unregister;
619 	}
620 
621 	np->mii_if.phy_id = np->phys[0];
622 
623 	/* Parse override configuration */
624 	np->an_enable = 1;
625 	if (card_idx < MAX_UNITS) {
626 		if (media[card_idx] != NULL) {
627 			np->an_enable = 0;
628 			if (strcmp (media[card_idx], "100mbps_fd") == 0 ||
629 			    strcmp (media[card_idx], "4") == 0) {
630 				np->speed = 100;
631 				np->mii_if.full_duplex = 1;
632 			} else if (strcmp (media[card_idx], "100mbps_hd") == 0 ||
633 				   strcmp (media[card_idx], "3") == 0) {
634 				np->speed = 100;
635 				np->mii_if.full_duplex = 0;
636 			} else if (strcmp (media[card_idx], "10mbps_fd") == 0 ||
637 				   strcmp (media[card_idx], "2") == 0) {
638 				np->speed = 10;
639 				np->mii_if.full_duplex = 1;
640 			} else if (strcmp (media[card_idx], "10mbps_hd") == 0 ||
641 				   strcmp (media[card_idx], "1") == 0) {
642 				np->speed = 10;
643 				np->mii_if.full_duplex = 0;
644 			} else {
645 				np->an_enable = 1;
646 			}
647 		}
648 		if (flowctrl == 1)
649 			np->flowctrl = 1;
650 	}
651 
652 	/* Fibre PHY? */
653 	if (ioread32 (ioaddr + ASICCtrl) & 0x80) {
654 		/* Default 100Mbps Full */
655 		if (np->an_enable) {
656 			np->speed = 100;
657 			np->mii_if.full_duplex = 1;
658 			np->an_enable = 0;
659 		}
660 	}
661 	/* Reset PHY */
662 	mdio_write (dev, np->phys[0], MII_BMCR, BMCR_RESET);
663 	mdelay (300);
664 	/* If flow control enabled, we need to advertise it.*/
665 	if (np->flowctrl)
666 		mdio_write (dev, np->phys[0], MII_ADVERTISE, np->mii_if.advertising | 0x0400);
667 	mdio_write (dev, np->phys[0], MII_BMCR, BMCR_ANENABLE|BMCR_ANRESTART);
668 	/* Force media type */
669 	if (!np->an_enable) {
670 		mii_ctl = 0;
671 		mii_ctl |= (np->speed == 100) ? BMCR_SPEED100 : 0;
672 		mii_ctl |= (np->mii_if.full_duplex) ? BMCR_FULLDPLX : 0;
673 		mdio_write (dev, np->phys[0], MII_BMCR, mii_ctl);
674 		printk (KERN_INFO "Override speed=%d, %s duplex\n",
675 			np->speed, np->mii_if.full_duplex ? "Full" : "Half");
676 
677 	}
678 
679 	/* Perhaps move the reset here? */
680 	/* Reset the chip to erase previous misconfiguration. */
681 	if (netif_msg_hw(np))
682 		printk("ASIC Control is %x.\n", ioread32(ioaddr + ASICCtrl));
683 	sundance_reset(dev, 0x00ff << 16);
684 	if (netif_msg_hw(np))
685 		printk("ASIC Control is now %x.\n", ioread32(ioaddr + ASICCtrl));
686 
687 	card_idx++;
688 	return 0;
689 
690 err_out_unregister:
691 	unregister_netdev(dev);
692 err_out_unmap_rx:
693 	dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE,
694 		np->rx_ring, np->rx_ring_dma);
695 err_out_unmap_tx:
696 	dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE,
697 		np->tx_ring, np->tx_ring_dma);
698 err_out_cleardev:
699 	pci_iounmap(pdev, ioaddr);
700 err_out_res:
701 	pci_release_regions(pdev);
702 err_out_netdev:
703 	free_netdev (dev);
704 	return -ENODEV;
705 }
706 
change_mtu(struct net_device * dev,int new_mtu)707 static int change_mtu(struct net_device *dev, int new_mtu)
708 {
709 	if (netif_running(dev))
710 		return -EBUSY;
711 	dev->mtu = new_mtu;
712 	return 0;
713 }
714 
715 #define eeprom_delay(ee_addr)	ioread32(ee_addr)
716 /* Read the EEPROM and MII Management Data I/O (MDIO) interfaces. */
eeprom_read(void __iomem * ioaddr,int location)717 static int eeprom_read(void __iomem *ioaddr, int location)
718 {
719 	int boguscnt = 10000;		/* Typical 1900 ticks. */
720 	iowrite16(0x0200 | (location & 0xff), ioaddr + EECtrl);
721 	do {
722 		eeprom_delay(ioaddr + EECtrl);
723 		if (! (ioread16(ioaddr + EECtrl) & 0x8000)) {
724 			return ioread16(ioaddr + EEData);
725 		}
726 	} while (--boguscnt > 0);
727 	return 0;
728 }
729 
730 /*  MII transceiver control section.
731 	Read and write the MII registers using software-generated serial
732 	MDIO protocol.  See the MII specifications or DP83840A data sheet
733 	for details.
734 
735 	The maximum data clock rate is 2.5 Mhz.  The minimum timing is usually
736 	met by back-to-back 33Mhz PCI cycles. */
737 #define mdio_delay() ioread8(mdio_addr)
738 
739 enum mii_reg_bits {
740 	MDIO_ShiftClk=0x0001, MDIO_Data=0x0002, MDIO_EnbOutput=0x0004,
741 };
742 #define MDIO_EnbIn  (0)
743 #define MDIO_WRITE0 (MDIO_EnbOutput)
744 #define MDIO_WRITE1 (MDIO_Data | MDIO_EnbOutput)
745 
746 /* Generate the preamble required for initial synchronization and
747    a few older transceivers. */
mdio_sync(void __iomem * mdio_addr)748 static void mdio_sync(void __iomem *mdio_addr)
749 {
750 	int bits = 32;
751 
752 	/* Establish sync by sending at least 32 logic ones. */
753 	while (--bits >= 0) {
754 		iowrite8(MDIO_WRITE1, mdio_addr);
755 		mdio_delay();
756 		iowrite8(MDIO_WRITE1 | MDIO_ShiftClk, mdio_addr);
757 		mdio_delay();
758 	}
759 }
760 
mdio_read(struct net_device * dev,int phy_id,int location)761 static int mdio_read(struct net_device *dev, int phy_id, int location)
762 {
763 	struct netdev_private *np = netdev_priv(dev);
764 	void __iomem *mdio_addr = np->base + MIICtrl;
765 	int mii_cmd = (0xf6 << 10) | (phy_id << 5) | location;
766 	int i, retval = 0;
767 
768 	if (np->mii_preamble_required)
769 		mdio_sync(mdio_addr);
770 
771 	/* Shift the read command bits out. */
772 	for (i = 15; i >= 0; i--) {
773 		int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
774 
775 		iowrite8(dataval, mdio_addr);
776 		mdio_delay();
777 		iowrite8(dataval | MDIO_ShiftClk, mdio_addr);
778 		mdio_delay();
779 	}
780 	/* Read the two transition, 16 data, and wire-idle bits. */
781 	for (i = 19; i > 0; i--) {
782 		iowrite8(MDIO_EnbIn, mdio_addr);
783 		mdio_delay();
784 		retval = (retval << 1) | ((ioread8(mdio_addr) & MDIO_Data) ? 1 : 0);
785 		iowrite8(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
786 		mdio_delay();
787 	}
788 	return (retval>>1) & 0xffff;
789 }
790 
mdio_write(struct net_device * dev,int phy_id,int location,int value)791 static void mdio_write(struct net_device *dev, int phy_id, int location, int value)
792 {
793 	struct netdev_private *np = netdev_priv(dev);
794 	void __iomem *mdio_addr = np->base + MIICtrl;
795 	int mii_cmd = (0x5002 << 16) | (phy_id << 23) | (location<<18) | value;
796 	int i;
797 
798 	if (np->mii_preamble_required)
799 		mdio_sync(mdio_addr);
800 
801 	/* Shift the command bits out. */
802 	for (i = 31; i >= 0; i--) {
803 		int dataval = (mii_cmd & (1 << i)) ? MDIO_WRITE1 : MDIO_WRITE0;
804 
805 		iowrite8(dataval, mdio_addr);
806 		mdio_delay();
807 		iowrite8(dataval | MDIO_ShiftClk, mdio_addr);
808 		mdio_delay();
809 	}
810 	/* Clear out extra bits. */
811 	for (i = 2; i > 0; i--) {
812 		iowrite8(MDIO_EnbIn, mdio_addr);
813 		mdio_delay();
814 		iowrite8(MDIO_EnbIn | MDIO_ShiftClk, mdio_addr);
815 		mdio_delay();
816 	}
817 }
818 
mdio_wait_link(struct net_device * dev,int wait)819 static int mdio_wait_link(struct net_device *dev, int wait)
820 {
821 	int bmsr;
822 	int phy_id;
823 	struct netdev_private *np;
824 
825 	np = netdev_priv(dev);
826 	phy_id = np->phys[0];
827 
828 	do {
829 		bmsr = mdio_read(dev, phy_id, MII_BMSR);
830 		if (bmsr & 0x0004)
831 			return 0;
832 		mdelay(1);
833 	} while (--wait > 0);
834 	return -1;
835 }
836 
netdev_open(struct net_device * dev)837 static int netdev_open(struct net_device *dev)
838 {
839 	struct netdev_private *np = netdev_priv(dev);
840 	void __iomem *ioaddr = np->base;
841 	const int irq = np->pci_dev->irq;
842 	unsigned long flags;
843 	int i;
844 
845 	sundance_reset(dev, 0x00ff << 16);
846 
847 	i = request_irq(irq, intr_handler, IRQF_SHARED, dev->name, dev);
848 	if (i)
849 		return i;
850 
851 	if (netif_msg_ifup(np))
852 		printk(KERN_DEBUG "%s: netdev_open() irq %d\n", dev->name, irq);
853 
854 	init_ring(dev);
855 
856 	iowrite32(np->rx_ring_dma, ioaddr + RxListPtr);
857 	/* The Tx list pointer is written as packets are queued. */
858 
859 	/* Initialize other registers. */
860 	__set_mac_addr(dev);
861 #if IS_ENABLED(CONFIG_VLAN_8021Q)
862 	iowrite16(dev->mtu + 18, ioaddr + MaxFrameSize);
863 #else
864 	iowrite16(dev->mtu + 14, ioaddr + MaxFrameSize);
865 #endif
866 	if (dev->mtu > 2047)
867 		iowrite32(ioread32(ioaddr + ASICCtrl) | 0x0C, ioaddr + ASICCtrl);
868 
869 	/* Configure the PCI bus bursts and FIFO thresholds. */
870 
871 	if (dev->if_port == 0)
872 		dev->if_port = np->default_port;
873 
874 	spin_lock_init(&np->mcastlock);
875 
876 	set_rx_mode(dev);
877 	iowrite16(0, ioaddr + IntrEnable);
878 	iowrite16(0, ioaddr + DownCounter);
879 	/* Set the chip to poll every N*320nsec. */
880 	iowrite8(100, ioaddr + RxDMAPollPeriod);
881 	iowrite8(127, ioaddr + TxDMAPollPeriod);
882 	/* Fix DFE-580TX packet drop issue */
883 	if (np->pci_dev->revision >= 0x14)
884 		iowrite8(0x01, ioaddr + DebugCtrl1);
885 	netif_start_queue(dev);
886 
887 	spin_lock_irqsave(&np->lock, flags);
888 	reset_tx(dev);
889 	spin_unlock_irqrestore(&np->lock, flags);
890 
891 	iowrite16 (StatsEnable | RxEnable | TxEnable, ioaddr + MACCtrl1);
892 
893 	/* Disable Wol */
894 	iowrite8(ioread8(ioaddr + WakeEvent) | 0x00, ioaddr + WakeEvent);
895 	np->wol_enabled = 0;
896 
897 	if (netif_msg_ifup(np))
898 		printk(KERN_DEBUG "%s: Done netdev_open(), status: Rx %x Tx %x "
899 			   "MAC Control %x, %4.4x %4.4x.\n",
900 			   dev->name, ioread32(ioaddr + RxStatus), ioread8(ioaddr + TxStatus),
901 			   ioread32(ioaddr + MACCtrl0),
902 			   ioread16(ioaddr + MACCtrl1), ioread16(ioaddr + MACCtrl0));
903 
904 	/* Set the timer to check for link beat. */
905 	timer_setup(&np->timer, netdev_timer, 0);
906 	np->timer.expires = jiffies + 3*HZ;
907 	add_timer(&np->timer);
908 
909 	/* Enable interrupts by setting the interrupt mask. */
910 	iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
911 
912 	return 0;
913 }
914 
check_duplex(struct net_device * dev)915 static void check_duplex(struct net_device *dev)
916 {
917 	struct netdev_private *np = netdev_priv(dev);
918 	void __iomem *ioaddr = np->base;
919 	int mii_lpa = mdio_read(dev, np->phys[0], MII_LPA);
920 	int negotiated = mii_lpa & np->mii_if.advertising;
921 	int duplex;
922 
923 	/* Force media */
924 	if (!np->an_enable || mii_lpa == 0xffff) {
925 		if (np->mii_if.full_duplex)
926 			iowrite16 (ioread16 (ioaddr + MACCtrl0) | EnbFullDuplex,
927 				ioaddr + MACCtrl0);
928 		return;
929 	}
930 
931 	/* Autonegotiation */
932 	duplex = (negotiated & 0x0100) || (negotiated & 0x01C0) == 0x0040;
933 	if (np->mii_if.full_duplex != duplex) {
934 		np->mii_if.full_duplex = duplex;
935 		if (netif_msg_link(np))
936 			printk(KERN_INFO "%s: Setting %s-duplex based on MII #%d "
937 				   "negotiated capability %4.4x.\n", dev->name,
938 				   duplex ? "full" : "half", np->phys[0], negotiated);
939 		iowrite16(ioread16(ioaddr + MACCtrl0) | (duplex ? 0x20 : 0), ioaddr + MACCtrl0);
940 	}
941 }
942 
netdev_timer(struct timer_list * t)943 static void netdev_timer(struct timer_list *t)
944 {
945 	struct netdev_private *np = from_timer(np, t, timer);
946 	struct net_device *dev = np->mii_if.dev;
947 	void __iomem *ioaddr = np->base;
948 	int next_tick = 10*HZ;
949 
950 	if (netif_msg_timer(np)) {
951 		printk(KERN_DEBUG "%s: Media selection timer tick, intr status %4.4x, "
952 			   "Tx %x Rx %x.\n",
953 			   dev->name, ioread16(ioaddr + IntrEnable),
954 			   ioread8(ioaddr + TxStatus), ioread32(ioaddr + RxStatus));
955 	}
956 	check_duplex(dev);
957 	np->timer.expires = jiffies + next_tick;
958 	add_timer(&np->timer);
959 }
960 
tx_timeout(struct net_device * dev,unsigned int txqueue)961 static void tx_timeout(struct net_device *dev, unsigned int txqueue)
962 {
963 	struct netdev_private *np = netdev_priv(dev);
964 	void __iomem *ioaddr = np->base;
965 	unsigned long flag;
966 
967 	netif_stop_queue(dev);
968 	tasklet_disable_in_atomic(&np->tx_tasklet);
969 	iowrite16(0, ioaddr + IntrEnable);
970 	printk(KERN_WARNING "%s: Transmit timed out, TxStatus %2.2x "
971 		   "TxFrameId %2.2x,"
972 		   " resetting...\n", dev->name, ioread8(ioaddr + TxStatus),
973 		   ioread8(ioaddr + TxFrameId));
974 
975 	{
976 		int i;
977 		for (i=0; i<TX_RING_SIZE; i++) {
978 			printk(KERN_DEBUG "%02x %08llx %08x %08x(%02x) %08x %08x\n", i,
979 				(unsigned long long)(np->tx_ring_dma + i*sizeof(*np->tx_ring)),
980 				le32_to_cpu(np->tx_ring[i].next_desc),
981 				le32_to_cpu(np->tx_ring[i].status),
982 				(le32_to_cpu(np->tx_ring[i].status) >> 2) & 0xff,
983 				le32_to_cpu(np->tx_ring[i].frag.addr),
984 				le32_to_cpu(np->tx_ring[i].frag.length));
985 		}
986 		printk(KERN_DEBUG "TxListPtr=%08x netif_queue_stopped=%d\n",
987 			ioread32(np->base + TxListPtr),
988 			netif_queue_stopped(dev));
989 		printk(KERN_DEBUG "cur_tx=%d(%02x) dirty_tx=%d(%02x)\n",
990 			np->cur_tx, np->cur_tx % TX_RING_SIZE,
991 			np->dirty_tx, np->dirty_tx % TX_RING_SIZE);
992 		printk(KERN_DEBUG "cur_rx=%d dirty_rx=%d\n", np->cur_rx, np->dirty_rx);
993 		printk(KERN_DEBUG "cur_task=%d\n", np->cur_task);
994 	}
995 	spin_lock_irqsave(&np->lock, flag);
996 
997 	/* Stop and restart the chip's Tx processes . */
998 	reset_tx(dev);
999 	spin_unlock_irqrestore(&np->lock, flag);
1000 
1001 	dev->if_port = 0;
1002 
1003 	netif_trans_update(dev); /* prevent tx timeout */
1004 	dev->stats.tx_errors++;
1005 	if (np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) {
1006 		netif_wake_queue(dev);
1007 	}
1008 	iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
1009 	tasklet_enable(&np->tx_tasklet);
1010 }
1011 
1012 
1013 /* Initialize the Rx and Tx rings, along with various 'dev' bits. */
init_ring(struct net_device * dev)1014 static void init_ring(struct net_device *dev)
1015 {
1016 	struct netdev_private *np = netdev_priv(dev);
1017 	int i;
1018 
1019 	np->cur_rx = np->cur_tx = 0;
1020 	np->dirty_rx = np->dirty_tx = 0;
1021 	np->cur_task = 0;
1022 
1023 	np->rx_buf_sz = (dev->mtu <= 1520 ? PKT_BUF_SZ : dev->mtu + 16);
1024 
1025 	/* Initialize all Rx descriptors. */
1026 	for (i = 0; i < RX_RING_SIZE; i++) {
1027 		np->rx_ring[i].next_desc = cpu_to_le32(np->rx_ring_dma +
1028 			((i+1)%RX_RING_SIZE)*sizeof(*np->rx_ring));
1029 		np->rx_ring[i].status = 0;
1030 		np->rx_ring[i].frag.length = 0;
1031 		np->rx_skbuff[i] = NULL;
1032 	}
1033 
1034 	/* Fill in the Rx buffers.  Handle allocation failure gracefully. */
1035 	for (i = 0; i < RX_RING_SIZE; i++) {
1036 		struct sk_buff *skb =
1037 			netdev_alloc_skb(dev, np->rx_buf_sz + 2);
1038 		np->rx_skbuff[i] = skb;
1039 		if (skb == NULL)
1040 			break;
1041 		skb_reserve(skb, 2);	/* 16 byte align the IP header. */
1042 		np->rx_ring[i].frag.addr = cpu_to_le32(
1043 			dma_map_single(&np->pci_dev->dev, skb->data,
1044 				np->rx_buf_sz, DMA_FROM_DEVICE));
1045 		if (dma_mapping_error(&np->pci_dev->dev,
1046 					np->rx_ring[i].frag.addr)) {
1047 			dev_kfree_skb(skb);
1048 			np->rx_skbuff[i] = NULL;
1049 			break;
1050 		}
1051 		np->rx_ring[i].frag.length = cpu_to_le32(np->rx_buf_sz | LastFrag);
1052 	}
1053 	np->dirty_rx = (unsigned int)(i - RX_RING_SIZE);
1054 
1055 	for (i = 0; i < TX_RING_SIZE; i++) {
1056 		np->tx_skbuff[i] = NULL;
1057 		np->tx_ring[i].status = 0;
1058 	}
1059 }
1060 
tx_poll(struct tasklet_struct * t)1061 static void tx_poll(struct tasklet_struct *t)
1062 {
1063 	struct netdev_private *np = from_tasklet(np, t, tx_tasklet);
1064 	unsigned head = np->cur_task % TX_RING_SIZE;
1065 	struct netdev_desc *txdesc =
1066 		&np->tx_ring[(np->cur_tx - 1) % TX_RING_SIZE];
1067 
1068 	/* Chain the next pointer */
1069 	for (; np->cur_tx - np->cur_task > 0; np->cur_task++) {
1070 		int entry = np->cur_task % TX_RING_SIZE;
1071 		txdesc = &np->tx_ring[entry];
1072 		if (np->last_tx) {
1073 			np->last_tx->next_desc = cpu_to_le32(np->tx_ring_dma +
1074 				entry*sizeof(struct netdev_desc));
1075 		}
1076 		np->last_tx = txdesc;
1077 	}
1078 	/* Indicate the latest descriptor of tx ring */
1079 	txdesc->status |= cpu_to_le32(DescIntrOnTx);
1080 
1081 	if (ioread32 (np->base + TxListPtr) == 0)
1082 		iowrite32 (np->tx_ring_dma + head * sizeof(struct netdev_desc),
1083 			np->base + TxListPtr);
1084 }
1085 
1086 static netdev_tx_t
start_tx(struct sk_buff * skb,struct net_device * dev)1087 start_tx (struct sk_buff *skb, struct net_device *dev)
1088 {
1089 	struct netdev_private *np = netdev_priv(dev);
1090 	struct netdev_desc *txdesc;
1091 	unsigned entry;
1092 
1093 	/* Calculate the next Tx descriptor entry. */
1094 	entry = np->cur_tx % TX_RING_SIZE;
1095 	np->tx_skbuff[entry] = skb;
1096 	txdesc = &np->tx_ring[entry];
1097 
1098 	txdesc->next_desc = 0;
1099 	txdesc->status = cpu_to_le32 ((entry << 2) | DisableAlign);
1100 	txdesc->frag.addr = cpu_to_le32(dma_map_single(&np->pci_dev->dev,
1101 				skb->data, skb->len, DMA_TO_DEVICE));
1102 	if (dma_mapping_error(&np->pci_dev->dev,
1103 				txdesc->frag.addr))
1104 			goto drop_frame;
1105 	txdesc->frag.length = cpu_to_le32 (skb->len | LastFrag);
1106 
1107 	/* Increment cur_tx before tasklet_schedule() */
1108 	np->cur_tx++;
1109 	mb();
1110 	/* Schedule a tx_poll() task */
1111 	tasklet_schedule(&np->tx_tasklet);
1112 
1113 	/* On some architectures: explicitly flush cache lines here. */
1114 	if (np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 1 &&
1115 	    !netif_queue_stopped(dev)) {
1116 		/* do nothing */
1117 	} else {
1118 		netif_stop_queue (dev);
1119 	}
1120 	if (netif_msg_tx_queued(np)) {
1121 		printk (KERN_DEBUG
1122 			"%s: Transmit frame #%d queued in slot %d.\n",
1123 			dev->name, np->cur_tx, entry);
1124 	}
1125 	return NETDEV_TX_OK;
1126 
1127 drop_frame:
1128 	dev_kfree_skb_any(skb);
1129 	np->tx_skbuff[entry] = NULL;
1130 	dev->stats.tx_dropped++;
1131 	return NETDEV_TX_OK;
1132 }
1133 
1134 /* Reset hardware tx and free all of tx buffers */
1135 static int
reset_tx(struct net_device * dev)1136 reset_tx (struct net_device *dev)
1137 {
1138 	struct netdev_private *np = netdev_priv(dev);
1139 	void __iomem *ioaddr = np->base;
1140 	struct sk_buff *skb;
1141 	int i;
1142 
1143 	/* Reset tx logic, TxListPtr will be cleaned */
1144 	iowrite16 (TxDisable, ioaddr + MACCtrl1);
1145 	sundance_reset(dev, (NetworkReset|FIFOReset|DMAReset|TxReset) << 16);
1146 
1147 	/* free all tx skbuff */
1148 	for (i = 0; i < TX_RING_SIZE; i++) {
1149 		np->tx_ring[i].next_desc = 0;
1150 
1151 		skb = np->tx_skbuff[i];
1152 		if (skb) {
1153 			dma_unmap_single(&np->pci_dev->dev,
1154 				le32_to_cpu(np->tx_ring[i].frag.addr),
1155 				skb->len, DMA_TO_DEVICE);
1156 			dev_kfree_skb_any(skb);
1157 			np->tx_skbuff[i] = NULL;
1158 			dev->stats.tx_dropped++;
1159 		}
1160 	}
1161 	np->cur_tx = np->dirty_tx = 0;
1162 	np->cur_task = 0;
1163 
1164 	np->last_tx = NULL;
1165 	iowrite8(127, ioaddr + TxDMAPollPeriod);
1166 
1167 	iowrite16 (StatsEnable | RxEnable | TxEnable, ioaddr + MACCtrl1);
1168 	return 0;
1169 }
1170 
1171 /* The interrupt handler cleans up after the Tx thread,
1172    and schedule a Rx thread work */
intr_handler(int irq,void * dev_instance)1173 static irqreturn_t intr_handler(int irq, void *dev_instance)
1174 {
1175 	struct net_device *dev = (struct net_device *)dev_instance;
1176 	struct netdev_private *np = netdev_priv(dev);
1177 	void __iomem *ioaddr = np->base;
1178 	int hw_frame_id;
1179 	int tx_cnt;
1180 	int tx_status;
1181 	int handled = 0;
1182 	int i;
1183 
1184 	do {
1185 		int intr_status = ioread16(ioaddr + IntrStatus);
1186 		iowrite16(intr_status, ioaddr + IntrStatus);
1187 
1188 		if (netif_msg_intr(np))
1189 			printk(KERN_DEBUG "%s: Interrupt, status %4.4x.\n",
1190 				   dev->name, intr_status);
1191 
1192 		if (!(intr_status & DEFAULT_INTR))
1193 			break;
1194 
1195 		handled = 1;
1196 
1197 		if (intr_status & (IntrRxDMADone)) {
1198 			iowrite16(DEFAULT_INTR & ~(IntrRxDone|IntrRxDMADone),
1199 					ioaddr + IntrEnable);
1200 			if (np->budget < 0)
1201 				np->budget = RX_BUDGET;
1202 			tasklet_schedule(&np->rx_tasklet);
1203 		}
1204 		if (intr_status & (IntrTxDone | IntrDrvRqst)) {
1205 			tx_status = ioread16 (ioaddr + TxStatus);
1206 			for (tx_cnt=32; tx_status & 0x80; --tx_cnt) {
1207 				if (netif_msg_tx_done(np))
1208 					printk
1209 					    ("%s: Transmit status is %2.2x.\n",
1210 				     	dev->name, tx_status);
1211 				if (tx_status & 0x1e) {
1212 					if (netif_msg_tx_err(np))
1213 						printk("%s: Transmit error status %4.4x.\n",
1214 							   dev->name, tx_status);
1215 					dev->stats.tx_errors++;
1216 					if (tx_status & 0x10)
1217 						dev->stats.tx_fifo_errors++;
1218 					if (tx_status & 0x08)
1219 						dev->stats.collisions++;
1220 					if (tx_status & 0x04)
1221 						dev->stats.tx_fifo_errors++;
1222 					if (tx_status & 0x02)
1223 						dev->stats.tx_window_errors++;
1224 
1225 					/*
1226 					** This reset has been verified on
1227 					** DFE-580TX boards ! phdm@macqel.be.
1228 					*/
1229 					if (tx_status & 0x10) {	/* TxUnderrun */
1230 						/* Restart Tx FIFO and transmitter */
1231 						sundance_reset(dev, (NetworkReset|FIFOReset|TxReset) << 16);
1232 						/* No need to reset the Tx pointer here */
1233 					}
1234 					/* Restart the Tx. Need to make sure tx enabled */
1235 					i = 10;
1236 					do {
1237 						iowrite16(ioread16(ioaddr + MACCtrl1) | TxEnable, ioaddr + MACCtrl1);
1238 						if (ioread16(ioaddr + MACCtrl1) & TxEnabled)
1239 							break;
1240 						mdelay(1);
1241 					} while (--i);
1242 				}
1243 				/* Yup, this is a documentation bug.  It cost me *hours*. */
1244 				iowrite16 (0, ioaddr + TxStatus);
1245 				if (tx_cnt < 0) {
1246 					iowrite32(5000, ioaddr + DownCounter);
1247 					break;
1248 				}
1249 				tx_status = ioread16 (ioaddr + TxStatus);
1250 			}
1251 			hw_frame_id = (tx_status >> 8) & 0xff;
1252 		} else 	{
1253 			hw_frame_id = ioread8(ioaddr + TxFrameId);
1254 		}
1255 
1256 		if (np->pci_dev->revision >= 0x14) {
1257 			spin_lock(&np->lock);
1258 			for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1259 				int entry = np->dirty_tx % TX_RING_SIZE;
1260 				struct sk_buff *skb;
1261 				int sw_frame_id;
1262 				sw_frame_id = (le32_to_cpu(
1263 					np->tx_ring[entry].status) >> 2) & 0xff;
1264 				if (sw_frame_id == hw_frame_id &&
1265 					!(le32_to_cpu(np->tx_ring[entry].status)
1266 					& 0x00010000))
1267 						break;
1268 				if (sw_frame_id == (hw_frame_id + 1) %
1269 					TX_RING_SIZE)
1270 						break;
1271 				skb = np->tx_skbuff[entry];
1272 				/* Free the original skb. */
1273 				dma_unmap_single(&np->pci_dev->dev,
1274 					le32_to_cpu(np->tx_ring[entry].frag.addr),
1275 					skb->len, DMA_TO_DEVICE);
1276 				dev_consume_skb_irq(np->tx_skbuff[entry]);
1277 				np->tx_skbuff[entry] = NULL;
1278 				np->tx_ring[entry].frag.addr = 0;
1279 				np->tx_ring[entry].frag.length = 0;
1280 			}
1281 			spin_unlock(&np->lock);
1282 		} else {
1283 			spin_lock(&np->lock);
1284 			for (; np->cur_tx - np->dirty_tx > 0; np->dirty_tx++) {
1285 				int entry = np->dirty_tx % TX_RING_SIZE;
1286 				struct sk_buff *skb;
1287 				if (!(le32_to_cpu(np->tx_ring[entry].status)
1288 							& 0x00010000))
1289 					break;
1290 				skb = np->tx_skbuff[entry];
1291 				/* Free the original skb. */
1292 				dma_unmap_single(&np->pci_dev->dev,
1293 					le32_to_cpu(np->tx_ring[entry].frag.addr),
1294 					skb->len, DMA_TO_DEVICE);
1295 				dev_consume_skb_irq(np->tx_skbuff[entry]);
1296 				np->tx_skbuff[entry] = NULL;
1297 				np->tx_ring[entry].frag.addr = 0;
1298 				np->tx_ring[entry].frag.length = 0;
1299 			}
1300 			spin_unlock(&np->lock);
1301 		}
1302 
1303 		if (netif_queue_stopped(dev) &&
1304 			np->cur_tx - np->dirty_tx < TX_QUEUE_LEN - 4) {
1305 			/* The ring is no longer full, clear busy flag. */
1306 			netif_wake_queue (dev);
1307 		}
1308 		/* Abnormal error summary/uncommon events handlers. */
1309 		if (intr_status & (IntrPCIErr | LinkChange | StatsMax))
1310 			netdev_error(dev, intr_status);
1311 	} while (0);
1312 	if (netif_msg_intr(np))
1313 		printk(KERN_DEBUG "%s: exiting interrupt, status=%#4.4x.\n",
1314 			   dev->name, ioread16(ioaddr + IntrStatus));
1315 	return IRQ_RETVAL(handled);
1316 }
1317 
rx_poll(struct tasklet_struct * t)1318 static void rx_poll(struct tasklet_struct *t)
1319 {
1320 	struct netdev_private *np = from_tasklet(np, t, rx_tasklet);
1321 	struct net_device *dev = np->ndev;
1322 	int entry = np->cur_rx % RX_RING_SIZE;
1323 	int boguscnt = np->budget;
1324 	void __iomem *ioaddr = np->base;
1325 	int received = 0;
1326 
1327 	/* If EOP is set on the next entry, it's a new packet. Send it up. */
1328 	while (1) {
1329 		struct netdev_desc *desc = &(np->rx_ring[entry]);
1330 		u32 frame_status = le32_to_cpu(desc->status);
1331 		int pkt_len;
1332 
1333 		if (--boguscnt < 0) {
1334 			goto not_done;
1335 		}
1336 		if (!(frame_status & DescOwn))
1337 			break;
1338 		pkt_len = frame_status & 0x1fff;	/* Chip omits the CRC. */
1339 		if (netif_msg_rx_status(np))
1340 			printk(KERN_DEBUG "  netdev_rx() status was %8.8x.\n",
1341 				   frame_status);
1342 		if (frame_status & 0x001f4000) {
1343 			/* There was a error. */
1344 			if (netif_msg_rx_err(np))
1345 				printk(KERN_DEBUG "  netdev_rx() Rx error was %8.8x.\n",
1346 					   frame_status);
1347 			dev->stats.rx_errors++;
1348 			if (frame_status & 0x00100000)
1349 				dev->stats.rx_length_errors++;
1350 			if (frame_status & 0x00010000)
1351 				dev->stats.rx_fifo_errors++;
1352 			if (frame_status & 0x00060000)
1353 				dev->stats.rx_frame_errors++;
1354 			if (frame_status & 0x00080000)
1355 				dev->stats.rx_crc_errors++;
1356 			if (frame_status & 0x00100000) {
1357 				printk(KERN_WARNING "%s: Oversized Ethernet frame,"
1358 					   " status %8.8x.\n",
1359 					   dev->name, frame_status);
1360 			}
1361 		} else {
1362 			struct sk_buff *skb;
1363 #ifndef final_version
1364 			if (netif_msg_rx_status(np))
1365 				printk(KERN_DEBUG "  netdev_rx() normal Rx pkt length %d"
1366 					   ", bogus_cnt %d.\n",
1367 					   pkt_len, boguscnt);
1368 #endif
1369 			/* Check if the packet is long enough to accept without copying
1370 			   to a minimally-sized skbuff. */
1371 			if (pkt_len < rx_copybreak &&
1372 			    (skb = netdev_alloc_skb(dev, pkt_len + 2)) != NULL) {
1373 				skb_reserve(skb, 2);	/* 16 byte align the IP header */
1374 				dma_sync_single_for_cpu(&np->pci_dev->dev,
1375 						le32_to_cpu(desc->frag.addr),
1376 						np->rx_buf_sz, DMA_FROM_DEVICE);
1377 				skb_copy_to_linear_data(skb, np->rx_skbuff[entry]->data, pkt_len);
1378 				dma_sync_single_for_device(&np->pci_dev->dev,
1379 						le32_to_cpu(desc->frag.addr),
1380 						np->rx_buf_sz, DMA_FROM_DEVICE);
1381 				skb_put(skb, pkt_len);
1382 			} else {
1383 				dma_unmap_single(&np->pci_dev->dev,
1384 					le32_to_cpu(desc->frag.addr),
1385 					np->rx_buf_sz, DMA_FROM_DEVICE);
1386 				skb_put(skb = np->rx_skbuff[entry], pkt_len);
1387 				np->rx_skbuff[entry] = NULL;
1388 			}
1389 			skb->protocol = eth_type_trans(skb, dev);
1390 			/* Note: checksum -> skb->ip_summed = CHECKSUM_UNNECESSARY; */
1391 			netif_rx(skb);
1392 		}
1393 		entry = (entry + 1) % RX_RING_SIZE;
1394 		received++;
1395 	}
1396 	np->cur_rx = entry;
1397 	refill_rx (dev);
1398 	np->budget -= received;
1399 	iowrite16(DEFAULT_INTR, ioaddr + IntrEnable);
1400 	return;
1401 
1402 not_done:
1403 	np->cur_rx = entry;
1404 	refill_rx (dev);
1405 	if (!received)
1406 		received = 1;
1407 	np->budget -= received;
1408 	if (np->budget <= 0)
1409 		np->budget = RX_BUDGET;
1410 	tasklet_schedule(&np->rx_tasklet);
1411 }
1412 
refill_rx(struct net_device * dev)1413 static void refill_rx (struct net_device *dev)
1414 {
1415 	struct netdev_private *np = netdev_priv(dev);
1416 	int entry;
1417 
1418 	/* Refill the Rx ring buffers. */
1419 	for (;(np->cur_rx - np->dirty_rx + RX_RING_SIZE) % RX_RING_SIZE > 0;
1420 		np->dirty_rx = (np->dirty_rx + 1) % RX_RING_SIZE) {
1421 		struct sk_buff *skb;
1422 		entry = np->dirty_rx % RX_RING_SIZE;
1423 		if (np->rx_skbuff[entry] == NULL) {
1424 			skb = netdev_alloc_skb(dev, np->rx_buf_sz + 2);
1425 			np->rx_skbuff[entry] = skb;
1426 			if (skb == NULL)
1427 				break;		/* Better luck next round. */
1428 			skb_reserve(skb, 2);	/* Align IP on 16 byte boundaries */
1429 			np->rx_ring[entry].frag.addr = cpu_to_le32(
1430 				dma_map_single(&np->pci_dev->dev, skb->data,
1431 					np->rx_buf_sz, DMA_FROM_DEVICE));
1432 			if (dma_mapping_error(&np->pci_dev->dev,
1433 				    np->rx_ring[entry].frag.addr)) {
1434 			    dev_kfree_skb_irq(skb);
1435 			    np->rx_skbuff[entry] = NULL;
1436 			    break;
1437 			}
1438 		}
1439 		/* Perhaps we need not reset this field. */
1440 		np->rx_ring[entry].frag.length =
1441 			cpu_to_le32(np->rx_buf_sz | LastFrag);
1442 		np->rx_ring[entry].status = 0;
1443 	}
1444 }
netdev_error(struct net_device * dev,int intr_status)1445 static void netdev_error(struct net_device *dev, int intr_status)
1446 {
1447 	struct netdev_private *np = netdev_priv(dev);
1448 	void __iomem *ioaddr = np->base;
1449 	u16 mii_ctl, mii_advertise, mii_lpa;
1450 	int speed;
1451 
1452 	if (intr_status & LinkChange) {
1453 		if (mdio_wait_link(dev, 10) == 0) {
1454 			printk(KERN_INFO "%s: Link up\n", dev->name);
1455 			if (np->an_enable) {
1456 				mii_advertise = mdio_read(dev, np->phys[0],
1457 							   MII_ADVERTISE);
1458 				mii_lpa = mdio_read(dev, np->phys[0], MII_LPA);
1459 				mii_advertise &= mii_lpa;
1460 				printk(KERN_INFO "%s: Link changed: ",
1461 					dev->name);
1462 				if (mii_advertise & ADVERTISE_100FULL) {
1463 					np->speed = 100;
1464 					printk("100Mbps, full duplex\n");
1465 				} else if (mii_advertise & ADVERTISE_100HALF) {
1466 					np->speed = 100;
1467 					printk("100Mbps, half duplex\n");
1468 				} else if (mii_advertise & ADVERTISE_10FULL) {
1469 					np->speed = 10;
1470 					printk("10Mbps, full duplex\n");
1471 				} else if (mii_advertise & ADVERTISE_10HALF) {
1472 					np->speed = 10;
1473 					printk("10Mbps, half duplex\n");
1474 				} else
1475 					printk("\n");
1476 
1477 			} else {
1478 				mii_ctl = mdio_read(dev, np->phys[0], MII_BMCR);
1479 				speed = (mii_ctl & BMCR_SPEED100) ? 100 : 10;
1480 				np->speed = speed;
1481 				printk(KERN_INFO "%s: Link changed: %dMbps ,",
1482 					dev->name, speed);
1483 				printk("%s duplex.\n",
1484 					(mii_ctl & BMCR_FULLDPLX) ?
1485 						"full" : "half");
1486 			}
1487 			check_duplex(dev);
1488 			if (np->flowctrl && np->mii_if.full_duplex) {
1489 				iowrite16(ioread16(ioaddr + MulticastFilter1+2) | 0x0200,
1490 					ioaddr + MulticastFilter1+2);
1491 				iowrite16(ioread16(ioaddr + MACCtrl0) | EnbFlowCtrl,
1492 					ioaddr + MACCtrl0);
1493 			}
1494 			netif_carrier_on(dev);
1495 		} else {
1496 			printk(KERN_INFO "%s: Link down\n", dev->name);
1497 			netif_carrier_off(dev);
1498 		}
1499 	}
1500 	if (intr_status & StatsMax) {
1501 		get_stats(dev);
1502 	}
1503 	if (intr_status & IntrPCIErr) {
1504 		printk(KERN_ERR "%s: Something Wicked happened! %4.4x.\n",
1505 			   dev->name, intr_status);
1506 		/* We must do a global reset of DMA to continue. */
1507 	}
1508 }
1509 
get_stats(struct net_device * dev)1510 static struct net_device_stats *get_stats(struct net_device *dev)
1511 {
1512 	struct netdev_private *np = netdev_priv(dev);
1513 	void __iomem *ioaddr = np->base;
1514 	unsigned long flags;
1515 	u8 late_coll, single_coll, mult_coll;
1516 
1517 	spin_lock_irqsave(&np->statlock, flags);
1518 	/* The chip only need report frame silently dropped. */
1519 	dev->stats.rx_missed_errors	+= ioread8(ioaddr + RxMissed);
1520 	dev->stats.tx_packets += ioread16(ioaddr + TxFramesOK);
1521 	dev->stats.rx_packets += ioread16(ioaddr + RxFramesOK);
1522 	dev->stats.tx_carrier_errors += ioread8(ioaddr + StatsCarrierError);
1523 
1524 	mult_coll = ioread8(ioaddr + StatsMultiColl);
1525 	np->xstats.tx_multiple_collisions += mult_coll;
1526 	single_coll = ioread8(ioaddr + StatsOneColl);
1527 	np->xstats.tx_single_collisions += single_coll;
1528 	late_coll = ioread8(ioaddr + StatsLateColl);
1529 	np->xstats.tx_late_collisions += late_coll;
1530 	dev->stats.collisions += mult_coll
1531 		+ single_coll
1532 		+ late_coll;
1533 
1534 	np->xstats.tx_deferred += ioread8(ioaddr + StatsTxDefer);
1535 	np->xstats.tx_deferred_excessive += ioread8(ioaddr + StatsTxXSDefer);
1536 	np->xstats.tx_aborted += ioread8(ioaddr + StatsTxAbort);
1537 	np->xstats.tx_bcasts += ioread8(ioaddr + StatsBcastTx);
1538 	np->xstats.rx_bcasts += ioread8(ioaddr + StatsBcastRx);
1539 	np->xstats.tx_mcasts += ioread8(ioaddr + StatsMcastTx);
1540 	np->xstats.rx_mcasts += ioread8(ioaddr + StatsMcastRx);
1541 
1542 	dev->stats.tx_bytes += ioread16(ioaddr + TxOctetsLow);
1543 	dev->stats.tx_bytes += ioread16(ioaddr + TxOctetsHigh) << 16;
1544 	dev->stats.rx_bytes += ioread16(ioaddr + RxOctetsLow);
1545 	dev->stats.rx_bytes += ioread16(ioaddr + RxOctetsHigh) << 16;
1546 
1547 	spin_unlock_irqrestore(&np->statlock, flags);
1548 
1549 	return &dev->stats;
1550 }
1551 
set_rx_mode(struct net_device * dev)1552 static void set_rx_mode(struct net_device *dev)
1553 {
1554 	struct netdev_private *np = netdev_priv(dev);
1555 	void __iomem *ioaddr = np->base;
1556 	u16 mc_filter[4];			/* Multicast hash filter */
1557 	u32 rx_mode;
1558 	int i;
1559 
1560 	if (dev->flags & IFF_PROMISC) {			/* Set promiscuous. */
1561 		memset(mc_filter, 0xff, sizeof(mc_filter));
1562 		rx_mode = AcceptBroadcast | AcceptMulticast | AcceptAll | AcceptMyPhys;
1563 	} else if ((netdev_mc_count(dev) > multicast_filter_limit) ||
1564 		   (dev->flags & IFF_ALLMULTI)) {
1565 		/* Too many to match, or accept all multicasts. */
1566 		memset(mc_filter, 0xff, sizeof(mc_filter));
1567 		rx_mode = AcceptBroadcast | AcceptMulticast | AcceptMyPhys;
1568 	} else if (!netdev_mc_empty(dev)) {
1569 		struct netdev_hw_addr *ha;
1570 		int bit;
1571 		int index;
1572 		int crc;
1573 		memset (mc_filter, 0, sizeof (mc_filter));
1574 		netdev_for_each_mc_addr(ha, dev) {
1575 			crc = ether_crc_le(ETH_ALEN, ha->addr);
1576 			for (index=0, bit=0; bit < 6; bit++, crc <<= 1)
1577 				if (crc & 0x80000000) index |= 1 << bit;
1578 			mc_filter[index/16] |= (1 << (index % 16));
1579 		}
1580 		rx_mode = AcceptBroadcast | AcceptMultiHash | AcceptMyPhys;
1581 	} else {
1582 		iowrite8(AcceptBroadcast | AcceptMyPhys, ioaddr + RxMode);
1583 		return;
1584 	}
1585 	if (np->mii_if.full_duplex && np->flowctrl)
1586 		mc_filter[3] |= 0x0200;
1587 
1588 	for (i = 0; i < 4; i++)
1589 		iowrite16(mc_filter[i], ioaddr + MulticastFilter0 + i*2);
1590 	iowrite8(rx_mode, ioaddr + RxMode);
1591 }
1592 
__set_mac_addr(struct net_device * dev)1593 static int __set_mac_addr(struct net_device *dev)
1594 {
1595 	struct netdev_private *np = netdev_priv(dev);
1596 	u16 addr16;
1597 
1598 	addr16 = (dev->dev_addr[0] | (dev->dev_addr[1] << 8));
1599 	iowrite16(addr16, np->base + StationAddr);
1600 	addr16 = (dev->dev_addr[2] | (dev->dev_addr[3] << 8));
1601 	iowrite16(addr16, np->base + StationAddr+2);
1602 	addr16 = (dev->dev_addr[4] | (dev->dev_addr[5] << 8));
1603 	iowrite16(addr16, np->base + StationAddr+4);
1604 	return 0;
1605 }
1606 
1607 /* Invoked with rtnl_lock held */
sundance_set_mac_addr(struct net_device * dev,void * data)1608 static int sundance_set_mac_addr(struct net_device *dev, void *data)
1609 {
1610 	const struct sockaddr *addr = data;
1611 
1612 	if (!is_valid_ether_addr(addr->sa_data))
1613 		return -EADDRNOTAVAIL;
1614 	eth_hw_addr_set(dev, addr->sa_data);
1615 	__set_mac_addr(dev);
1616 
1617 	return 0;
1618 }
1619 
1620 static const struct {
1621 	const char name[ETH_GSTRING_LEN];
1622 } sundance_stats[] = {
1623 	{ "tx_multiple_collisions" },
1624 	{ "tx_single_collisions" },
1625 	{ "tx_late_collisions" },
1626 	{ "tx_deferred" },
1627 	{ "tx_deferred_excessive" },
1628 	{ "tx_aborted" },
1629 	{ "tx_bcasts" },
1630 	{ "rx_bcasts" },
1631 	{ "tx_mcasts" },
1632 	{ "rx_mcasts" },
1633 };
1634 
check_if_running(struct net_device * dev)1635 static int check_if_running(struct net_device *dev)
1636 {
1637 	if (!netif_running(dev))
1638 		return -EINVAL;
1639 	return 0;
1640 }
1641 
get_drvinfo(struct net_device * dev,struct ethtool_drvinfo * info)1642 static void get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
1643 {
1644 	struct netdev_private *np = netdev_priv(dev);
1645 	strscpy(info->driver, DRV_NAME, sizeof(info->driver));
1646 	strscpy(info->bus_info, pci_name(np->pci_dev), sizeof(info->bus_info));
1647 }
1648 
get_link_ksettings(struct net_device * dev,struct ethtool_link_ksettings * cmd)1649 static int get_link_ksettings(struct net_device *dev,
1650 			      struct ethtool_link_ksettings *cmd)
1651 {
1652 	struct netdev_private *np = netdev_priv(dev);
1653 	spin_lock_irq(&np->lock);
1654 	mii_ethtool_get_link_ksettings(&np->mii_if, cmd);
1655 	spin_unlock_irq(&np->lock);
1656 	return 0;
1657 }
1658 
set_link_ksettings(struct net_device * dev,const struct ethtool_link_ksettings * cmd)1659 static int set_link_ksettings(struct net_device *dev,
1660 			      const struct ethtool_link_ksettings *cmd)
1661 {
1662 	struct netdev_private *np = netdev_priv(dev);
1663 	int res;
1664 	spin_lock_irq(&np->lock);
1665 	res = mii_ethtool_set_link_ksettings(&np->mii_if, cmd);
1666 	spin_unlock_irq(&np->lock);
1667 	return res;
1668 }
1669 
nway_reset(struct net_device * dev)1670 static int nway_reset(struct net_device *dev)
1671 {
1672 	struct netdev_private *np = netdev_priv(dev);
1673 	return mii_nway_restart(&np->mii_if);
1674 }
1675 
get_link(struct net_device * dev)1676 static u32 get_link(struct net_device *dev)
1677 {
1678 	struct netdev_private *np = netdev_priv(dev);
1679 	return mii_link_ok(&np->mii_if);
1680 }
1681 
get_msglevel(struct net_device * dev)1682 static u32 get_msglevel(struct net_device *dev)
1683 {
1684 	struct netdev_private *np = netdev_priv(dev);
1685 	return np->msg_enable;
1686 }
1687 
set_msglevel(struct net_device * dev,u32 val)1688 static void set_msglevel(struct net_device *dev, u32 val)
1689 {
1690 	struct netdev_private *np = netdev_priv(dev);
1691 	np->msg_enable = val;
1692 }
1693 
get_strings(struct net_device * dev,u32 stringset,u8 * data)1694 static void get_strings(struct net_device *dev, u32 stringset,
1695 		u8 *data)
1696 {
1697 	if (stringset == ETH_SS_STATS)
1698 		memcpy(data, sundance_stats, sizeof(sundance_stats));
1699 }
1700 
get_sset_count(struct net_device * dev,int sset)1701 static int get_sset_count(struct net_device *dev, int sset)
1702 {
1703 	switch (sset) {
1704 	case ETH_SS_STATS:
1705 		return ARRAY_SIZE(sundance_stats);
1706 	default:
1707 		return -EOPNOTSUPP;
1708 	}
1709 }
1710 
get_ethtool_stats(struct net_device * dev,struct ethtool_stats * stats,u64 * data)1711 static void get_ethtool_stats(struct net_device *dev,
1712 		struct ethtool_stats *stats, u64 *data)
1713 {
1714 	struct netdev_private *np = netdev_priv(dev);
1715 	int i = 0;
1716 
1717 	get_stats(dev);
1718 	data[i++] = np->xstats.tx_multiple_collisions;
1719 	data[i++] = np->xstats.tx_single_collisions;
1720 	data[i++] = np->xstats.tx_late_collisions;
1721 	data[i++] = np->xstats.tx_deferred;
1722 	data[i++] = np->xstats.tx_deferred_excessive;
1723 	data[i++] = np->xstats.tx_aborted;
1724 	data[i++] = np->xstats.tx_bcasts;
1725 	data[i++] = np->xstats.rx_bcasts;
1726 	data[i++] = np->xstats.tx_mcasts;
1727 	data[i++] = np->xstats.rx_mcasts;
1728 }
1729 
1730 #ifdef CONFIG_PM
1731 
sundance_get_wol(struct net_device * dev,struct ethtool_wolinfo * wol)1732 static void sundance_get_wol(struct net_device *dev,
1733 		struct ethtool_wolinfo *wol)
1734 {
1735 	struct netdev_private *np = netdev_priv(dev);
1736 	void __iomem *ioaddr = np->base;
1737 	u8 wol_bits;
1738 
1739 	wol->wolopts = 0;
1740 
1741 	wol->supported = (WAKE_PHY | WAKE_MAGIC);
1742 	if (!np->wol_enabled)
1743 		return;
1744 
1745 	wol_bits = ioread8(ioaddr + WakeEvent);
1746 	if (wol_bits & MagicPktEnable)
1747 		wol->wolopts |= WAKE_MAGIC;
1748 	if (wol_bits & LinkEventEnable)
1749 		wol->wolopts |= WAKE_PHY;
1750 }
1751 
sundance_set_wol(struct net_device * dev,struct ethtool_wolinfo * wol)1752 static int sundance_set_wol(struct net_device *dev,
1753 	struct ethtool_wolinfo *wol)
1754 {
1755 	struct netdev_private *np = netdev_priv(dev);
1756 	void __iomem *ioaddr = np->base;
1757 	u8 wol_bits;
1758 
1759 	if (!device_can_wakeup(&np->pci_dev->dev))
1760 		return -EOPNOTSUPP;
1761 
1762 	np->wol_enabled = !!(wol->wolopts);
1763 	wol_bits = ioread8(ioaddr + WakeEvent);
1764 	wol_bits &= ~(WakePktEnable | MagicPktEnable |
1765 			LinkEventEnable | WolEnable);
1766 
1767 	if (np->wol_enabled) {
1768 		if (wol->wolopts & WAKE_MAGIC)
1769 			wol_bits |= (MagicPktEnable | WolEnable);
1770 		if (wol->wolopts & WAKE_PHY)
1771 			wol_bits |= (LinkEventEnable | WolEnable);
1772 	}
1773 	iowrite8(wol_bits, ioaddr + WakeEvent);
1774 
1775 	device_set_wakeup_enable(&np->pci_dev->dev, np->wol_enabled);
1776 
1777 	return 0;
1778 }
1779 #else
1780 #define sundance_get_wol NULL
1781 #define sundance_set_wol NULL
1782 #endif /* CONFIG_PM */
1783 
1784 static const struct ethtool_ops ethtool_ops = {
1785 	.begin = check_if_running,
1786 	.get_drvinfo = get_drvinfo,
1787 	.nway_reset = nway_reset,
1788 	.get_link = get_link,
1789 	.get_wol = sundance_get_wol,
1790 	.set_wol = sundance_set_wol,
1791 	.get_msglevel = get_msglevel,
1792 	.set_msglevel = set_msglevel,
1793 	.get_strings = get_strings,
1794 	.get_sset_count = get_sset_count,
1795 	.get_ethtool_stats = get_ethtool_stats,
1796 	.get_link_ksettings = get_link_ksettings,
1797 	.set_link_ksettings = set_link_ksettings,
1798 };
1799 
netdev_ioctl(struct net_device * dev,struct ifreq * rq,int cmd)1800 static int netdev_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
1801 {
1802 	struct netdev_private *np = netdev_priv(dev);
1803 	int rc;
1804 
1805 	if (!netif_running(dev))
1806 		return -EINVAL;
1807 
1808 	spin_lock_irq(&np->lock);
1809 	rc = generic_mii_ioctl(&np->mii_if, if_mii(rq), cmd, NULL);
1810 	spin_unlock_irq(&np->lock);
1811 
1812 	return rc;
1813 }
1814 
netdev_close(struct net_device * dev)1815 static int netdev_close(struct net_device *dev)
1816 {
1817 	struct netdev_private *np = netdev_priv(dev);
1818 	void __iomem *ioaddr = np->base;
1819 	struct sk_buff *skb;
1820 	int i;
1821 
1822 	/* Wait and kill tasklet */
1823 	tasklet_kill(&np->rx_tasklet);
1824 	tasklet_kill(&np->tx_tasklet);
1825 	np->cur_tx = 0;
1826 	np->dirty_tx = 0;
1827 	np->cur_task = 0;
1828 	np->last_tx = NULL;
1829 
1830 	netif_stop_queue(dev);
1831 
1832 	if (netif_msg_ifdown(np)) {
1833 		printk(KERN_DEBUG "%s: Shutting down ethercard, status was Tx %2.2x "
1834 			   "Rx %4.4x Int %2.2x.\n",
1835 			   dev->name, ioread8(ioaddr + TxStatus),
1836 			   ioread32(ioaddr + RxStatus), ioread16(ioaddr + IntrStatus));
1837 		printk(KERN_DEBUG "%s: Queue pointers were Tx %d / %d,  Rx %d / %d.\n",
1838 			   dev->name, np->cur_tx, np->dirty_tx, np->cur_rx, np->dirty_rx);
1839 	}
1840 
1841 	/* Disable interrupts by clearing the interrupt mask. */
1842 	iowrite16(0x0000, ioaddr + IntrEnable);
1843 
1844 	/* Disable Rx and Tx DMA for safely release resource */
1845 	iowrite32(0x500, ioaddr + DMACtrl);
1846 
1847 	/* Stop the chip's Tx and Rx processes. */
1848 	iowrite16(TxDisable | RxDisable | StatsDisable, ioaddr + MACCtrl1);
1849 
1850 	for (i = 2000; i > 0; i--) {
1851 		if ((ioread32(ioaddr + DMACtrl) & 0xc000) == 0)
1852 			break;
1853 		mdelay(1);
1854 	}
1855 
1856 	iowrite16(GlobalReset | DMAReset | FIFOReset | NetworkReset,
1857 			ioaddr + ASIC_HI_WORD(ASICCtrl));
1858 
1859 	for (i = 2000; i > 0; i--) {
1860 		if ((ioread16(ioaddr + ASIC_HI_WORD(ASICCtrl)) & ResetBusy) == 0)
1861 			break;
1862 		mdelay(1);
1863 	}
1864 
1865 #ifdef __i386__
1866 	if (netif_msg_hw(np)) {
1867 		printk(KERN_DEBUG "  Tx ring at %8.8x:\n",
1868 			   (int)(np->tx_ring_dma));
1869 		for (i = 0; i < TX_RING_SIZE; i++)
1870 			printk(KERN_DEBUG " #%d desc. %4.4x %8.8x %8.8x.\n",
1871 				   i, np->tx_ring[i].status, np->tx_ring[i].frag.addr,
1872 				   np->tx_ring[i].frag.length);
1873 		printk(KERN_DEBUG "  Rx ring %8.8x:\n",
1874 			   (int)(np->rx_ring_dma));
1875 		for (i = 0; i < /*RX_RING_SIZE*/4 ; i++) {
1876 			printk(KERN_DEBUG " #%d desc. %4.4x %4.4x %8.8x\n",
1877 				   i, np->rx_ring[i].status, np->rx_ring[i].frag.addr,
1878 				   np->rx_ring[i].frag.length);
1879 		}
1880 	}
1881 #endif /* __i386__ debugging only */
1882 
1883 	free_irq(np->pci_dev->irq, dev);
1884 
1885 	del_timer_sync(&np->timer);
1886 
1887 	/* Free all the skbuffs in the Rx queue. */
1888 	for (i = 0; i < RX_RING_SIZE; i++) {
1889 		np->rx_ring[i].status = 0;
1890 		skb = np->rx_skbuff[i];
1891 		if (skb) {
1892 			dma_unmap_single(&np->pci_dev->dev,
1893 				le32_to_cpu(np->rx_ring[i].frag.addr),
1894 				np->rx_buf_sz, DMA_FROM_DEVICE);
1895 			dev_kfree_skb(skb);
1896 			np->rx_skbuff[i] = NULL;
1897 		}
1898 		np->rx_ring[i].frag.addr = cpu_to_le32(0xBADF00D0); /* poison */
1899 	}
1900 	for (i = 0; i < TX_RING_SIZE; i++) {
1901 		np->tx_ring[i].next_desc = 0;
1902 		skb = np->tx_skbuff[i];
1903 		if (skb) {
1904 			dma_unmap_single(&np->pci_dev->dev,
1905 				le32_to_cpu(np->tx_ring[i].frag.addr),
1906 				skb->len, DMA_TO_DEVICE);
1907 			dev_kfree_skb(skb);
1908 			np->tx_skbuff[i] = NULL;
1909 		}
1910 	}
1911 
1912 	return 0;
1913 }
1914 
sundance_remove1(struct pci_dev * pdev)1915 static void sundance_remove1(struct pci_dev *pdev)
1916 {
1917 	struct net_device *dev = pci_get_drvdata(pdev);
1918 
1919 	if (dev) {
1920 	    struct netdev_private *np = netdev_priv(dev);
1921 	    unregister_netdev(dev);
1922 	    dma_free_coherent(&pdev->dev, RX_TOTAL_SIZE,
1923 		    np->rx_ring, np->rx_ring_dma);
1924 	    dma_free_coherent(&pdev->dev, TX_TOTAL_SIZE,
1925 		    np->tx_ring, np->tx_ring_dma);
1926 	    pci_iounmap(pdev, np->base);
1927 	    pci_release_regions(pdev);
1928 	    free_netdev(dev);
1929 	}
1930 }
1931 
sundance_suspend(struct device * dev_d)1932 static int __maybe_unused sundance_suspend(struct device *dev_d)
1933 {
1934 	struct net_device *dev = dev_get_drvdata(dev_d);
1935 	struct netdev_private *np = netdev_priv(dev);
1936 	void __iomem *ioaddr = np->base;
1937 
1938 	if (!netif_running(dev))
1939 		return 0;
1940 
1941 	netdev_close(dev);
1942 	netif_device_detach(dev);
1943 
1944 	if (np->wol_enabled) {
1945 		iowrite8(AcceptBroadcast | AcceptMyPhys, ioaddr + RxMode);
1946 		iowrite16(RxEnable, ioaddr + MACCtrl1);
1947 	}
1948 
1949 	device_set_wakeup_enable(dev_d, np->wol_enabled);
1950 
1951 	return 0;
1952 }
1953 
sundance_resume(struct device * dev_d)1954 static int __maybe_unused sundance_resume(struct device *dev_d)
1955 {
1956 	struct net_device *dev = dev_get_drvdata(dev_d);
1957 	int err = 0;
1958 
1959 	if (!netif_running(dev))
1960 		return 0;
1961 
1962 	err = netdev_open(dev);
1963 	if (err) {
1964 		printk(KERN_ERR "%s: Can't resume interface!\n",
1965 				dev->name);
1966 		goto out;
1967 	}
1968 
1969 	netif_device_attach(dev);
1970 
1971 out:
1972 	return err;
1973 }
1974 
1975 static SIMPLE_DEV_PM_OPS(sundance_pm_ops, sundance_suspend, sundance_resume);
1976 
1977 static struct pci_driver sundance_driver = {
1978 	.name		= DRV_NAME,
1979 	.id_table	= sundance_pci_tbl,
1980 	.probe		= sundance_probe1,
1981 	.remove		= sundance_remove1,
1982 	.driver.pm	= &sundance_pm_ops,
1983 };
1984 
1985 module_pci_driver(sundance_driver);
1986