mv643xx_eth.c 71.2 KB
Newer Older
L
Linus Torvalds 已提交
1
/*
2
 * Driver for Marvell Discovery (MV643XX) and Marvell Orion ethernet ports
L
Linus Torvalds 已提交
3 4 5
 * Copyright (C) 2002 Matthew Dharm <mdharm@momenco.com>
 *
 * Based on the 64360 driver from:
6 7
 * Copyright (C) 2002 Rabeeh Khoury <rabeeh@galileo.co.il>
 *		      Rabeeh Khoury <rabeeh@marvell.com>
L
Linus Torvalds 已提交
8 9
 *
 * Copyright (C) 2003 PMC-Sierra, Inc.,
10
 *	written by Manish Lachwani
L
Linus Torvalds 已提交
11 12 13
 *
 * Copyright (C) 2003 Ralf Baechle <ralf@linux-mips.org>
 *
14
 * Copyright (C) 2004-2006 MontaVista Software, Inc.
L
Linus Torvalds 已提交
15 16 17 18 19
 *			   Dale Farnsworth <dale@farnsworth.org>
 *
 * Copyright (C) 2004 Steven J. Hill <sjhill1@rockwellcollins.com>
 *				     <sjhill@realitydiluted.com>
 *
20 21 22
 * Copyright (C) 2007-2008 Marvell Semiconductor
 *			   Lennert Buytenhek <buytenh@marvell.com>
 *
L
Linus Torvalds 已提交
23 24 25 26 27 28 29 30 31 32 33 34 35 36
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */
37

L
Linus Torvalds 已提交
38 39
#include <linux/init.h>
#include <linux/dma-mapping.h>
40
#include <linux/in.h>
41
#include <linux/ip.h>
L
Linus Torvalds 已提交
42 43 44 45 46
#include <linux/tcp.h>
#include <linux/udp.h>
#include <linux/etherdevice.h>
#include <linux/delay.h>
#include <linux/ethtool.h>
47
#include <linux/platform_device.h>
48 49 50 51
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/spinlock.h>
#include <linux/workqueue.h>
52
#include <linux/phy.h>
53
#include <linux/mv643xx_eth.h>
L
Lennert Buytenhek 已提交
54 55
#include <linux/io.h>
#include <linux/types.h>
56
#include <linux/inet_lro.h>
L
Linus Torvalds 已提交
57
#include <asm/system.h>
58

59
static char mv643xx_eth_driver_name[] = "mv643xx_eth";
60
static char mv643xx_eth_driver_version[] = "1.4";
61

62 63 64 65

/*
 * Registers shared between all ports.
 */
66 67
#define PHY_ADDR			0x0000
#define SMI_REG				0x0004
68 69 70 71 72 73 74
#define  SMI_BUSY			0x10000000
#define  SMI_READ_VALID			0x08000000
#define  SMI_OPCODE_READ		0x04000000
#define  SMI_OPCODE_WRITE		0x00000000
#define ERR_INT_CAUSE			0x0080
#define  ERR_INT_SMI_DONE		0x00000010
#define ERR_INT_MASK			0x0084
75 76 77 78 79
#define WINDOW_BASE(w)			(0x0200 + ((w) << 3))
#define WINDOW_SIZE(w)			(0x0204 + ((w) << 3))
#define WINDOW_REMAP_HIGH(w)		(0x0280 + ((w) << 2))
#define WINDOW_BAR_ENABLE		0x0290
#define WINDOW_PROTECT(w)		(0x0294 + ((w) << 4))
80 81

/*
82 83
 * Main per-port registers.  These live at offset 0x0400 for
 * port #0, 0x0800 for port #1, and 0x0c00 for port #2.
84
 */
85
#define PORT_CONFIG			0x0000
86
#define  UNICAST_PROMISCUOUS_MODE	0x00000001
87 88 89 90 91 92
#define PORT_CONFIG_EXT			0x0004
#define MAC_ADDR_LOW			0x0014
#define MAC_ADDR_HIGH			0x0018
#define SDMA_CONFIG			0x001c
#define PORT_SERIAL_CONTROL		0x003c
#define PORT_STATUS			0x0044
93
#define  TX_FIFO_EMPTY			0x00000400
94
#define  TX_IN_PROGRESS			0x00000080
95 96 97 98 99 100
#define  PORT_SPEED_MASK		0x00000030
#define  PORT_SPEED_1000		0x00000010
#define  PORT_SPEED_100			0x00000020
#define  PORT_SPEED_10			0x00000000
#define  FLOW_CONTROL_ENABLED		0x00000008
#define  FULL_DUPLEX			0x00000004
101
#define  LINK_UP			0x00000002
102 103 104 105 106 107
#define TXQ_COMMAND			0x0048
#define TXQ_FIX_PRIO_CONF		0x004c
#define TX_BW_RATE			0x0050
#define TX_BW_MTU			0x0058
#define TX_BW_BURST			0x005c
#define INT_CAUSE			0x0060
108
#define  INT_TX_END			0x07f80000
109
#define  INT_RX				0x000003fc
110
#define  INT_EXT			0x00000002
111
#define INT_CAUSE_EXT			0x0064
112 113
#define  INT_EXT_LINK_PHY		0x00110000
#define  INT_EXT_TX			0x000000ff
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
#define INT_MASK			0x0068
#define INT_MASK_EXT			0x006c
#define TX_FIFO_URGENT_THRESHOLD	0x0074
#define TXQ_FIX_PRIO_CONF_MOVED		0x00dc
#define TX_BW_RATE_MOVED		0x00e0
#define TX_BW_MTU_MOVED			0x00e8
#define TX_BW_BURST_MOVED		0x00ec
#define RXQ_CURRENT_DESC_PTR(q)		(0x020c + ((q) << 4))
#define RXQ_COMMAND			0x0280
#define TXQ_CURRENT_DESC_PTR(q)		(0x02c0 + ((q) << 2))
#define TXQ_BW_TOKENS(q)		(0x0300 + ((q) << 4))
#define TXQ_BW_CONF(q)			(0x0304 + ((q) << 4))
#define TXQ_BW_WRR_CONF(q)		(0x0308 + ((q) << 4))

/*
 * Misc per-port registers.
 */
131 132 133 134
#define MIB_COUNTERS(p)			(0x1000 + ((p) << 7))
#define SPECIAL_MCAST_TABLE(p)		(0x1400 + ((p) << 10))
#define OTHER_MCAST_TABLE(p)		(0x1500 + ((p) << 10))
#define UNICAST_TABLE(p)		(0x1600 + ((p) << 10))
135

136 137 138 139

/*
 * SDMA configuration register.
 */
140
#define RX_BURST_SIZE_4_64BIT		(2 << 1)
141
#define RX_BURST_SIZE_16_64BIT		(4 << 1)
142 143
#define BLM_RX_NO_SWAP			(1 << 4)
#define BLM_TX_NO_SWAP			(1 << 5)
144
#define TX_BURST_SIZE_4_64BIT		(2 << 22)
145
#define TX_BURST_SIZE_16_64BIT		(4 << 22)
146 147 148

#if defined(__BIG_ENDIAN)
#define PORT_SDMA_CONFIG_DEFAULT_VALUE		\
149 150
		(RX_BURST_SIZE_4_64BIT	|	\
		 TX_BURST_SIZE_4_64BIT)
151 152
#elif defined(__LITTLE_ENDIAN)
#define PORT_SDMA_CONFIG_DEFAULT_VALUE		\
153 154 155 156
		(RX_BURST_SIZE_4_64BIT	|	\
		 BLM_RX_NO_SWAP		|	\
		 BLM_TX_NO_SWAP		|	\
		 TX_BURST_SIZE_4_64BIT)
157 158 159 160
#else
#error One of __BIG_ENDIAN or __LITTLE_ENDIAN must be defined
#endif

161 162 163 164 165 166 167

/*
 * Port serial control register.
 */
#define SET_MII_SPEED_TO_100			(1 << 24)
#define SET_GMII_SPEED_TO_1000			(1 << 23)
#define SET_FULL_DUPLEX_MODE			(1 << 21)
168
#define MAX_RX_PACKET_9700BYTE			(5 << 17)
169 170 171 172 173 174 175
#define DISABLE_AUTO_NEG_SPEED_GMII		(1 << 13)
#define DO_NOT_FORCE_LINK_FAIL			(1 << 10)
#define SERIAL_PORT_CONTROL_RESERVED		(1 << 9)
#define DISABLE_AUTO_NEG_FOR_FLOW_CTRL		(1 << 3)
#define DISABLE_AUTO_NEG_FOR_DUPLEX		(1 << 2)
#define FORCE_LINK_PASS				(1 << 1)
#define SERIAL_PORT_ENABLE			(1 << 0)
176

177 178
#define DEFAULT_RX_QUEUE_SIZE		128
#define DEFAULT_TX_QUEUE_SIZE		256
179 180


181 182
/*
 * RX/TX descriptors.
183 184
 */
#if defined(__BIG_ENDIAN)
185
struct rx_desc {
186 187 188 189 190 191 192
	u16 byte_cnt;		/* Descriptor buffer byte count		*/
	u16 buf_size;		/* Buffer size				*/
	u32 cmd_sts;		/* Descriptor command status		*/
	u32 next_desc_ptr;	/* Next descriptor pointer		*/
	u32 buf_ptr;		/* Descriptor buffer pointer		*/
};

193
struct tx_desc {
194 195 196 197 198 199 200
	u16 byte_cnt;		/* buffer byte count			*/
	u16 l4i_chk;		/* CPU provided TCP checksum		*/
	u32 cmd_sts;		/* Command/status field			*/
	u32 next_desc_ptr;	/* Pointer to next descriptor		*/
	u32 buf_ptr;		/* pointer to buffer for this descriptor*/
};
#elif defined(__LITTLE_ENDIAN)
201
struct rx_desc {
202 203 204 205 206 207 208
	u32 cmd_sts;		/* Descriptor command status		*/
	u16 buf_size;		/* Buffer size				*/
	u16 byte_cnt;		/* Descriptor buffer byte count		*/
	u32 buf_ptr;		/* Descriptor buffer pointer		*/
	u32 next_desc_ptr;	/* Next descriptor pointer		*/
};

209
struct tx_desc {
210 211 212 213 214 215 216 217 218 219
	u32 cmd_sts;		/* Command/status field			*/
	u16 l4i_chk;		/* CPU provided TCP checksum		*/
	u16 byte_cnt;		/* buffer byte count			*/
	u32 buf_ptr;		/* pointer to buffer for this descriptor*/
	u32 next_desc_ptr;	/* Pointer to next descriptor		*/
};
#else
#error One of __BIG_ENDIAN or __LITTLE_ENDIAN must be defined
#endif

220
/* RX & TX descriptor command */
221
#define BUFFER_OWNED_BY_DMA		0x80000000
222 223

/* RX & TX descriptor status */
224
#define ERROR_SUMMARY			0x00000001
225 226

/* RX descriptor status */
227 228 229 230
#define LAYER_4_CHECKSUM_OK		0x40000000
#define RX_ENABLE_INTERRUPT		0x20000000
#define RX_FIRST_DESC			0x08000000
#define RX_LAST_DESC			0x04000000
231 232 233 234 235 236
#define RX_IP_HDR_OK			0x02000000
#define RX_PKT_IS_IPV4			0x01000000
#define RX_PKT_IS_ETHERNETV2		0x00800000
#define RX_PKT_LAYER4_TYPE_MASK		0x00600000
#define RX_PKT_LAYER4_TYPE_TCP_IPV4	0x00000000
#define RX_PKT_IS_VLAN_TAGGED		0x00080000
237 238

/* TX descriptor command */
239 240 241 242 243 244 245 246
#define TX_ENABLE_INTERRUPT		0x00800000
#define GEN_CRC				0x00400000
#define TX_FIRST_DESC			0x00200000
#define TX_LAST_DESC			0x00100000
#define ZERO_PADDING			0x00080000
#define GEN_IP_V4_CHECKSUM		0x00040000
#define GEN_TCP_UDP_CHECKSUM		0x00020000
#define UDP_FRAME			0x00010000
247 248
#define MAC_HDR_EXTRA_4_BYTES		0x00008000
#define MAC_HDR_EXTRA_8_BYTES		0x00000200
249

250
#define TX_IHL_SHIFT			11
251 252


253
/* global *******************************************************************/
254
struct mv643xx_eth_shared_private {
L
Lennert Buytenhek 已提交
255 256 257
	/*
	 * Ethernet controller base address.
	 */
258
	void __iomem *base;
259

260 261 262 263 264
	/*
	 * Points at the right SMI instance to use.
	 */
	struct mv643xx_eth_shared_private *smi;

L
Lennert Buytenhek 已提交
265
	/*
266
	 * Provides access to local SMI interface.
L
Lennert Buytenhek 已提交
267
	 */
268
	struct mii_bus *smi_bus;
269

270 271 272 273 274 275 276 277 278
	/*
	 * If we have access to the error interrupt pin (which is
	 * somewhat misnamed as it not only reflects internal errors
	 * but also reflects SMI completion), use that to wait for
	 * SMI access completion instead of polling the SMI busy bit.
	 */
	int err_interrupt;
	wait_queue_head_t smi_busy_wait;

L
Lennert Buytenhek 已提交
279 280 281
	/*
	 * Per-port MBUS window access register value.
	 */
282 283
	u32 win_protect;

L
Lennert Buytenhek 已提交
284 285 286
	/*
	 * Hardware-specific parameters.
	 */
287
	unsigned int t_clk;
288
	int extended_rx_coal_limit;
289
	int tx_bw_control;
290 291
};

292 293 294 295
#define TX_BW_CONTROL_ABSENT		0
#define TX_BW_CONTROL_OLD_LAYOUT	1
#define TX_BW_CONTROL_NEW_LAYOUT	2

296 297 298
static int mv643xx_eth_open(struct net_device *dev);
static int mv643xx_eth_stop(struct net_device *dev);

299 300

/* per-port *****************************************************************/
301
struct mib_counters {
302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333
	u64 good_octets_received;
	u32 bad_octets_received;
	u32 internal_mac_transmit_err;
	u32 good_frames_received;
	u32 bad_frames_received;
	u32 broadcast_frames_received;
	u32 multicast_frames_received;
	u32 frames_64_octets;
	u32 frames_65_to_127_octets;
	u32 frames_128_to_255_octets;
	u32 frames_256_to_511_octets;
	u32 frames_512_to_1023_octets;
	u32 frames_1024_to_max_octets;
	u64 good_octets_sent;
	u32 good_frames_sent;
	u32 excessive_collision;
	u32 multicast_frames_sent;
	u32 broadcast_frames_sent;
	u32 unrec_mac_control_received;
	u32 fc_sent;
	u32 good_fc_received;
	u32 bad_fc_received;
	u32 undersize_received;
	u32 fragments_received;
	u32 oversize_received;
	u32 jabber_received;
	u32 mac_receive_error;
	u32 bad_crc_event;
	u32 collision;
	u32 late_collision;
};

334 335 336 337 338 339
struct lro_counters {
	u32 lro_aggregated;
	u32 lro_flushed;
	u32 lro_no_desc;
};

340
struct rx_queue {
341 342
	int index;

343 344 345 346 347 348 349 350 351 352
	int rx_ring_size;

	int rx_desc_count;
	int rx_curr_desc;
	int rx_used_desc;

	struct rx_desc *rx_desc_area;
	dma_addr_t rx_desc_dma;
	int rx_desc_area_size;
	struct sk_buff **rx_skb;
353 354 355

	struct net_lro_mgr lro_mgr;
	struct net_lro_desc lro_arr[8];
356 357
};

358
struct tx_queue {
359 360
	int index;

361
	int tx_ring_size;
362

363 364 365
	int tx_desc_count;
	int tx_curr_desc;
	int tx_used_desc;
366

367
	struct tx_desc *tx_desc_area;
368 369
	dma_addr_t tx_desc_dma;
	int tx_desc_area_size;
370 371

	struct sk_buff_head tx_skb;
372 373 374 375

	unsigned long tx_packets;
	unsigned long tx_bytes;
	unsigned long tx_dropped;
376 377 378 379
};

struct mv643xx_eth_private {
	struct mv643xx_eth_shared_private *shared;
380
	void __iomem *base;
L
Lennert Buytenhek 已提交
381
	int port_num;
382

L
Lennert Buytenhek 已提交
383
	struct net_device *dev;
384

385
	struct phy_device *phy;
386

387 388
	struct timer_list mib_counters_timer;
	spinlock_t mib_counters_lock;
L
Lennert Buytenhek 已提交
389
	struct mib_counters mib_counters;
390

391 392
	struct lro_counters lro_counters;

L
Lennert Buytenhek 已提交
393
	struct work_struct tx_timeout_task;
394

395 396 397 398 399 400 401 402
	struct napi_struct napi;
	u8 work_link;
	u8 work_tx;
	u8 work_tx_end;
	u8 work_rx;
	u8 work_rx_refill;
	u8 work_rx_oom;

403 404 405
	int skb_size;
	struct sk_buff_head rx_recycle;

406 407 408
	/*
	 * RX state.
	 */
409
	int rx_ring_size;
410 411
	unsigned long rx_desc_sram_addr;
	int rx_desc_sram_size;
412
	int rxq_count;
413
	struct timer_list rx_oom;
414
	struct rx_queue rxq[8];
415 416 417 418

	/*
	 * TX state.
	 */
419
	int tx_ring_size;
420 421
	unsigned long tx_desc_sram_addr;
	int tx_desc_sram_size;
422
	int txq_count;
423
	struct tx_queue txq[8];
424
};
L
Linus Torvalds 已提交
425

426

427
/* port register accessors **************************************************/
428
static inline u32 rdl(struct mv643xx_eth_private *mp, int offset)
429
{
430
	return readl(mp->shared->base + offset);
431
}
432

433 434 435 436 437
static inline u32 rdlp(struct mv643xx_eth_private *mp, int offset)
{
	return readl(mp->base + offset);
}

438
static inline void wrl(struct mv643xx_eth_private *mp, int offset, u32 data)
439
{
440
	writel(data, mp->shared->base + offset);
441
}
442

443 444 445 446 447
static inline void wrlp(struct mv643xx_eth_private *mp, int offset, u32 data)
{
	writel(data, mp->base + offset);
}

448

449
/* rxq/txq helper functions *************************************************/
450
static struct mv643xx_eth_private *rxq_to_mp(struct rx_queue *rxq)
451
{
452
	return container_of(rxq, struct mv643xx_eth_private, rxq[rxq->index]);
453
}
454

455 456
static struct mv643xx_eth_private *txq_to_mp(struct tx_queue *txq)
{
457
	return container_of(txq, struct mv643xx_eth_private, txq[txq->index]);
458 459
}

460
static void rxq_enable(struct rx_queue *rxq)
461
{
462
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
463
	wrlp(mp, RXQ_COMMAND, 1 << rxq->index);
464
}
L
Linus Torvalds 已提交
465

466 467 468
static void rxq_disable(struct rx_queue *rxq)
{
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
469
	u8 mask = 1 << rxq->index;
L
Linus Torvalds 已提交
470

471 472
	wrlp(mp, RXQ_COMMAND, mask << 8);
	while (rdlp(mp, RXQ_COMMAND) & mask)
473
		udelay(10);
474 475
}

476 477 478 479 480 481 482
static void txq_reset_hw_ptr(struct tx_queue *txq)
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
	u32 addr;

	addr = (u32)txq->tx_desc_dma;
	addr += txq->tx_curr_desc * sizeof(struct tx_desc);
483
	wrlp(mp, TXQ_CURRENT_DESC_PTR(txq->index), addr);
484 485
}

486
static void txq_enable(struct tx_queue *txq)
L
Linus Torvalds 已提交
487
{
488
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
489
	wrlp(mp, TXQ_COMMAND, 1 << txq->index);
L
Linus Torvalds 已提交
490 491
}

492
static void txq_disable(struct tx_queue *txq)
L
Linus Torvalds 已提交
493
{
494
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
495
	u8 mask = 1 << txq->index;
496

497 498
	wrlp(mp, TXQ_COMMAND, mask << 8);
	while (rdlp(mp, TXQ_COMMAND) & mask)
499 500 501
		udelay(10);
}

502
static void txq_maybe_wake(struct tx_queue *txq)
503 504
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
505
	struct netdev_queue *nq = netdev_get_tx_queue(mp->dev, txq->index);
506

507 508 509 510 511 512
	if (netif_tx_queue_stopped(nq)) {
		__netif_tx_lock(nq, smp_processor_id());
		if (txq->tx_ring_size - txq->tx_desc_count >= MAX_SKB_FRAGS + 1)
			netif_tx_wake_queue(nq);
		__netif_tx_unlock(nq);
	}
L
Linus Torvalds 已提交
513 514
}

515

516
/* rx napi ******************************************************************/
517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542
static int
mv643xx_get_skb_header(struct sk_buff *skb, void **iphdr, void **tcph,
		       u64 *hdr_flags, void *priv)
{
	unsigned long cmd_sts = (unsigned long)priv;

	/*
	 * Make sure that this packet is Ethernet II, is not VLAN
	 * tagged, is IPv4, has a valid IP header, and is TCP.
	 */
	if ((cmd_sts & (RX_IP_HDR_OK | RX_PKT_IS_IPV4 |
		       RX_PKT_IS_ETHERNETV2 | RX_PKT_LAYER4_TYPE_MASK |
		       RX_PKT_IS_VLAN_TAGGED)) !=
	    (RX_IP_HDR_OK | RX_PKT_IS_IPV4 |
	     RX_PKT_IS_ETHERNETV2 | RX_PKT_LAYER4_TYPE_TCP_IPV4))
		return -1;

	skb_reset_network_header(skb);
	skb_set_transport_header(skb, ip_hdrlen(skb));
	*iphdr = ip_hdr(skb);
	*tcph = tcp_hdr(skb);
	*hdr_flags = LRO_IPV4 | LRO_TCP;

	return 0;
}

543
static int rxq_process(struct rx_queue *rxq, int budget)
L
Linus Torvalds 已提交
544
{
545 546
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	struct net_device_stats *stats = &mp->dev->stats;
547
	int lro_flush_needed;
548
	int rx;
L
Linus Torvalds 已提交
549

550
	lro_flush_needed = 0;
551
	rx = 0;
552
	while (rx < budget && rxq->rx_desc_count) {
L
Lennert Buytenhek 已提交
553
		struct rx_desc *rx_desc;
554
		unsigned int cmd_sts;
L
Lennert Buytenhek 已提交
555
		struct sk_buff *skb;
556
		u16 byte_cnt;
557

558
		rx_desc = &rxq->rx_desc_area[rxq->rx_curr_desc];
L
Linus Torvalds 已提交
559

560
		cmd_sts = rx_desc->cmd_sts;
561
		if (cmd_sts & BUFFER_OWNED_BY_DMA)
562 563
			break;
		rmb();
L
Linus Torvalds 已提交
564

565 566
		skb = rxq->rx_skb[rxq->rx_curr_desc];
		rxq->rx_skb[rxq->rx_curr_desc] = NULL;
567

568 569 570
		rxq->rx_curr_desc++;
		if (rxq->rx_curr_desc == rxq->rx_ring_size)
			rxq->rx_curr_desc = 0;
571

572
		dma_unmap_single(NULL, rx_desc->buf_ptr,
573
				 rx_desc->buf_size, DMA_FROM_DEVICE);
574 575
		rxq->rx_desc_count--;
		rx++;
576

577 578
		mp->work_rx_refill |= 1 << rxq->index;

579 580
		byte_cnt = rx_desc->byte_cnt;

581 582
		/*
		 * Update statistics.
L
Lennert Buytenhek 已提交
583 584 585 586 587
		 *
		 * Note that the descriptor byte count includes 2 dummy
		 * bytes automatically inserted by the hardware at the
		 * start of the packet (which we don't count), and a 4
		 * byte CRC at the end of the packet (which we do count).
588
		 */
L
Linus Torvalds 已提交
589
		stats->rx_packets++;
590
		stats->rx_bytes += byte_cnt - 2;
591

L
Linus Torvalds 已提交
592
		/*
L
Lennert Buytenhek 已提交
593 594 595
		 * In case we received a packet without first / last bits
		 * on, or the error summary bit is set, the packet needs
		 * to be dropped.
L
Linus Torvalds 已提交
596
		 */
597 598 599 600 601 602 603 604 605 606 607 608 609
		if ((cmd_sts & (RX_FIRST_DESC | RX_LAST_DESC | ERROR_SUMMARY))
			!= (RX_FIRST_DESC | RX_LAST_DESC))
			goto err;

		/*
		 * The -4 is for the CRC in the trailer of the
		 * received packet
		 */
		skb_put(skb, byte_cnt - 2 - 4);

		if (cmd_sts & LAYER_4_CHECKSUM_OK)
			skb->ip_summed = CHECKSUM_UNNECESSARY;
		skb->protocol = eth_type_trans(skb, mp->dev);
610 611 612 613 614 615 616

		if (skb->dev->features & NETIF_F_LRO &&
		    skb->ip_summed == CHECKSUM_UNNECESSARY) {
			lro_receive_skb(&rxq->lro_mgr, skb, (void *)cmd_sts);
			lro_flush_needed = 1;
		} else
			netif_receive_skb(skb);
617 618 619 620 621 622 623 624 625 626 627 628

		continue;

err:
		stats->rx_dropped++;

		if ((cmd_sts & (RX_FIRST_DESC | RX_LAST_DESC)) !=
			(RX_FIRST_DESC | RX_LAST_DESC)) {
			if (net_ratelimit())
				dev_printk(KERN_ERR, &mp->dev->dev,
					   "received packet spanning "
					   "multiple descriptors\n");
L
Linus Torvalds 已提交
629
		}
630 631 632 633 634

		if (cmd_sts & ERROR_SUMMARY)
			stats->rx_errors++;

		dev_kfree_skb(skb);
L
Linus Torvalds 已提交
635
	}
L
Lennert Buytenhek 已提交
636

637 638 639
	if (lro_flush_needed)
		lro_flush_all(&rxq->lro_mgr);

640 641 642
	if (rx < budget)
		mp->work_rx &= ~(1 << rxq->index);

643
	return rx;
L
Linus Torvalds 已提交
644 645
}

646
static int rxq_refill(struct rx_queue *rxq, int budget)
647
{
648 649
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	int refilled;
650

651 652 653 654 655
	refilled = 0;
	while (refilled < budget && rxq->rx_desc_count < rxq->rx_ring_size) {
		struct sk_buff *skb;
		int unaligned;
		int rx;
656
		struct rx_desc *rx_desc;
657

658 659 660 661 662
		skb = __skb_dequeue(&mp->rx_recycle);
		if (skb == NULL)
			skb = dev_alloc_skb(mp->skb_size +
					    dma_get_cache_alignment() - 1);

663 664 665 666
		if (skb == NULL) {
			mp->work_rx_oom |= 1 << rxq->index;
			goto oom;
		}
667

668 669 670
		unaligned = (u32)skb->data & (dma_get_cache_alignment() - 1);
		if (unaligned)
			skb_reserve(skb, dma_get_cache_alignment() - unaligned);
671

672 673
		refilled++;
		rxq->rx_desc_count++;
674

675 676 677
		rx = rxq->rx_used_desc++;
		if (rxq->rx_used_desc == rxq->rx_ring_size)
			rxq->rx_used_desc = 0;
678

679 680 681 682 683
		rx_desc = rxq->rx_desc_area + rx;

		rx_desc->buf_ptr = dma_map_single(NULL, skb->data,
					mp->skb_size, DMA_FROM_DEVICE);
		rx_desc->buf_size = mp->skb_size;
684 685
		rxq->rx_skb[rx] = skb;
		wmb();
686
		rx_desc->cmd_sts = BUFFER_OWNED_BY_DMA | RX_ENABLE_INTERRUPT;
687
		wmb();
688

689 690 691 692 693 694 695 696 697 698 699 700 701
		/*
		 * The hardware automatically prepends 2 bytes of
		 * dummy data to each received packet, so that the
		 * IP header ends up 16-byte aligned.
		 */
		skb_reserve(skb, 2);
	}

	if (refilled < budget)
		mp->work_rx_refill &= ~(1 << rxq->index);

oom:
	return refilled;
702 703
}

704 705 706

/* tx ***********************************************************************/
static inline unsigned int has_tiny_unaligned_frags(struct sk_buff *skb)
L
Linus Torvalds 已提交
707
{
708
	int frag;
L
Linus Torvalds 已提交
709

710
	for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
711 712
		skb_frag_t *fragp = &skb_shinfo(skb)->frags[frag];
		if (fragp->size <= 8 && fragp->page_offset & 7)
713
			return 1;
L
Linus Torvalds 已提交
714
	}
715

716 717
	return 0;
}
718

719
static void txq_submit_frag_skb(struct tx_queue *txq, struct sk_buff *skb)
720
{
721
	int nr_frags = skb_shinfo(skb)->nr_frags;
722
	int frag;
L
Linus Torvalds 已提交
723

724 725 726 727 728 729
	for (frag = 0; frag < nr_frags; frag++) {
		skb_frag_t *this_frag;
		int tx_index;
		struct tx_desc *desc;

		this_frag = &skb_shinfo(skb)->frags[frag];
730 731 732
		tx_index = txq->tx_curr_desc++;
		if (txq->tx_curr_desc == txq->tx_ring_size)
			txq->tx_curr_desc = 0;
733 734 735 736 737 738 739 740 741 742 743 744 745 746
		desc = &txq->tx_desc_area[tx_index];

		/*
		 * The last fragment will generate an interrupt
		 * which will free the skb on TX completion.
		 */
		if (frag == nr_frags - 1) {
			desc->cmd_sts = BUFFER_OWNED_BY_DMA |
					ZERO_PADDING | TX_LAST_DESC |
					TX_ENABLE_INTERRUPT;
		} else {
			desc->cmd_sts = BUFFER_OWNED_BY_DMA;
		}

747 748 749 750 751 752 753
		desc->l4i_chk = 0;
		desc->byte_cnt = this_frag->size;
		desc->buf_ptr = dma_map_page(NULL, this_frag->page,
						this_frag->page_offset,
						this_frag->size,
						DMA_TO_DEVICE);
	}
L
Linus Torvalds 已提交
754 755
}

756 757 758 759
static inline __be16 sum16_as_be(__sum16 sum)
{
	return (__force __be16)sum;
}
L
Linus Torvalds 已提交
760

761
static int txq_submit_skb(struct tx_queue *txq, struct sk_buff *skb)
L
Linus Torvalds 已提交
762
{
763
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
764
	int nr_frags = skb_shinfo(skb)->nr_frags;
765
	int tx_index;
766
	struct tx_desc *desc;
767
	u32 cmd_sts;
768
	u16 l4i_chk;
769
	int length;
L
Linus Torvalds 已提交
770

771
	cmd_sts = TX_FIRST_DESC | GEN_CRC | BUFFER_OWNED_BY_DMA;
772
	l4i_chk = 0;
773 774

	if (skb->ip_summed == CHECKSUM_PARTIAL) {
775
		int tag_bytes;
776 777 778

		BUG_ON(skb->protocol != htons(ETH_P_IP) &&
		       skb->protocol != htons(ETH_P_8021Q));
779

780 781 782 783 784 785 786
		tag_bytes = (void *)ip_hdr(skb) - (void *)skb->data - ETH_HLEN;
		if (unlikely(tag_bytes & ~12)) {
			if (skb_checksum_help(skb) == 0)
				goto no_csum;
			kfree_skb(skb);
			return 1;
		}
787

788
		if (tag_bytes & 4)
789
			cmd_sts |= MAC_HDR_EXTRA_4_BYTES;
790
		if (tag_bytes & 8)
791
			cmd_sts |= MAC_HDR_EXTRA_8_BYTES;
792 793 794 795

		cmd_sts |= GEN_TCP_UDP_CHECKSUM |
			   GEN_IP_V4_CHECKSUM   |
			   ip_hdr(skb)->ihl << TX_IHL_SHIFT;
796

797 798
		switch (ip_hdr(skb)->protocol) {
		case IPPROTO_UDP:
799
			cmd_sts |= UDP_FRAME;
800
			l4i_chk = ntohs(sum16_as_be(udp_hdr(skb)->check));
801 802
			break;
		case IPPROTO_TCP:
803
			l4i_chk = ntohs(sum16_as_be(tcp_hdr(skb)->check));
804 805 806 807 808
			break;
		default:
			BUG();
		}
	} else {
809
no_csum:
810
		/* Errata BTS #50, IHL must be 5 if no HW checksum */
811
		cmd_sts |= 5 << TX_IHL_SHIFT;
812 813
	}

814 815 816
	tx_index = txq->tx_curr_desc++;
	if (txq->tx_curr_desc == txq->tx_ring_size)
		txq->tx_curr_desc = 0;
817 818 819 820 821 822 823 824 825 826 827 828 829 830
	desc = &txq->tx_desc_area[tx_index];

	if (nr_frags) {
		txq_submit_frag_skb(txq, skb);
		length = skb_headlen(skb);
	} else {
		cmd_sts |= ZERO_PADDING | TX_LAST_DESC | TX_ENABLE_INTERRUPT;
		length = skb->len;
	}

	desc->l4i_chk = l4i_chk;
	desc->byte_cnt = length;
	desc->buf_ptr = dma_map_single(NULL, skb->data, length, DMA_TO_DEVICE);

831 832
	__skb_queue_tail(&txq->tx_skb, skb);

833 834 835 836
	/* ensure all other descriptors are written before first cmd_sts */
	wmb();
	desc->cmd_sts = cmd_sts;

837 838
	/* clear TX_END status */
	mp->work_tx_end &= ~(1 << txq->index);
839

840 841
	/* ensure all descriptors are written before poking hardware */
	wmb();
842
	txq_enable(txq);
843

844
	txq->tx_desc_count += nr_frags + 1;
845 846

	return 0;
L
Linus Torvalds 已提交
847 848
}

L
Lennert Buytenhek 已提交
849
static int mv643xx_eth_xmit(struct sk_buff *skb, struct net_device *dev)
L
Linus Torvalds 已提交
850
{
851
	struct mv643xx_eth_private *mp = netdev_priv(dev);
852
	int queue;
853
	struct tx_queue *txq;
854
	struct netdev_queue *nq;
855

856 857 858 859
	queue = skb_get_queue_mapping(skb);
	txq = mp->txq + queue;
	nq = netdev_get_tx_queue(dev, queue);

860
	if (has_tiny_unaligned_frags(skb) && __skb_linearize(skb)) {
861
		txq->tx_dropped++;
L
Lennert Buytenhek 已提交
862 863 864
		dev_printk(KERN_DEBUG, &dev->dev,
			   "failed to linearize skb with tiny "
			   "unaligned fragment\n");
865 866 867
		return NETDEV_TX_BUSY;
	}

868
	if (txq->tx_ring_size - txq->tx_desc_count < MAX_SKB_FRAGS + 1) {
869 870
		if (net_ratelimit())
			dev_printk(KERN_ERR, &dev->dev, "tx queue full?!\n");
871 872
		kfree_skb(skb);
		return NETDEV_TX_OK;
873 874
	}

875 876 877 878 879 880
	if (!txq_submit_skb(txq, skb)) {
		int entries_left;

		txq->tx_bytes += skb->len;
		txq->tx_packets++;
		dev->trans_start = jiffies;
881

882 883 884 885
		entries_left = txq->tx_ring_size - txq->tx_desc_count;
		if (entries_left < MAX_SKB_FRAGS + 1)
			netif_tx_stop_queue(nq);
	}
886 887

	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
888 889
}

890

891 892 893 894
/* tx napi ******************************************************************/
static void txq_kick(struct tx_queue *txq)
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
895
	struct netdev_queue *nq = netdev_get_tx_queue(mp->dev, txq->index);
896 897 898
	u32 hw_desc_ptr;
	u32 expected_ptr;

899
	__netif_tx_lock(nq, smp_processor_id());
900

901
	if (rdlp(mp, TXQ_COMMAND) & (1 << txq->index))
902 903
		goto out;

904
	hw_desc_ptr = rdlp(mp, TXQ_CURRENT_DESC_PTR(txq->index));
905 906 907 908 909 910 911
	expected_ptr = (u32)txq->tx_desc_dma +
				txq->tx_curr_desc * sizeof(struct tx_desc);

	if (hw_desc_ptr != expected_ptr)
		txq_enable(txq);

out:
912
	__netif_tx_unlock(nq);
913 914 915 916 917 918 919

	mp->work_tx_end &= ~(1 << txq->index);
}

static int txq_reclaim(struct tx_queue *txq, int budget, int force)
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
920
	struct netdev_queue *nq = netdev_get_tx_queue(mp->dev, txq->index);
921 922
	int reclaimed;

923
	__netif_tx_lock(nq, smp_processor_id());
924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948

	reclaimed = 0;
	while (reclaimed < budget && txq->tx_desc_count > 0) {
		int tx_index;
		struct tx_desc *desc;
		u32 cmd_sts;
		struct sk_buff *skb;

		tx_index = txq->tx_used_desc;
		desc = &txq->tx_desc_area[tx_index];
		cmd_sts = desc->cmd_sts;

		if (cmd_sts & BUFFER_OWNED_BY_DMA) {
			if (!force)
				break;
			desc->cmd_sts = cmd_sts & ~BUFFER_OWNED_BY_DMA;
		}

		txq->tx_used_desc = tx_index + 1;
		if (txq->tx_used_desc == txq->tx_ring_size)
			txq->tx_used_desc = 0;

		reclaimed++;
		txq->tx_desc_count--;

949 950 951
		skb = NULL;
		if (cmd_sts & TX_LAST_DESC)
			skb = __skb_dequeue(&txq->tx_skb);
952 953 954 955 956 957

		if (cmd_sts & ERROR_SUMMARY) {
			dev_printk(KERN_INFO, &mp->dev->dev, "tx error\n");
			mp->dev->stats.tx_errors++;
		}

958 959 960 961 962 963 964
		if (cmd_sts & TX_FIRST_DESC) {
			dma_unmap_single(NULL, desc->buf_ptr,
					 desc->byte_cnt, DMA_TO_DEVICE);
		} else {
			dma_unmap_page(NULL, desc->buf_ptr,
				       desc->byte_cnt, DMA_TO_DEVICE);
		}
965

966 967
		if (skb != NULL) {
			if (skb_queue_len(&mp->rx_recycle) <
968
					mp->rx_ring_size &&
969 970
			    skb_recycle_check(skb, mp->skb_size +
					dma_get_cache_alignment() - 1))
971 972 973 974
				__skb_queue_head(&mp->rx_recycle, skb);
			else
				dev_kfree_skb(skb);
		}
975 976
	}

977 978
	__netif_tx_unlock(nq);

979 980 981 982 983 984 985
	if (reclaimed < budget)
		mp->work_tx &= ~(1 << txq->index);

	return reclaimed;
}


986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002 1003 1004 1005 1006 1007 1008
/* tx rate control **********************************************************/
/*
 * Set total maximum TX rate (shared by all TX queues for this port)
 * to 'rate' bits per second, with a maximum burst of 'burst' bytes.
 */
static void tx_set_rate(struct mv643xx_eth_private *mp, int rate, int burst)
{
	int token_rate;
	int mtu;
	int bucket_size;

	token_rate = ((rate / 1000) * 64) / (mp->shared->t_clk / 1000);
	if (token_rate > 1023)
		token_rate = 1023;

	mtu = (mp->dev->mtu + 255) >> 8;
	if (mtu > 63)
		mtu = 63;

	bucket_size = (burst + 255) >> 8;
	if (bucket_size > 65535)
		bucket_size = 65535;

1009 1010
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
1011 1012 1013
		wrlp(mp, TX_BW_RATE, token_rate);
		wrlp(mp, TX_BW_MTU, mtu);
		wrlp(mp, TX_BW_BURST, bucket_size);
1014 1015
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
1016 1017 1018
		wrlp(mp, TX_BW_RATE_MOVED, token_rate);
		wrlp(mp, TX_BW_MTU_MOVED, mtu);
		wrlp(mp, TX_BW_BURST_MOVED, bucket_size);
1019
		break;
1020
	}
1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036
}

static void txq_set_rate(struct tx_queue *txq, int rate, int burst)
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
	int token_rate;
	int bucket_size;

	token_rate = ((rate / 1000) * 64) / (mp->shared->t_clk / 1000);
	if (token_rate > 1023)
		token_rate = 1023;

	bucket_size = (burst + 255) >> 8;
	if (bucket_size > 65535)
		bucket_size = 65535;

1037 1038
	wrlp(mp, TXQ_BW_TOKENS(txq->index), token_rate << 14);
	wrlp(mp, TXQ_BW_CONF(txq->index), (bucket_size << 10) | token_rate);
1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049
}

static void txq_set_fixed_prio_mode(struct tx_queue *txq)
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
	int off;
	u32 val;

	/*
	 * Turn on fixed priority mode.
	 */
1050 1051 1052
	off = 0;
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
1053
		off = TXQ_FIX_PRIO_CONF;
1054 1055
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
1056
		off = TXQ_FIX_PRIO_CONF_MOVED;
1057 1058
		break;
	}
1059

1060
	if (off) {
1061
		val = rdlp(mp, off);
1062
		val |= 1 << txq->index;
1063
		wrlp(mp, off, val);
1064
	}
1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075
}

static void txq_set_wrr(struct tx_queue *txq, int weight)
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
	int off;
	u32 val;

	/*
	 * Turn off fixed priority mode.
	 */
1076 1077 1078
	off = 0;
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
1079
		off = TXQ_FIX_PRIO_CONF;
1080 1081
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
1082
		off = TXQ_FIX_PRIO_CONF_MOVED;
1083 1084
		break;
	}
1085

1086
	if (off) {
1087
		val = rdlp(mp, off);
1088
		val &= ~(1 << txq->index);
1089
		wrlp(mp, off, val);
1090

1091 1092 1093
		/*
		 * Configure WRR weight for this queue.
		 */
1094

1095
		val = rdlp(mp, off);
1096
		val = (val & ~0xff) | (weight & 0xff);
1097
		wrlp(mp, TXQ_BW_WRR_CONF(txq->index), val);
1098
	}
1099 1100 1101
}


1102
/* mii management interface *************************************************/
1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114
static irqreturn_t mv643xx_eth_err_irq(int irq, void *dev_id)
{
	struct mv643xx_eth_shared_private *msp = dev_id;

	if (readl(msp->base + ERR_INT_CAUSE) & ERR_INT_SMI_DONE) {
		writel(~ERR_INT_SMI_DONE, msp->base + ERR_INT_CAUSE);
		wake_up(&msp->smi_busy_wait);
		return IRQ_HANDLED;
	}

	return IRQ_NONE;
}
1115

1116
static int smi_is_done(struct mv643xx_eth_shared_private *msp)
L
Linus Torvalds 已提交
1117
{
1118 1119
	return !(readl(msp->base + SMI_REG) & SMI_BUSY);
}
L
Linus Torvalds 已提交
1120

1121 1122 1123 1124
static int smi_wait_ready(struct mv643xx_eth_shared_private *msp)
{
	if (msp->err_interrupt == NO_IRQ) {
		int i;
1125

1126 1127 1128 1129
		for (i = 0; !smi_is_done(msp); i++) {
			if (i == 10)
				return -ETIMEDOUT;
			msleep(10);
1130
		}
1131 1132 1133 1134

		return 0;
	}

1135 1136 1137 1138 1139 1140
	if (!smi_is_done(msp)) {
		wait_event_timeout(msp->smi_busy_wait, smi_is_done(msp),
				   msecs_to_jiffies(100));
		if (!smi_is_done(msp))
			return -ETIMEDOUT;
	}
1141 1142 1143 1144

	return 0;
}

1145
static int smi_bus_read(struct mii_bus *bus, int addr, int reg)
1146
{
1147
	struct mv643xx_eth_shared_private *msp = bus->priv;
1148 1149 1150 1151
	void __iomem *smi_reg = msp->base + SMI_REG;
	int ret;

	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1152
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1153
		return -ETIMEDOUT;
L
Linus Torvalds 已提交
1154 1155
	}

L
Lennert Buytenhek 已提交
1156
	writel(SMI_OPCODE_READ | (reg << 21) | (addr << 16), smi_reg);
L
Linus Torvalds 已提交
1157

1158
	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1159
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1160
		return -ETIMEDOUT;
1161 1162 1163 1164
	}

	ret = readl(smi_reg);
	if (!(ret & SMI_READ_VALID)) {
L
Lennert Buytenhek 已提交
1165
		printk(KERN_WARNING "mv643xx_eth: SMI bus read not valid\n");
1166
		return -ENODEV;
1167 1168
	}

1169
	return ret & 0xffff;
L
Linus Torvalds 已提交
1170 1171
}

1172
static int smi_bus_write(struct mii_bus *bus, int addr, int reg, u16 val)
L
Linus Torvalds 已提交
1173
{
1174
	struct mv643xx_eth_shared_private *msp = bus->priv;
1175
	void __iomem *smi_reg = msp->base + SMI_REG;
L
Linus Torvalds 已提交
1176

1177
	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1178
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1179
		return -ETIMEDOUT;
L
Linus Torvalds 已提交
1180 1181
	}

L
Lennert Buytenhek 已提交
1182
	writel(SMI_OPCODE_WRITE | (reg << 21) |
1183
		(addr << 16) | (val & 0xffff), smi_reg);
1184

1185
	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1186
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1187 1188
		return -ETIMEDOUT;
	}
1189 1190

	return 0;
1191
}
L
Linus Torvalds 已提交
1192

1193

1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
/* statistics ***************************************************************/
static struct net_device_stats *mv643xx_eth_get_stats(struct net_device *dev)
{
	struct mv643xx_eth_private *mp = netdev_priv(dev);
	struct net_device_stats *stats = &dev->stats;
	unsigned long tx_packets = 0;
	unsigned long tx_bytes = 0;
	unsigned long tx_dropped = 0;
	int i;

	for (i = 0; i < mp->txq_count; i++) {
		struct tx_queue *txq = mp->txq + i;

		tx_packets += txq->tx_packets;
		tx_bytes += txq->tx_bytes;
		tx_dropped += txq->tx_dropped;
	}

	stats->tx_packets = tx_packets;
	stats->tx_bytes = tx_bytes;
	stats->tx_dropped = tx_dropped;

	return stats;
}

1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238
static void mv643xx_eth_grab_lro_stats(struct mv643xx_eth_private *mp)
{
	u32 lro_aggregated = 0;
	u32 lro_flushed = 0;
	u32 lro_no_desc = 0;
	int i;

	for (i = 0; i < mp->rxq_count; i++) {
		struct rx_queue *rxq = mp->rxq + i;

		lro_aggregated += rxq->lro_mgr.stats.aggregated;
		lro_flushed += rxq->lro_mgr.stats.flushed;
		lro_no_desc += rxq->lro_mgr.stats.no_desc;
	}

	mp->lro_counters.lro_aggregated = lro_aggregated;
	mp->lro_counters.lro_flushed = lro_flushed;
	mp->lro_counters.lro_no_desc = lro_no_desc;
}

L
Lennert Buytenhek 已提交
1239
static inline u32 mib_read(struct mv643xx_eth_private *mp, int offset)
1240
{
L
Lennert Buytenhek 已提交
1241
	return rdl(mp, MIB_COUNTERS(mp->port_num) + offset);
L
Linus Torvalds 已提交
1242 1243
}

L
Lennert Buytenhek 已提交
1244
static void mib_counters_clear(struct mv643xx_eth_private *mp)
1245
{
L
Lennert Buytenhek 已提交
1246 1247 1248 1249
	int i;

	for (i = 0; i < 0x80; i += 4)
		mib_read(mp, i);
1250
}
1251

L
Lennert Buytenhek 已提交
1252
static void mib_counters_update(struct mv643xx_eth_private *mp)
1253
{
1254
	struct mib_counters *p = &mp->mib_counters;
1255

1256
	spin_lock_bh(&mp->mib_counters_lock);
L
Lennert Buytenhek 已提交
1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288
	p->good_octets_received += mib_read(mp, 0x00);
	p->good_octets_received += (u64)mib_read(mp, 0x04) << 32;
	p->bad_octets_received += mib_read(mp, 0x08);
	p->internal_mac_transmit_err += mib_read(mp, 0x0c);
	p->good_frames_received += mib_read(mp, 0x10);
	p->bad_frames_received += mib_read(mp, 0x14);
	p->broadcast_frames_received += mib_read(mp, 0x18);
	p->multicast_frames_received += mib_read(mp, 0x1c);
	p->frames_64_octets += mib_read(mp, 0x20);
	p->frames_65_to_127_octets += mib_read(mp, 0x24);
	p->frames_128_to_255_octets += mib_read(mp, 0x28);
	p->frames_256_to_511_octets += mib_read(mp, 0x2c);
	p->frames_512_to_1023_octets += mib_read(mp, 0x30);
	p->frames_1024_to_max_octets += mib_read(mp, 0x34);
	p->good_octets_sent += mib_read(mp, 0x38);
	p->good_octets_sent += (u64)mib_read(mp, 0x3c) << 32;
	p->good_frames_sent += mib_read(mp, 0x40);
	p->excessive_collision += mib_read(mp, 0x44);
	p->multicast_frames_sent += mib_read(mp, 0x48);
	p->broadcast_frames_sent += mib_read(mp, 0x4c);
	p->unrec_mac_control_received += mib_read(mp, 0x50);
	p->fc_sent += mib_read(mp, 0x54);
	p->good_fc_received += mib_read(mp, 0x58);
	p->bad_fc_received += mib_read(mp, 0x5c);
	p->undersize_received += mib_read(mp, 0x60);
	p->fragments_received += mib_read(mp, 0x64);
	p->oversize_received += mib_read(mp, 0x68);
	p->jabber_received += mib_read(mp, 0x6c);
	p->mac_receive_error += mib_read(mp, 0x70);
	p->bad_crc_event += mib_read(mp, 0x74);
	p->collision += mib_read(mp, 0x78);
	p->late_collision += mib_read(mp, 0x7c);
1289
	spin_unlock_bh(&mp->mib_counters_lock);
1290 1291 1292 1293 1294 1295 1296 1297 1298

	mod_timer(&mp->mib_counters_timer, jiffies + 30 * HZ);
}

static void mib_counters_timer_wrapper(unsigned long _mp)
{
	struct mv643xx_eth_private *mp = (void *)_mp;

	mib_counters_update(mp);
1299 1300
}

1301

1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323 1324 1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335 1336 1337 1338 1339 1340 1341 1342 1343 1344 1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380
/* interrupt coalescing *****************************************************/
/*
 * Hardware coalescing parameters are set in units of 64 t_clk
 * cycles.  I.e.:
 *
 *	coal_delay_in_usec = 64000000 * register_value / t_clk_rate
 *
 *	register_value = coal_delay_in_usec * t_clk_rate / 64000000
 *
 * In the ->set*() methods, we round the computed register value
 * to the nearest integer.
 */
static unsigned int get_rx_coal(struct mv643xx_eth_private *mp)
{
	u32 val = rdlp(mp, SDMA_CONFIG);
	u64 temp;

	if (mp->shared->extended_rx_coal_limit)
		temp = ((val & 0x02000000) >> 10) | ((val & 0x003fff80) >> 7);
	else
		temp = (val & 0x003fff00) >> 8;

	temp *= 64000000;
	do_div(temp, mp->shared->t_clk);

	return (unsigned int)temp;
}

static void set_rx_coal(struct mv643xx_eth_private *mp, unsigned int usec)
{
	u64 temp;
	u32 val;

	temp = (u64)usec * mp->shared->t_clk;
	temp += 31999999;
	do_div(temp, 64000000);

	val = rdlp(mp, SDMA_CONFIG);
	if (mp->shared->extended_rx_coal_limit) {
		if (temp > 0xffff)
			temp = 0xffff;
		val &= ~0x023fff80;
		val |= (temp & 0x8000) << 10;
		val |= (temp & 0x7fff) << 7;
	} else {
		if (temp > 0x3fff)
			temp = 0x3fff;
		val &= ~0x003fff00;
		val |= (temp & 0x3fff) << 8;
	}
	wrlp(mp, SDMA_CONFIG, val);
}

static unsigned int get_tx_coal(struct mv643xx_eth_private *mp)
{
	u64 temp;

	temp = (rdlp(mp, TX_FIFO_URGENT_THRESHOLD) & 0x3fff0) >> 4;
	temp *= 64000000;
	do_div(temp, mp->shared->t_clk);

	return (unsigned int)temp;
}

static void set_tx_coal(struct mv643xx_eth_private *mp, unsigned int usec)
{
	u64 temp;

	temp = (u64)usec * mp->shared->t_clk;
	temp += 31999999;
	do_div(temp, 64000000);

	if (temp > 0x3fff)
		temp = 0x3fff;

	wrlp(mp, TX_FIFO_URGENT_THRESHOLD, temp << 4);
}


1381
/* ethtool ******************************************************************/
1382
struct mv643xx_eth_stats {
1383 1384
	char stat_string[ETH_GSTRING_LEN];
	int sizeof_stat;
1385 1386
	int netdev_off;
	int mp_off;
1387 1388
};

1389 1390 1391 1392 1393 1394 1395 1396
#define SSTAT(m)						\
	{ #m, FIELD_SIZEOF(struct net_device_stats, m),		\
	  offsetof(struct net_device, stats.m), -1 }

#define MIBSTAT(m)						\
	{ #m, FIELD_SIZEOF(struct mib_counters, m),		\
	  -1, offsetof(struct mv643xx_eth_private, mib_counters.m) }

1397 1398 1399 1400
#define LROSTAT(m)						\
	{ #m, FIELD_SIZEOF(struct lro_counters, m),		\
	  -1, offsetof(struct mv643xx_eth_private, lro_counters.m) }

1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439
static const struct mv643xx_eth_stats mv643xx_eth_stats[] = {
	SSTAT(rx_packets),
	SSTAT(tx_packets),
	SSTAT(rx_bytes),
	SSTAT(tx_bytes),
	SSTAT(rx_errors),
	SSTAT(tx_errors),
	SSTAT(rx_dropped),
	SSTAT(tx_dropped),
	MIBSTAT(good_octets_received),
	MIBSTAT(bad_octets_received),
	MIBSTAT(internal_mac_transmit_err),
	MIBSTAT(good_frames_received),
	MIBSTAT(bad_frames_received),
	MIBSTAT(broadcast_frames_received),
	MIBSTAT(multicast_frames_received),
	MIBSTAT(frames_64_octets),
	MIBSTAT(frames_65_to_127_octets),
	MIBSTAT(frames_128_to_255_octets),
	MIBSTAT(frames_256_to_511_octets),
	MIBSTAT(frames_512_to_1023_octets),
	MIBSTAT(frames_1024_to_max_octets),
	MIBSTAT(good_octets_sent),
	MIBSTAT(good_frames_sent),
	MIBSTAT(excessive_collision),
	MIBSTAT(multicast_frames_sent),
	MIBSTAT(broadcast_frames_sent),
	MIBSTAT(unrec_mac_control_received),
	MIBSTAT(fc_sent),
	MIBSTAT(good_fc_received),
	MIBSTAT(bad_fc_received),
	MIBSTAT(undersize_received),
	MIBSTAT(fragments_received),
	MIBSTAT(oversize_received),
	MIBSTAT(jabber_received),
	MIBSTAT(mac_receive_error),
	MIBSTAT(bad_crc_event),
	MIBSTAT(collision),
	MIBSTAT(late_collision),
1440 1441 1442
	LROSTAT(lro_aggregated),
	LROSTAT(lro_flushed),
	LROSTAT(lro_no_desc),
1443 1444
};

L
Lennert Buytenhek 已提交
1445
static int
1446 1447
mv643xx_eth_get_settings_phy(struct mv643xx_eth_private *mp,
			     struct ethtool_cmd *cmd)
1448 1449 1450
{
	int err;

1451 1452 1453
	err = phy_read_status(mp->phy);
	if (err == 0)
		err = phy_ethtool_gset(mp->phy, cmd);
1454

L
Lennert Buytenhek 已提交
1455 1456 1457
	/*
	 * The MAC does not support 1000baseT_Half.
	 */
1458 1459 1460 1461 1462 1463
	cmd->supported &= ~SUPPORTED_1000baseT_Half;
	cmd->advertising &= ~ADVERTISED_1000baseT_Half;

	return err;
}

L
Lennert Buytenhek 已提交
1464
static int
1465
mv643xx_eth_get_settings_phyless(struct mv643xx_eth_private *mp,
L
Lennert Buytenhek 已提交
1466
				 struct ethtool_cmd *cmd)
1467
{
1468 1469
	u32 port_status;

1470
	port_status = rdlp(mp, PORT_STATUS);
1471

1472 1473
	cmd->supported = SUPPORTED_MII;
	cmd->advertising = ADVERTISED_MII;
1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
	switch (port_status & PORT_SPEED_MASK) {
	case PORT_SPEED_10:
		cmd->speed = SPEED_10;
		break;
	case PORT_SPEED_100:
		cmd->speed = SPEED_100;
		break;
	case PORT_SPEED_1000:
		cmd->speed = SPEED_1000;
		break;
	default:
		cmd->speed = -1;
		break;
	}
	cmd->duplex = (port_status & FULL_DUPLEX) ? DUPLEX_FULL : DUPLEX_HALF;
1489 1490 1491 1492 1493 1494 1495 1496 1497 1498
	cmd->port = PORT_MII;
	cmd->phy_address = 0;
	cmd->transceiver = XCVR_INTERNAL;
	cmd->autoneg = AUTONEG_DISABLE;
	cmd->maxtxpkt = 1;
	cmd->maxrxpkt = 1;

	return 0;
}

1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
static int
mv643xx_eth_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
	struct mv643xx_eth_private *mp = netdev_priv(dev);

	if (mp->phy != NULL)
		return mv643xx_eth_get_settings_phy(mp, cmd);
	else
		return mv643xx_eth_get_settings_phyless(mp, cmd);
}

L
Lennert Buytenhek 已提交
1510 1511
static int
mv643xx_eth_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
L
Linus Torvalds 已提交
1512
{
1513
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1514

1515 1516 1517
	if (mp->phy == NULL)
		return -EINVAL;

L
Lennert Buytenhek 已提交
1518 1519 1520 1521 1522
	/*
	 * The MAC does not support 1000baseT_Half.
	 */
	cmd->advertising &= ~ADVERTISED_1000baseT_Half;

1523
	return phy_ethtool_sset(mp->phy, cmd);
1524
}
L
Linus Torvalds 已提交
1525

L
Lennert Buytenhek 已提交
1526 1527
static void mv643xx_eth_get_drvinfo(struct net_device *dev,
				    struct ethtool_drvinfo *drvinfo)
1528
{
1529 1530
	strncpy(drvinfo->driver,  mv643xx_eth_driver_name, 32);
	strncpy(drvinfo->version, mv643xx_eth_driver_version, 32);
1531
	strncpy(drvinfo->fw_version, "N/A", 32);
L
Lennert Buytenhek 已提交
1532
	strncpy(drvinfo->bus_info, "platform", 32);
1533
	drvinfo->n_stats = ARRAY_SIZE(mv643xx_eth_stats);
1534
}
L
Linus Torvalds 已提交
1535

L
Lennert Buytenhek 已提交
1536
static int mv643xx_eth_nway_reset(struct net_device *dev)
1537
{
1538
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
1539

1540 1541
	if (mp->phy == NULL)
		return -EINVAL;
L
Linus Torvalds 已提交
1542

1543
	return genphy_restart_aneg(mp->phy);
1544 1545
}

1546 1547
static u32 mv643xx_eth_get_link(struct net_device *dev)
{
1548
	return !!netif_carrier_ok(dev);
1549 1550
}

1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572
static int
mv643xx_eth_get_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
{
	struct mv643xx_eth_private *mp = netdev_priv(dev);

	ec->rx_coalesce_usecs = get_rx_coal(mp);
	ec->tx_coalesce_usecs = get_tx_coal(mp);

	return 0;
}

static int
mv643xx_eth_set_coalesce(struct net_device *dev, struct ethtool_coalesce *ec)
{
	struct mv643xx_eth_private *mp = netdev_priv(dev);

	set_rx_coal(mp, ec->rx_coalesce_usecs);
	set_tx_coal(mp, ec->tx_coalesce_usecs);

	return 0;
}

1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612
static void
mv643xx_eth_get_ringparam(struct net_device *dev, struct ethtool_ringparam *er)
{
	struct mv643xx_eth_private *mp = netdev_priv(dev);

	er->rx_max_pending = 4096;
	er->tx_max_pending = 4096;
	er->rx_mini_max_pending = 0;
	er->rx_jumbo_max_pending = 0;

	er->rx_pending = mp->rx_ring_size;
	er->tx_pending = mp->tx_ring_size;
	er->rx_mini_pending = 0;
	er->rx_jumbo_pending = 0;
}

static int
mv643xx_eth_set_ringparam(struct net_device *dev, struct ethtool_ringparam *er)
{
	struct mv643xx_eth_private *mp = netdev_priv(dev);

	if (er->rx_mini_pending || er->rx_jumbo_pending)
		return -EINVAL;

	mp->rx_ring_size = er->rx_pending < 4096 ? er->rx_pending : 4096;
	mp->tx_ring_size = er->tx_pending < 4096 ? er->tx_pending : 4096;

	if (netif_running(dev)) {
		mv643xx_eth_stop(dev);
		if (mv643xx_eth_open(dev)) {
			dev_printk(KERN_ERR, &dev->dev,
				   "fatal error on re-opening device after "
				   "ring param change\n");
			return -ENOMEM;
		}
	}

	return 0;
}

1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630
static u32
mv643xx_eth_get_rx_csum(struct net_device *dev)
{
	struct mv643xx_eth_private *mp = netdev_priv(dev);

	return !!(rdlp(mp, PORT_CONFIG) & 0x02000000);
}

static int
mv643xx_eth_set_rx_csum(struct net_device *dev, u32 rx_csum)
{
	struct mv643xx_eth_private *mp = netdev_priv(dev);

	wrlp(mp, PORT_CONFIG, rx_csum ? 0x02000000 : 0x00000000);

	return 0;
}

L
Lennert Buytenhek 已提交
1631 1632
static void mv643xx_eth_get_strings(struct net_device *dev,
				    uint32_t stringset, uint8_t *data)
1633 1634
{
	int i;
L
Linus Torvalds 已提交
1635

L
Lennert Buytenhek 已提交
1636 1637
	if (stringset == ETH_SS_STATS) {
		for (i = 0; i < ARRAY_SIZE(mv643xx_eth_stats); i++) {
1638
			memcpy(data + i * ETH_GSTRING_LEN,
1639
				mv643xx_eth_stats[i].stat_string,
1640
				ETH_GSTRING_LEN);
1641 1642 1643
		}
	}
}
L
Linus Torvalds 已提交
1644

L
Lennert Buytenhek 已提交
1645 1646 1647
static void mv643xx_eth_get_ethtool_stats(struct net_device *dev,
					  struct ethtool_stats *stats,
					  uint64_t *data)
1648
{
1649
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1650
	int i;
L
Linus Torvalds 已提交
1651

1652
	mv643xx_eth_get_stats(dev);
L
Lennert Buytenhek 已提交
1653
	mib_counters_update(mp);
1654
	mv643xx_eth_grab_lro_stats(mp);
L
Linus Torvalds 已提交
1655

1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
	for (i = 0; i < ARRAY_SIZE(mv643xx_eth_stats); i++) {
		const struct mv643xx_eth_stats *stat;
		void *p;

		stat = mv643xx_eth_stats + i;

		if (stat->netdev_off >= 0)
			p = ((void *)mp->dev) + stat->netdev_off;
		else
			p = ((void *)mp) + stat->mp_off;

		data[i] = (stat->sizeof_stat == 8) ?
				*(uint64_t *)p : *(uint32_t *)p;
L
Linus Torvalds 已提交
1669
	}
1670
}
L
Linus Torvalds 已提交
1671

L
Lennert Buytenhek 已提交
1672
static int mv643xx_eth_get_sset_count(struct net_device *dev, int sset)
1673
{
L
Lennert Buytenhek 已提交
1674
	if (sset == ETH_SS_STATS)
1675
		return ARRAY_SIZE(mv643xx_eth_stats);
L
Lennert Buytenhek 已提交
1676 1677

	return -EOPNOTSUPP;
1678
}
L
Linus Torvalds 已提交
1679

1680
static const struct ethtool_ops mv643xx_eth_ethtool_ops = {
L
Lennert Buytenhek 已提交
1681 1682 1683 1684 1685
	.get_settings		= mv643xx_eth_get_settings,
	.set_settings		= mv643xx_eth_set_settings,
	.get_drvinfo		= mv643xx_eth_get_drvinfo,
	.nway_reset		= mv643xx_eth_nway_reset,
	.get_link		= mv643xx_eth_get_link,
1686 1687
	.get_coalesce		= mv643xx_eth_get_coalesce,
	.set_coalesce		= mv643xx_eth_set_coalesce,
1688 1689
	.get_ringparam		= mv643xx_eth_get_ringparam,
	.set_ringparam		= mv643xx_eth_set_ringparam,
1690 1691
	.get_rx_csum		= mv643xx_eth_get_rx_csum,
	.set_rx_csum		= mv643xx_eth_set_rx_csum,
1692
	.set_tx_csum		= ethtool_op_set_tx_csum,
1693
	.set_sg			= ethtool_op_set_sg,
L
Lennert Buytenhek 已提交
1694 1695
	.get_strings		= mv643xx_eth_get_strings,
	.get_ethtool_stats	= mv643xx_eth_get_ethtool_stats,
1696 1697
	.get_flags		= ethtool_op_get_flags,
	.set_flags		= ethtool_op_set_flags,
1698
	.get_sset_count		= mv643xx_eth_get_sset_count,
1699
};
L
Linus Torvalds 已提交
1700

1701

1702
/* address handling *********************************************************/
1703
static void uc_addr_get(struct mv643xx_eth_private *mp, unsigned char *addr)
1704
{
1705 1706
	unsigned int mac_h = rdlp(mp, MAC_ADDR_HIGH);
	unsigned int mac_l = rdlp(mp, MAC_ADDR_LOW);
L
Linus Torvalds 已提交
1707

1708 1709 1710 1711 1712 1713
	addr[0] = (mac_h >> 24) & 0xff;
	addr[1] = (mac_h >> 16) & 0xff;
	addr[2] = (mac_h >> 8) & 0xff;
	addr[3] = mac_h & 0xff;
	addr[4] = (mac_l >> 8) & 0xff;
	addr[5] = mac_l & 0xff;
1714
}
L
Linus Torvalds 已提交
1715

1716
static void uc_addr_set(struct mv643xx_eth_private *mp, unsigned char *addr)
1717
{
1718 1719 1720
	wrlp(mp, MAC_ADDR_HIGH,
		(addr[0] << 24) | (addr[1] << 16) | (addr[2] << 8) | addr[3]);
	wrlp(mp, MAC_ADDR_LOW, (addr[4] << 8) | addr[5]);
1721
}
1722

1723
static u32 uc_addr_filter_mask(struct net_device *dev)
1724
{
1725 1726
	struct dev_addr_list *uc_ptr;
	u32 nibbles;
L
Linus Torvalds 已提交
1727

1728 1729
	if (dev->flags & IFF_PROMISC)
		return 0;
L
Linus Torvalds 已提交
1730

1731 1732 1733 1734 1735 1736
	nibbles = 1 << (dev->dev_addr[5] & 0x0f);
	for (uc_ptr = dev->uc_list; uc_ptr != NULL; uc_ptr = uc_ptr->next) {
		if (memcmp(dev->dev_addr, uc_ptr->da_addr, 5))
			return 0;
		if ((dev->dev_addr[5] ^ uc_ptr->da_addr[5]) & 0xf0)
			return 0;
1737

1738 1739
		nibbles |= 1 << (uc_ptr->da_addr[5] & 0x0f);
	}
L
Linus Torvalds 已提交
1740

1741
	return nibbles;
L
Linus Torvalds 已提交
1742 1743
}

1744
static void mv643xx_eth_program_unicast_filter(struct net_device *dev)
L
Linus Torvalds 已提交
1745
{
1746
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1747 1748 1749
	u32 port_config;
	u32 nibbles;
	int i;
L
Linus Torvalds 已提交
1750

1751
	uc_addr_set(mp, dev->dev_addr);
L
Linus Torvalds 已提交
1752

1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780
	port_config = rdlp(mp, PORT_CONFIG);
	nibbles = uc_addr_filter_mask(dev);
	if (!nibbles) {
		port_config |= UNICAST_PROMISCUOUS_MODE;
		wrlp(mp, PORT_CONFIG, port_config);
		return;
	}

	for (i = 0; i < 16; i += 4) {
		int off = UNICAST_TABLE(mp->port_num) + i;
		u32 v;

		v = 0;
		if (nibbles & 1)
			v |= 0x00000001;
		if (nibbles & 2)
			v |= 0x00000100;
		if (nibbles & 4)
			v |= 0x00010000;
		if (nibbles & 8)
			v |= 0x01000000;
		nibbles >>= 4;

		wrl(mp, off, v);
	}

	port_config &= ~UNICAST_PROMISCUOUS_MODE;
	wrlp(mp, PORT_CONFIG, port_config);
L
Linus Torvalds 已提交
1781 1782
}

1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799 1800
static int addr_crc(unsigned char *addr)
{
	int crc = 0;
	int i;

	for (i = 0; i < 6; i++) {
		int j;

		crc = (crc ^ addr[i]) << 8;
		for (j = 7; j >= 0; j--) {
			if (crc & (0x100 << j))
				crc ^= 0x107 << j;
		}
	}

	return crc;
}

1801
static void mv643xx_eth_program_multicast_filter(struct net_device *dev)
L
Linus Torvalds 已提交
1802
{
L
Lennert Buytenhek 已提交
1803
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1804 1805
	u32 *mc_spec;
	u32 *mc_other;
L
Lennert Buytenhek 已提交
1806 1807
	struct dev_addr_list *addr;
	int i;
1808

L
Lennert Buytenhek 已提交
1809
	if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
1810 1811 1812
		int port_num;
		u32 accept;
		int i;
1813

1814 1815 1816
oom:
		port_num = mp->port_num;
		accept = 0x01010101;
L
Lennert Buytenhek 已提交
1817 1818 1819
		for (i = 0; i < 0x100; i += 4) {
			wrl(mp, SPECIAL_MCAST_TABLE(port_num) + i, accept);
			wrl(mp, OTHER_MCAST_TABLE(port_num) + i, accept);
1820 1821 1822
		}
		return;
	}
1823

1824
	mc_spec = kmalloc(0x200, GFP_ATOMIC);
1825 1826 1827 1828 1829 1830
	if (mc_spec == NULL)
		goto oom;
	mc_other = mc_spec + (0x100 >> 2);

	memset(mc_spec, 0, 0x100);
	memset(mc_other, 0, 0x100);
L
Linus Torvalds 已提交
1831

L
Lennert Buytenhek 已提交
1832 1833
	for (addr = dev->mc_list; addr != NULL; addr = addr->next) {
		u8 *a = addr->da_addr;
1834 1835
		u32 *table;
		int entry;
L
Linus Torvalds 已提交
1836

L
Lennert Buytenhek 已提交
1837
		if (memcmp(a, "\x01\x00\x5e\x00\x00", 5) == 0) {
1838 1839
			table = mc_spec;
			entry = a[5];
L
Lennert Buytenhek 已提交
1840
		} else {
1841 1842
			table = mc_other;
			entry = addr_crc(a);
L
Lennert Buytenhek 已提交
1843
		}
1844

1845
		table[entry >> 2] |= 1 << (8 * (entry & 3));
L
Lennert Buytenhek 已提交
1846
	}
1847 1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869 1870 1871 1872

	for (i = 0; i < 0x100; i += 4) {
		wrl(mp, SPECIAL_MCAST_TABLE(mp->port_num) + i, mc_spec[i >> 2]);
		wrl(mp, OTHER_MCAST_TABLE(mp->port_num) + i, mc_other[i >> 2]);
	}

	kfree(mc_spec);
}

static void mv643xx_eth_set_rx_mode(struct net_device *dev)
{
	mv643xx_eth_program_unicast_filter(dev);
	mv643xx_eth_program_multicast_filter(dev);
}

static int mv643xx_eth_set_mac_address(struct net_device *dev, void *addr)
{
	struct sockaddr *sa = addr;

	memcpy(dev->dev_addr, sa->sa_data, ETH_ALEN);

	netif_addr_lock_bh(dev);
	mv643xx_eth_program_unicast_filter(dev);
	netif_addr_unlock_bh(dev);

	return 0;
1873
}
1874 1875


1876
/* rx/tx queue initialisation ***********************************************/
1877
static int rxq_init(struct mv643xx_eth_private *mp, int index)
1878
{
1879
	struct rx_queue *rxq = mp->rxq + index;
1880 1881
	struct rx_desc *rx_desc;
	int size;
1882 1883
	int i;

1884 1885
	rxq->index = index;

1886
	rxq->rx_ring_size = mp->rx_ring_size;
1887 1888 1889 1890 1891 1892 1893

	rxq->rx_desc_count = 0;
	rxq->rx_curr_desc = 0;
	rxq->rx_used_desc = 0;

	size = rxq->rx_ring_size * sizeof(struct rx_desc);

1894
	if (index == 0 && size <= mp->rx_desc_sram_size) {
1895 1896 1897 1898 1899 1900 1901
		rxq->rx_desc_area = ioremap(mp->rx_desc_sram_addr,
						mp->rx_desc_sram_size);
		rxq->rx_desc_dma = mp->rx_desc_sram_addr;
	} else {
		rxq->rx_desc_area = dma_alloc_coherent(NULL, size,
							&rxq->rx_desc_dma,
							GFP_KERNEL);
1902 1903
	}

1904 1905 1906 1907 1908 1909
	if (rxq->rx_desc_area == NULL) {
		dev_printk(KERN_ERR, &mp->dev->dev,
			   "can't allocate rx ring (%d bytes)\n", size);
		goto out;
	}
	memset(rxq->rx_desc_area, 0, size);
L
Linus Torvalds 已提交
1910

1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921
	rxq->rx_desc_area_size = size;
	rxq->rx_skb = kmalloc(rxq->rx_ring_size * sizeof(*rxq->rx_skb),
								GFP_KERNEL);
	if (rxq->rx_skb == NULL) {
		dev_printk(KERN_ERR, &mp->dev->dev,
			   "can't allocate rx skb ring\n");
		goto out_free;
	}

	rx_desc = (struct rx_desc *)rxq->rx_desc_area;
	for (i = 0; i < rxq->rx_ring_size; i++) {
1922 1923 1924 1925 1926 1927
		int nexti;

		nexti = i + 1;
		if (nexti == rxq->rx_ring_size)
			nexti = 0;

1928 1929 1930 1931
		rx_desc[i].next_desc_ptr = rxq->rx_desc_dma +
					nexti * sizeof(struct rx_desc);
	}

1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944
	rxq->lro_mgr.dev = mp->dev;
	memset(&rxq->lro_mgr.stats, 0, sizeof(rxq->lro_mgr.stats));
	rxq->lro_mgr.features = LRO_F_NAPI;
	rxq->lro_mgr.ip_summed = CHECKSUM_UNNECESSARY;
	rxq->lro_mgr.ip_summed_aggr = CHECKSUM_UNNECESSARY;
	rxq->lro_mgr.max_desc = ARRAY_SIZE(rxq->lro_arr);
	rxq->lro_mgr.max_aggr = 32;
	rxq->lro_mgr.frag_align_pad = 0;
	rxq->lro_mgr.lro_arr = rxq->lro_arr;
	rxq->lro_mgr.get_skb_header = mv643xx_get_skb_header;

	memset(&rxq->lro_arr, 0, sizeof(rxq->lro_arr));

1945 1946 1947 1948
	return 0;


out_free:
1949
	if (index == 0 && size <= mp->rx_desc_sram_size)
1950 1951 1952 1953 1954 1955 1956 1957
		iounmap(rxq->rx_desc_area);
	else
		dma_free_coherent(NULL, size,
				  rxq->rx_desc_area,
				  rxq->rx_desc_dma);

out:
	return -ENOMEM;
1958
}
1959

1960
static void rxq_deinit(struct rx_queue *rxq)
1961
{
1962 1963 1964 1965
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	int i;

	rxq_disable(rxq);
1966

1967 1968 1969 1970
	for (i = 0; i < rxq->rx_ring_size; i++) {
		if (rxq->rx_skb[i]) {
			dev_kfree_skb(rxq->rx_skb[i]);
			rxq->rx_desc_count--;
L
Linus Torvalds 已提交
1971
		}
1972
	}
L
Linus Torvalds 已提交
1973

1974 1975 1976 1977 1978 1979
	if (rxq->rx_desc_count) {
		dev_printk(KERN_ERR, &mp->dev->dev,
			   "error freeing rx ring -- %d skbs stuck\n",
			   rxq->rx_desc_count);
	}

1980
	if (rxq->index == 0 &&
1981
	    rxq->rx_desc_area_size <= mp->rx_desc_sram_size)
1982
		iounmap(rxq->rx_desc_area);
1983
	else
1984 1985 1986 1987
		dma_free_coherent(NULL, rxq->rx_desc_area_size,
				  rxq->rx_desc_area, rxq->rx_desc_dma);

	kfree(rxq->rx_skb);
1988
}
L
Linus Torvalds 已提交
1989

1990
static int txq_init(struct mv643xx_eth_private *mp, int index)
1991
{
1992
	struct tx_queue *txq = mp->txq + index;
1993 1994
	struct tx_desc *tx_desc;
	int size;
1995
	int i;
L
Linus Torvalds 已提交
1996

1997 1998
	txq->index = index;

1999
	txq->tx_ring_size = mp->tx_ring_size;
2000 2001 2002 2003 2004 2005 2006

	txq->tx_desc_count = 0;
	txq->tx_curr_desc = 0;
	txq->tx_used_desc = 0;

	size = txq->tx_ring_size * sizeof(struct tx_desc);

2007
	if (index == 0 && size <= mp->tx_desc_sram_size) {
2008 2009 2010 2011 2012 2013 2014 2015 2016 2017 2018 2019
		txq->tx_desc_area = ioremap(mp->tx_desc_sram_addr,
						mp->tx_desc_sram_size);
		txq->tx_desc_dma = mp->tx_desc_sram_addr;
	} else {
		txq->tx_desc_area = dma_alloc_coherent(NULL, size,
							&txq->tx_desc_dma,
							GFP_KERNEL);
	}

	if (txq->tx_desc_area == NULL) {
		dev_printk(KERN_ERR, &mp->dev->dev,
			   "can't allocate tx ring (%d bytes)\n", size);
2020
		return -ENOMEM;
2021
	}
2022 2023 2024 2025 2026 2027
	memset(txq->tx_desc_area, 0, size);

	txq->tx_desc_area_size = size;

	tx_desc = (struct tx_desc *)txq->tx_desc_area;
	for (i = 0; i < txq->tx_ring_size; i++) {
2028
		struct tx_desc *txd = tx_desc + i;
2029 2030 2031 2032 2033
		int nexti;

		nexti = i + 1;
		if (nexti == txq->tx_ring_size)
			nexti = 0;
2034 2035 2036

		txd->cmd_sts = 0;
		txd->next_desc_ptr = txq->tx_desc_dma +
2037 2038 2039
					nexti * sizeof(struct tx_desc);
	}

2040
	skb_queue_head_init(&txq->tx_skb);
2041

2042
	return 0;
2043
}
L
Linus Torvalds 已提交
2044

2045
static void txq_deinit(struct tx_queue *txq)
2046
{
2047
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
2048

2049
	txq_disable(txq);
2050
	txq_reclaim(txq, txq->tx_ring_size, 1);
L
Linus Torvalds 已提交
2051

2052
	BUG_ON(txq->tx_used_desc != txq->tx_curr_desc);
L
Linus Torvalds 已提交
2053

2054
	if (txq->index == 0 &&
2055
	    txq->tx_desc_area_size <= mp->tx_desc_sram_size)
2056
		iounmap(txq->tx_desc_area);
2057
	else
2058 2059
		dma_free_coherent(NULL, txq->tx_desc_area_size,
				  txq->tx_desc_area, txq->tx_desc_dma);
2060
}
L
Linus Torvalds 已提交
2061 2062


2063
/* netdev ops and related ***************************************************/
2064 2065 2066 2067 2068
static int mv643xx_eth_collect_events(struct mv643xx_eth_private *mp)
{
	u32 int_cause;
	u32 int_cause_ext;

2069
	int_cause = rdlp(mp, INT_CAUSE) & (INT_TX_END | INT_RX | INT_EXT);
2070 2071 2072 2073 2074
	if (int_cause == 0)
		return 0;

	int_cause_ext = 0;
	if (int_cause & INT_EXT)
2075
		int_cause_ext = rdlp(mp, INT_CAUSE_EXT);
2076 2077 2078

	int_cause &= INT_TX_END | INT_RX;
	if (int_cause) {
2079
		wrlp(mp, INT_CAUSE, ~int_cause);
2080
		mp->work_tx_end |= ((int_cause & INT_TX_END) >> 19) &
2081
				~(rdlp(mp, TXQ_COMMAND) & 0xff);
2082 2083 2084 2085 2086
		mp->work_rx |= (int_cause & INT_RX) >> 2;
	}

	int_cause_ext &= INT_EXT_LINK_PHY | INT_EXT_TX;
	if (int_cause_ext) {
2087
		wrlp(mp, INT_CAUSE_EXT, ~int_cause_ext);
2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103
		if (int_cause_ext & INT_EXT_LINK_PHY)
			mp->work_link = 1;
		mp->work_tx |= int_cause_ext & INT_EXT_TX;
	}

	return 1;
}

static irqreturn_t mv643xx_eth_irq(int irq, void *dev_id)
{
	struct net_device *dev = (struct net_device *)dev_id;
	struct mv643xx_eth_private *mp = netdev_priv(dev);

	if (unlikely(!mv643xx_eth_collect_events(mp)))
		return IRQ_NONE;

2104
	wrlp(mp, INT_MASK, 0);
2105 2106 2107 2108 2109
	napi_schedule(&mp->napi);

	return IRQ_HANDLED;
}

2110 2111 2112 2113 2114 2115 2116 2117
static void handle_link_event(struct mv643xx_eth_private *mp)
{
	struct net_device *dev = mp->dev;
	u32 port_status;
	int speed;
	int duplex;
	int fc;

2118
	port_status = rdlp(mp, PORT_STATUS);
2119 2120 2121 2122 2123 2124 2125 2126
	if (!(port_status & LINK_UP)) {
		if (netif_carrier_ok(dev)) {
			int i;

			printk(KERN_INFO "%s: link down\n", dev->name);

			netif_carrier_off(dev);

2127
			for (i = 0; i < mp->txq_count; i++) {
2128 2129
				struct tx_queue *txq = mp->txq + i;

2130
				txq_reclaim(txq, txq->tx_ring_size, 1);
2131
				txq_reset_hw_ptr(txq);
2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158
			}
		}
		return;
	}

	switch (port_status & PORT_SPEED_MASK) {
	case PORT_SPEED_10:
		speed = 10;
		break;
	case PORT_SPEED_100:
		speed = 100;
		break;
	case PORT_SPEED_1000:
		speed = 1000;
		break;
	default:
		speed = -1;
		break;
	}
	duplex = (port_status & FULL_DUPLEX) ? 1 : 0;
	fc = (port_status & FLOW_CONTROL_ENABLED) ? 1 : 0;

	printk(KERN_INFO "%s: link up, %d Mb/s, %s duplex, "
			 "flow control %sabled\n", dev->name,
			 speed, duplex ? "full" : "half",
			 fc ? "en" : "dis");

2159
	if (!netif_carrier_ok(dev))
2160 2161 2162
		netif_carrier_on(dev);
}

2163
static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
2164
{
2165 2166
	struct mv643xx_eth_private *mp;
	int work_done;
2167

2168
	mp = container_of(napi, struct mv643xx_eth_private, napi);
L
Lennert Buytenhek 已提交
2169

2170 2171
	mp->work_rx_refill |= mp->work_rx_oom;
	mp->work_rx_oom = 0;
L
Linus Torvalds 已提交
2172

2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183
	work_done = 0;
	while (work_done < budget) {
		u8 queue_mask;
		int queue;
		int work_tbd;

		if (mp->work_link) {
			mp->work_link = 0;
			handle_link_event(mp);
			continue;
		}
L
Linus Torvalds 已提交
2184

2185 2186 2187 2188 2189 2190 2191
		queue_mask = mp->work_tx | mp->work_tx_end |
				mp->work_rx | mp->work_rx_refill;
		if (!queue_mask) {
			if (mv643xx_eth_collect_events(mp))
				continue;
			break;
		}
L
Linus Torvalds 已提交
2192

2193 2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207 2208 2209 2210 2211
		queue = fls(queue_mask) - 1;
		queue_mask = 1 << queue;

		work_tbd = budget - work_done;
		if (work_tbd > 16)
			work_tbd = 16;

		if (mp->work_tx_end & queue_mask) {
			txq_kick(mp->txq + queue);
		} else if (mp->work_tx & queue_mask) {
			work_done += txq_reclaim(mp->txq + queue, work_tbd, 0);
			txq_maybe_wake(mp->txq + queue);
		} else if (mp->work_rx & queue_mask) {
			work_done += rxq_process(mp->rxq + queue, work_tbd);
		} else if (mp->work_rx_refill & queue_mask) {
			work_done += rxq_refill(mp->rxq + queue, work_tbd);
		} else {
			BUG();
		}
2212
	}
L
Lennert Buytenhek 已提交
2213

2214 2215 2216 2217
	if (work_done < budget) {
		if (mp->work_rx_oom)
			mod_timer(&mp->rx_oom, jiffies + (HZ / 10));
		napi_complete(napi);
2218
		wrlp(mp, INT_MASK, INT_TX_END | INT_RX | INT_EXT);
2219
	}
2220

2221 2222
	return work_done;
}
2223

2224 2225 2226
static inline void oom_timer_wrapper(unsigned long data)
{
	struct mv643xx_eth_private *mp = (void *)data;
L
Linus Torvalds 已提交
2227

2228
	napi_schedule(&mp->napi);
L
Linus Torvalds 已提交
2229 2230
}

2231
static void phy_reset(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2232
{
2233 2234
	int data;

2235
	data = phy_read(mp->phy, MII_BMCR);
2236 2237
	if (data < 0)
		return;
L
Linus Torvalds 已提交
2238

2239
	data |= BMCR_RESET;
2240
	if (phy_write(mp->phy, MII_BMCR, data) < 0)
2241
		return;
L
Linus Torvalds 已提交
2242

2243
	do {
2244
		data = phy_read(mp->phy, MII_BMCR);
2245
	} while (data >= 0 && data & BMCR_RESET);
L
Linus Torvalds 已提交
2246 2247
}

L
Lennert Buytenhek 已提交
2248
static void port_start(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2249
{
2250
	u32 pscr;
2251
	int i;
L
Linus Torvalds 已提交
2252

2253 2254 2255
	/*
	 * Perform PHY reset, if there is a PHY.
	 */
2256
	if (mp->phy != NULL) {
2257 2258 2259 2260 2261 2262
		struct ethtool_cmd cmd;

		mv643xx_eth_get_settings(mp->dev, &cmd);
		phy_reset(mp);
		mv643xx_eth_set_settings(mp->dev, &cmd);
	}
L
Linus Torvalds 已提交
2263

2264 2265 2266
	/*
	 * Configure basic link parameters.
	 */
2267
	pscr = rdlp(mp, PORT_SERIAL_CONTROL);
2268 2269

	pscr |= SERIAL_PORT_ENABLE;
2270
	wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2271 2272

	pscr |= DO_NOT_FORCE_LINK_FAIL;
2273
	if (mp->phy == NULL)
2274
		pscr |= FORCE_LINK_PASS;
2275
	wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2276

2277
	wrlp(mp, SDMA_CONFIG, PORT_SDMA_CONFIG_DEFAULT_VALUE);
2278

2279 2280 2281
	/*
	 * Configure TX path and queues.
	 */
2282
	tx_set_rate(mp, 1000000000, 16777216);
2283
	for (i = 0; i < mp->txq_count; i++) {
2284
		struct tx_queue *txq = mp->txq + i;
2285

2286
		txq_reset_hw_ptr(txq);
2287 2288
		txq_set_rate(txq, 1000000000, 16777216);
		txq_set_fixed_prio_mode(txq);
2289 2290
	}

L
Lennert Buytenhek 已提交
2291 2292 2293
	/*
	 * Add configured unicast address to address filter table.
	 */
2294
	mv643xx_eth_program_unicast_filter(mp->dev);
L
Linus Torvalds 已提交
2295

2296 2297
	/*
	 * Receive all unmatched unicast, TCP, UDP, BPDU and broadcast
2298 2299
	 * frames to RX queue #0, and include the pseudo-header when
	 * calculating receive checksums.
2300
	 */
2301
	wrlp(mp, PORT_CONFIG, 0x02000000);
2302

2303 2304 2305
	/*
	 * Treat BPDUs as normal multicasts, and disable partition mode.
	 */
2306
	wrlp(mp, PORT_CONFIG_EXT, 0x00000000);
2307

2308
	/*
2309
	 * Enable the receive queues.
2310
	 */
2311
	for (i = 0; i < mp->rxq_count; i++) {
2312
		struct rx_queue *rxq = mp->rxq + i;
2313
		u32 addr;
L
Linus Torvalds 已提交
2314

2315 2316
		addr = (u32)rxq->rx_desc_dma;
		addr += rxq->rx_curr_desc * sizeof(struct rx_desc);
2317
		wrlp(mp, RXQ_CURRENT_DESC_PTR(i), addr);
L
Linus Torvalds 已提交
2318

2319 2320
		rxq_enable(rxq);
	}
L
Linus Torvalds 已提交
2321 2322
}

2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342
static void mv643xx_eth_recalc_skb_size(struct mv643xx_eth_private *mp)
{
	int skb_size;

	/*
	 * Reserve 2+14 bytes for an ethernet header (the hardware
	 * automatically prepends 2 bytes of dummy data to each
	 * received packet), 16 bytes for up to four VLAN tags, and
	 * 4 bytes for the trailing FCS -- 36 bytes total.
	 */
	skb_size = mp->dev->mtu + 36;

	/*
	 * Make sure that the skb size is a multiple of 8 bytes, as
	 * the lower three bits of the receive descriptor's buffer
	 * size field are ignored by the hardware.
	 */
	mp->skb_size = (skb_size + 7) & ~7;
}

2343
static int mv643xx_eth_open(struct net_device *dev)
2344
{
2345
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2346
	int err;
2347
	int i;
2348

2349 2350 2351
	wrlp(mp, INT_CAUSE, 0);
	wrlp(mp, INT_CAUSE_EXT, 0);
	rdlp(mp, INT_CAUSE_EXT);
2352

L
Lennert Buytenhek 已提交
2353
	err = request_irq(dev->irq, mv643xx_eth_irq,
2354
			  IRQF_SHARED, dev->name, dev);
2355
	if (err) {
L
Lennert Buytenhek 已提交
2356
		dev_printk(KERN_ERR, &dev->dev, "can't assign irq\n");
2357
		return -EAGAIN;
2358 2359
	}

2360 2361
	mv643xx_eth_recalc_skb_size(mp);

2362 2363
	napi_enable(&mp->napi);

2364 2365
	skb_queue_head_init(&mp->rx_recycle);

2366
	for (i = 0; i < mp->rxq_count; i++) {
2367 2368 2369
		err = rxq_init(mp, i);
		if (err) {
			while (--i >= 0)
2370
				rxq_deinit(mp->rxq + i);
2371 2372 2373
			goto out;
		}

2374
		rxq_refill(mp->rxq + i, INT_MAX);
2375 2376
	}

2377
	if (mp->work_rx_oom) {
2378 2379
		mp->rx_oom.expires = jiffies + (HZ / 10);
		add_timer(&mp->rx_oom);
2380
	}
2381

2382
	for (i = 0; i < mp->txq_count; i++) {
2383 2384 2385
		err = txq_init(mp, i);
		if (err) {
			while (--i >= 0)
2386
				txq_deinit(mp->txq + i);
2387 2388 2389
			goto out_free;
		}
	}
2390

L
Lennert Buytenhek 已提交
2391
	port_start(mp);
2392

2393 2394
	wrlp(mp, INT_MASK_EXT, INT_EXT_LINK_PHY | INT_EXT_TX);
	wrlp(mp, INT_MASK, INT_TX_END | INT_RX | INT_EXT);
2395

2396 2397
	return 0;

2398

L
Lennert Buytenhek 已提交
2399
out_free:
2400 2401
	for (i = 0; i < mp->rxq_count; i++)
		rxq_deinit(mp->rxq + i);
L
Lennert Buytenhek 已提交
2402
out:
2403 2404 2405
	free_irq(dev->irq, dev);

	return err;
2406 2407
}

2408
static void port_reset(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2409
{
L
Lennert Buytenhek 已提交
2410
	unsigned int data;
2411
	int i;
L
Linus Torvalds 已提交
2412

2413 2414 2415 2416
	for (i = 0; i < mp->rxq_count; i++)
		rxq_disable(mp->rxq + i);
	for (i = 0; i < mp->txq_count; i++)
		txq_disable(mp->txq + i);
2417 2418

	while (1) {
2419
		u32 ps = rdlp(mp, PORT_STATUS);
2420 2421 2422

		if ((ps & (TX_IN_PROGRESS | TX_FIFO_EMPTY)) == TX_FIFO_EMPTY)
			break;
2423
		udelay(10);
2424
	}
L
Linus Torvalds 已提交
2425

2426
	/* Reset the Enable bit in the Configuration Register */
2427
	data = rdlp(mp, PORT_SERIAL_CONTROL);
L
Lennert Buytenhek 已提交
2428 2429 2430
	data &= ~(SERIAL_PORT_ENABLE		|
		  DO_NOT_FORCE_LINK_FAIL	|
		  FORCE_LINK_PASS);
2431
	wrlp(mp, PORT_SERIAL_CONTROL, data);
L
Linus Torvalds 已提交
2432 2433
}

2434
static int mv643xx_eth_stop(struct net_device *dev)
L
Linus Torvalds 已提交
2435
{
2436
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2437
	int i;
L
Linus Torvalds 已提交
2438

2439
	wrlp(mp, INT_MASK_EXT, 0x00000000);
2440 2441
	wrlp(mp, INT_MASK, 0x00000000);
	rdlp(mp, INT_MASK);
L
Linus Torvalds 已提交
2442

2443
	napi_disable(&mp->napi);
2444

2445 2446
	del_timer_sync(&mp->rx_oom);

2447
	netif_carrier_off(dev);
L
Linus Torvalds 已提交
2448

L
Lennert Buytenhek 已提交
2449 2450
	free_irq(dev->irq, dev);

2451
	port_reset(mp);
2452
	mv643xx_eth_get_stats(dev);
L
Lennert Buytenhek 已提交
2453
	mib_counters_update(mp);
2454
	del_timer_sync(&mp->mib_counters_timer);
L
Linus Torvalds 已提交
2455

2456 2457
	skb_queue_purge(&mp->rx_recycle);

2458 2459 2460 2461
	for (i = 0; i < mp->rxq_count; i++)
		rxq_deinit(mp->rxq + i);
	for (i = 0; i < mp->txq_count; i++)
		txq_deinit(mp->txq + i);
L
Linus Torvalds 已提交
2462

2463
	return 0;
L
Linus Torvalds 已提交
2464 2465
}

L
Lennert Buytenhek 已提交
2466
static int mv643xx_eth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
L
Linus Torvalds 已提交
2467
{
2468
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
2469

2470 2471
	if (mp->phy != NULL)
		return phy_mii_ioctl(mp->phy, if_mii(ifr), cmd);
2472 2473

	return -EOPNOTSUPP;
L
Linus Torvalds 已提交
2474 2475
}

2476
static int mv643xx_eth_change_mtu(struct net_device *dev, int new_mtu)
L
Linus Torvalds 已提交
2477
{
2478 2479
	struct mv643xx_eth_private *mp = netdev_priv(dev);

L
Lennert Buytenhek 已提交
2480
	if (new_mtu < 64 || new_mtu > 9500)
2481
		return -EINVAL;
L
Linus Torvalds 已提交
2482

2483
	dev->mtu = new_mtu;
2484
	mv643xx_eth_recalc_skb_size(mp);
2485 2486
	tx_set_rate(mp, 1000000000, 16777216);

2487 2488
	if (!netif_running(dev))
		return 0;
L
Linus Torvalds 已提交
2489

2490 2491 2492 2493
	/*
	 * Stop and then re-open the interface. This will allocate RX
	 * skbs of the new MTU.
	 * There is a possible danger that the open will not succeed,
L
Lennert Buytenhek 已提交
2494
	 * due to memory being full.
2495 2496 2497
	 */
	mv643xx_eth_stop(dev);
	if (mv643xx_eth_open(dev)) {
L
Lennert Buytenhek 已提交
2498 2499 2500
		dev_printk(KERN_ERR, &dev->dev,
			   "fatal error on re-opening device after "
			   "MTU change\n");
2501 2502 2503
	}

	return 0;
L
Linus Torvalds 已提交
2504 2505
}

L
Lennert Buytenhek 已提交
2506
static void tx_timeout_task(struct work_struct *ugly)
L
Linus Torvalds 已提交
2507
{
L
Lennert Buytenhek 已提交
2508
	struct mv643xx_eth_private *mp;
L
Linus Torvalds 已提交
2509

L
Lennert Buytenhek 已提交
2510 2511
	mp = container_of(ugly, struct mv643xx_eth_private, tx_timeout_task);
	if (netif_running(mp->dev)) {
2512
		netif_tx_stop_all_queues(mp->dev);
L
Lennert Buytenhek 已提交
2513 2514
		port_reset(mp);
		port_start(mp);
2515
		netif_tx_wake_all_queues(mp->dev);
L
Lennert Buytenhek 已提交
2516
	}
2517 2518 2519
}

static void mv643xx_eth_tx_timeout(struct net_device *dev)
L
Linus Torvalds 已提交
2520
{
2521
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
2522

L
Lennert Buytenhek 已提交
2523
	dev_printk(KERN_INFO, &dev->dev, "tx timeout\n");
2524

2525
	schedule_work(&mp->tx_timeout_task);
L
Linus Torvalds 已提交
2526 2527
}

2528
#ifdef CONFIG_NET_POLL_CONTROLLER
L
Lennert Buytenhek 已提交
2529
static void mv643xx_eth_netpoll(struct net_device *dev)
2530
{
L
Lennert Buytenhek 已提交
2531
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2532

2533 2534
	wrlp(mp, INT_MASK, 0x00000000);
	rdlp(mp, INT_MASK);
2535

L
Lennert Buytenhek 已提交
2536
	mv643xx_eth_irq(dev->irq, dev);
2537

2538
	wrlp(mp, INT_MASK, INT_TX_END | INT_RX | INT_EXT);
2539
}
2540
#endif
2541 2542


2543
/* platform glue ************************************************************/
2544 2545 2546
static void
mv643xx_eth_conf_mbus_windows(struct mv643xx_eth_shared_private *msp,
			      struct mbus_dram_target_info *dram)
2547
{
2548
	void __iomem *base = msp->base;
2549 2550 2551
	u32 win_enable;
	u32 win_protect;
	int i;
2552

2553 2554 2555 2556 2557
	for (i = 0; i < 6; i++) {
		writel(0, base + WINDOW_BASE(i));
		writel(0, base + WINDOW_SIZE(i));
		if (i < 4)
			writel(0, base + WINDOW_REMAP_HIGH(i));
2558 2559
	}

2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576
	win_enable = 0x3f;
	win_protect = 0;

	for (i = 0; i < dram->num_cs; i++) {
		struct mbus_dram_window *cs = dram->cs + i;

		writel((cs->base & 0xffff0000) |
			(cs->mbus_attr << 8) |
			dram->mbus_dram_target_id, base + WINDOW_BASE(i));
		writel((cs->size - 1) & 0xffff0000, base + WINDOW_SIZE(i));

		win_enable &= ~(1 << i);
		win_protect |= 3 << (2 * i);
	}

	writel(win_enable, base + WINDOW_BAR_ENABLE);
	msp->win_protect = win_protect;
2577 2578
}

2579 2580 2581 2582 2583 2584 2585
static void infer_hw_params(struct mv643xx_eth_shared_private *msp)
{
	/*
	 * Check whether we have a 14-bit coal limit field in bits
	 * [21:8], or a 16-bit coal limit in bits [25,21:7] of the
	 * SDMA config register.
	 */
2586 2587
	writel(0x02000000, msp->base + 0x0400 + SDMA_CONFIG);
	if (readl(msp->base + 0x0400 + SDMA_CONFIG) & 0x02000000)
2588 2589 2590
		msp->extended_rx_coal_limit = 1;
	else
		msp->extended_rx_coal_limit = 0;
2591 2592

	/*
2593 2594 2595
	 * Check whether the MAC supports TX rate control, and if
	 * yes, whether its associated registers are in the old or
	 * the new place.
2596
	 */
2597 2598
	writel(1, msp->base + 0x0400 + TX_BW_MTU_MOVED);
	if (readl(msp->base + 0x0400 + TX_BW_MTU_MOVED) & 1) {
2599 2600
		msp->tx_bw_control = TX_BW_CONTROL_NEW_LAYOUT;
	} else {
2601 2602
		writel(7, msp->base + 0x0400 + TX_BW_RATE);
		if (readl(msp->base + 0x0400 + TX_BW_RATE) & 7)
2603 2604 2605 2606
			msp->tx_bw_control = TX_BW_CONTROL_OLD_LAYOUT;
		else
			msp->tx_bw_control = TX_BW_CONTROL_ABSENT;
	}
2607 2608
}

2609
static int mv643xx_eth_shared_probe(struct platform_device *pdev)
2610
{
L
Lennert Buytenhek 已提交
2611
	static int mv643xx_eth_version_printed;
2612
	struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
2613
	struct mv643xx_eth_shared_private *msp;
2614 2615
	struct resource *res;
	int ret;
2616

2617
	if (!mv643xx_eth_version_printed++)
2618 2619
		printk(KERN_NOTICE "MV-643xx 10/100/1000 ethernet "
			"driver version %s\n", mv643xx_eth_driver_version);
2620

2621 2622 2623 2624
	ret = -EINVAL;
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL)
		goto out;
2625

2626 2627 2628 2629 2630 2631
	ret = -ENOMEM;
	msp = kmalloc(sizeof(*msp), GFP_KERNEL);
	if (msp == NULL)
		goto out;
	memset(msp, 0, sizeof(*msp));

2632 2633
	msp->base = ioremap(res->start, res->end - res->start + 1);
	if (msp->base == NULL)
2634 2635
		goto out_free;

2636 2637 2638 2639
	/*
	 * Set up and register SMI bus.
	 */
	if (pd == NULL || pd->shared_smi == NULL) {
2640 2641
		msp->smi_bus = mdiobus_alloc();
		if (msp->smi_bus == NULL)
2642
			goto out_unmap;
2643 2644 2645 2646 2647 2648 2649 2650 2651 2652

		msp->smi_bus->priv = msp;
		msp->smi_bus->name = "mv643xx_eth smi";
		msp->smi_bus->read = smi_bus_read;
		msp->smi_bus->write = smi_bus_write,
		snprintf(msp->smi_bus->id, MII_BUS_ID_SIZE, "%d", pdev->id);
		msp->smi_bus->parent = &pdev->dev;
		msp->smi_bus->phy_mask = 0xffffffff;
		if (mdiobus_register(msp->smi_bus) < 0)
			goto out_free_mii_bus;
2653 2654
		msp->smi = msp;
	} else {
2655
		msp->smi = platform_get_drvdata(pd->shared_smi);
2656
	}
2657

2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675
	msp->err_interrupt = NO_IRQ;
	init_waitqueue_head(&msp->smi_busy_wait);

	/*
	 * Check whether the error interrupt is hooked up.
	 */
	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	if (res != NULL) {
		int err;

		err = request_irq(res->start, mv643xx_eth_err_irq,
				  IRQF_SHARED, "mv643xx_eth", msp);
		if (!err) {
			writel(ERR_INT_SMI_DONE, msp->base + ERR_INT_MASK);
			msp->err_interrupt = res->start;
		}
	}

2676 2677 2678 2679 2680 2681
	/*
	 * (Re-)program MBUS remapping windows if we are asked to.
	 */
	if (pd != NULL && pd->dram != NULL)
		mv643xx_eth_conf_mbus_windows(msp, pd->dram);

L
Lennert Buytenhek 已提交
2682 2683 2684 2685
	/*
	 * Detect hardware parameters.
	 */
	msp->t_clk = (pd != NULL && pd->t_clk != 0) ? pd->t_clk : 133000000;
2686
	infer_hw_params(msp);
L
Lennert Buytenhek 已提交
2687 2688 2689

	platform_set_drvdata(pdev, msp);

2690 2691
	return 0;

2692 2693
out_free_mii_bus:
	mdiobus_free(msp->smi_bus);
2694 2695
out_unmap:
	iounmap(msp->base);
2696 2697 2698 2699 2700 2701 2702 2703
out_free:
	kfree(msp);
out:
	return ret;
}

static int mv643xx_eth_shared_remove(struct platform_device *pdev)
{
2704
	struct mv643xx_eth_shared_private *msp = platform_get_drvdata(pdev);
2705
	struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
2706

2707 2708
	if (pd == NULL || pd->shared_smi == NULL) {
		mdiobus_unregister(msp->smi_bus);
2709
		mdiobus_free(msp->smi_bus);
2710
	}
2711 2712
	if (msp->err_interrupt != NO_IRQ)
		free_irq(msp->err_interrupt, msp);
2713
	iounmap(msp->base);
2714 2715 2716
	kfree(msp);

	return 0;
2717 2718
}

2719
static struct platform_driver mv643xx_eth_shared_driver = {
L
Lennert Buytenhek 已提交
2720 2721
	.probe		= mv643xx_eth_shared_probe,
	.remove		= mv643xx_eth_shared_remove,
2722
	.driver = {
L
Lennert Buytenhek 已提交
2723
		.name	= MV643XX_ETH_SHARED_NAME,
2724 2725 2726 2727
		.owner	= THIS_MODULE,
	},
};

2728
static void phy_addr_set(struct mv643xx_eth_private *mp, int phy_addr)
L
Linus Torvalds 已提交
2729
{
2730
	int addr_shift = 5 * mp->port_num;
L
Lennert Buytenhek 已提交
2731
	u32 data;
L
Linus Torvalds 已提交
2732

L
Lennert Buytenhek 已提交
2733 2734 2735 2736
	data = rdl(mp, PHY_ADDR);
	data &= ~(0x1f << addr_shift);
	data |= (phy_addr & 0x1f) << addr_shift;
	wrl(mp, PHY_ADDR, data);
L
Linus Torvalds 已提交
2737 2738
}

2739
static int phy_addr_get(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2740
{
L
Lennert Buytenhek 已提交
2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757
	unsigned int data;

	data = rdl(mp, PHY_ADDR);

	return (data >> (5 * mp->port_num)) & 0x1f;
}

static void set_params(struct mv643xx_eth_private *mp,
		       struct mv643xx_eth_platform_data *pd)
{
	struct net_device *dev = mp->dev;

	if (is_valid_ether_addr(pd->mac_addr))
		memcpy(dev->dev_addr, pd->mac_addr, 6);
	else
		uc_addr_get(mp, dev->dev_addr);

2758
	mp->rx_ring_size = DEFAULT_RX_QUEUE_SIZE;
L
Lennert Buytenhek 已提交
2759
	if (pd->rx_queue_size)
2760
		mp->rx_ring_size = pd->rx_queue_size;
L
Lennert Buytenhek 已提交
2761 2762
	mp->rx_desc_sram_addr = pd->rx_sram_addr;
	mp->rx_desc_sram_size = pd->rx_sram_size;
L
Linus Torvalds 已提交
2763

2764
	mp->rxq_count = pd->rx_queue_count ? : 1;
2765

2766
	mp->tx_ring_size = DEFAULT_TX_QUEUE_SIZE;
L
Lennert Buytenhek 已提交
2767
	if (pd->tx_queue_size)
2768
		mp->tx_ring_size = pd->tx_queue_size;
L
Lennert Buytenhek 已提交
2769 2770
	mp->tx_desc_sram_addr = pd->tx_sram_addr;
	mp->tx_desc_sram_size = pd->tx_sram_size;
2771

2772
	mp->txq_count = pd->tx_queue_count ? : 1;
L
Linus Torvalds 已提交
2773 2774
}

2775 2776
static struct phy_device *phy_scan(struct mv643xx_eth_private *mp,
				   int phy_addr)
L
Linus Torvalds 已提交
2777
{
2778
	struct mii_bus *bus = mp->shared->smi->smi_bus;
2779 2780 2781 2782
	struct phy_device *phydev;
	int start;
	int num;
	int i;
2783

2784 2785 2786 2787 2788 2789 2790
	if (phy_addr == MV643XX_ETH_PHY_ADDR_DEFAULT) {
		start = phy_addr_get(mp) & 0x1f;
		num = 32;
	} else {
		start = phy_addr & 0x1f;
		num = 1;
	}
2791

2792 2793 2794
	phydev = NULL;
	for (i = 0; i < num; i++) {
		int addr = (start + i) & 0x1f;
L
Lennert Buytenhek 已提交
2795

2796 2797
		if (bus->phy_map[addr] == NULL)
			mdiobus_scan(bus, addr);
L
Linus Torvalds 已提交
2798

2799 2800 2801 2802 2803 2804
		if (phydev == NULL) {
			phydev = bus->phy_map[addr];
			if (phydev != NULL)
				phy_addr_set(mp, addr);
		}
	}
L
Linus Torvalds 已提交
2805

2806
	return phydev;
L
Linus Torvalds 已提交
2807 2808
}

2809
static void phy_init(struct mv643xx_eth_private *mp, int speed, int duplex)
2810
{
2811
	struct phy_device *phy = mp->phy;
2812

L
Lennert Buytenhek 已提交
2813 2814
	phy_reset(mp);

2815
	phy_attach(mp->dev, dev_name(&phy->dev), 0, PHY_INTERFACE_MODE_GMII);
2816 2817 2818 2819 2820 2821

	if (speed == 0) {
		phy->autoneg = AUTONEG_ENABLE;
		phy->speed = 0;
		phy->duplex = 0;
		phy->advertising = phy->supported | ADVERTISED_Autoneg;
2822
	} else {
2823 2824 2825 2826
		phy->autoneg = AUTONEG_DISABLE;
		phy->advertising = 0;
		phy->speed = speed;
		phy->duplex = duplex;
2827
	}
2828
	phy_start_aneg(phy);
2829 2830
}

2831 2832 2833 2834
static void init_pscr(struct mv643xx_eth_private *mp, int speed, int duplex)
{
	u32 pscr;

2835
	pscr = rdlp(mp, PORT_SERIAL_CONTROL);
2836 2837
	if (pscr & SERIAL_PORT_ENABLE) {
		pscr &= ~SERIAL_PORT_ENABLE;
2838
		wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2839 2840 2841
	}

	pscr = MAX_RX_PACKET_9700BYTE | SERIAL_PORT_CONTROL_RESERVED;
2842
	if (mp->phy == NULL) {
2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854 2855
		pscr |= DISABLE_AUTO_NEG_SPEED_GMII;
		if (speed == SPEED_1000)
			pscr |= SET_GMII_SPEED_TO_1000;
		else if (speed == SPEED_100)
			pscr |= SET_MII_SPEED_TO_100;

		pscr |= DISABLE_AUTO_NEG_FOR_FLOW_CTRL;

		pscr |= DISABLE_AUTO_NEG_FOR_DUPLEX;
		if (duplex == DUPLEX_FULL)
			pscr |= SET_FULL_DUPLEX_MODE;
	}

2856
	wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2857 2858
}

2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872 2873
static const struct net_device_ops mv643xx_eth_netdev_ops = {
	.ndo_open		= mv643xx_eth_open,
	.ndo_stop		= mv643xx_eth_stop,
	.ndo_start_xmit		= mv643xx_eth_xmit,
	.ndo_set_rx_mode	= mv643xx_eth_set_rx_mode,
	.ndo_set_mac_address	= mv643xx_eth_set_mac_address,
	.ndo_do_ioctl		= mv643xx_eth_ioctl,
	.ndo_change_mtu		= mv643xx_eth_change_mtu,
	.ndo_tx_timeout		= mv643xx_eth_tx_timeout,
	.ndo_get_stats		= mv643xx_eth_get_stats,
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= mv643xx_eth_netpoll,
#endif
};

2874
static int mv643xx_eth_probe(struct platform_device *pdev)
L
Linus Torvalds 已提交
2875
{
2876
	struct mv643xx_eth_platform_data *pd;
2877
	struct mv643xx_eth_private *mp;
2878 2879
	struct net_device *dev;
	struct resource *res;
L
Lennert Buytenhek 已提交
2880
	int err;
L
Linus Torvalds 已提交
2881

2882 2883
	pd = pdev->dev.platform_data;
	if (pd == NULL) {
L
Lennert Buytenhek 已提交
2884 2885
		dev_printk(KERN_ERR, &pdev->dev,
			   "no mv643xx_eth_platform_data\n");
2886 2887
		return -ENODEV;
	}
L
Linus Torvalds 已提交
2888

2889
	if (pd->shared == NULL) {
L
Lennert Buytenhek 已提交
2890 2891
		dev_printk(KERN_ERR, &pdev->dev,
			   "no mv643xx_eth_platform_data->shared\n");
2892 2893
		return -ENODEV;
	}
2894

2895
	dev = alloc_etherdev_mq(sizeof(struct mv643xx_eth_private), 8);
2896 2897
	if (!dev)
		return -ENOMEM;
L
Linus Torvalds 已提交
2898

2899
	mp = netdev_priv(dev);
L
Lennert Buytenhek 已提交
2900 2901 2902
	platform_set_drvdata(pdev, mp);

	mp->shared = platform_get_drvdata(pd->shared);
2903
	mp->base = mp->shared->base + 0x0400 + (pd->port_number << 10);
L
Lennert Buytenhek 已提交
2904 2905
	mp->port_num = pd->port_number;

2906
	mp->dev = dev;
2907

L
Lennert Buytenhek 已提交
2908
	set_params(mp, pd);
2909
	dev->real_num_tx_queues = mp->txq_count;
L
Lennert Buytenhek 已提交
2910

2911 2912
	if (pd->phy_addr != MV643XX_ETH_PHY_NONE)
		mp->phy = phy_scan(mp, pd->phy_addr);
2913

2914
	if (mp->phy != NULL)
2915
		phy_init(mp, pd->speed, pd->duplex);
2916 2917

	SET_ETHTOOL_OPS(dev, &mv643xx_eth_ethtool_ops);
2918

2919
	init_pscr(mp, pd->speed, pd->duplex);
L
Lennert Buytenhek 已提交
2920

2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933

	mib_counters_clear(mp);

	init_timer(&mp->mib_counters_timer);
	mp->mib_counters_timer.data = (unsigned long)mp;
	mp->mib_counters_timer.function = mib_counters_timer_wrapper;
	mp->mib_counters_timer.expires = jiffies + 30 * HZ;
	add_timer(&mp->mib_counters_timer);

	spin_lock_init(&mp->mib_counters_lock);

	INIT_WORK(&mp->tx_timeout_task, tx_timeout_task);

2934 2935 2936 2937 2938 2939
	netif_napi_add(dev, &mp->napi, mv643xx_eth_poll, 128);

	init_timer(&mp->rx_oom);
	mp->rx_oom.data = (unsigned long)mp;
	mp->rx_oom.function = oom_timer_wrapper;

L
Lennert Buytenhek 已提交
2940

2941 2942 2943
	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	BUG_ON(!res);
	dev->irq = res->start;
L
Linus Torvalds 已提交
2944

2945 2946
	dev->netdev_ops = &mv643xx_eth_netdev_ops;

2947 2948
	dev->watchdog_timeo = 2 * HZ;
	dev->base_addr = 0;
L
Linus Torvalds 已提交
2949

2950
	dev->features = NETIF_F_SG | NETIF_F_IP_CSUM;
2951
	dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM;
L
Linus Torvalds 已提交
2952

L
Lennert Buytenhek 已提交
2953
	SET_NETDEV_DEV(dev, &pdev->dev);
2954

2955
	if (mp->shared->win_protect)
L
Lennert Buytenhek 已提交
2956
		wrl(mp, WINDOW_PROTECT(mp->port_num), mp->shared->win_protect);
L
Linus Torvalds 已提交
2957

2958 2959 2960 2961 2962
	netif_carrier_off(dev);

	set_rx_coal(mp, 0);
	set_tx_coal(mp, 0);

2963 2964 2965
	err = register_netdev(dev);
	if (err)
		goto out;
L
Linus Torvalds 已提交
2966

J
Johannes Berg 已提交
2967 2968
	dev_printk(KERN_NOTICE, &dev->dev, "port %d with MAC address %pM\n",
		   mp->port_num, dev->dev_addr);
L
Linus Torvalds 已提交
2969

2970
	if (mp->tx_desc_sram_size > 0)
L
Lennert Buytenhek 已提交
2971
		dev_printk(KERN_NOTICE, &dev->dev, "configured with sram\n");
L
Linus Torvalds 已提交
2972

2973
	return 0;
L
Linus Torvalds 已提交
2974

2975 2976
out:
	free_netdev(dev);
L
Linus Torvalds 已提交
2977

2978
	return err;
L
Linus Torvalds 已提交
2979 2980
}

2981
static int mv643xx_eth_remove(struct platform_device *pdev)
L
Linus Torvalds 已提交
2982
{
L
Lennert Buytenhek 已提交
2983
	struct mv643xx_eth_private *mp = platform_get_drvdata(pdev);
L
Linus Torvalds 已提交
2984

L
Lennert Buytenhek 已提交
2985
	unregister_netdev(mp->dev);
2986 2987
	if (mp->phy != NULL)
		phy_detach(mp->phy);
2988
	flush_scheduled_work();
L
Lennert Buytenhek 已提交
2989
	free_netdev(mp->dev);
2990 2991

	platform_set_drvdata(pdev, NULL);
L
Lennert Buytenhek 已提交
2992

2993
	return 0;
L
Linus Torvalds 已提交
2994 2995
}

2996
static void mv643xx_eth_shutdown(struct platform_device *pdev)
2997
{
L
Lennert Buytenhek 已提交
2998
	struct mv643xx_eth_private *mp = platform_get_drvdata(pdev);
2999

3000
	/* Mask all interrupts on ethernet port */
3001 3002
	wrlp(mp, INT_MASK, 0);
	rdlp(mp, INT_MASK);
3003

L
Lennert Buytenhek 已提交
3004 3005
	if (netif_running(mp->dev))
		port_reset(mp);
3006 3007
}

3008
static struct platform_driver mv643xx_eth_driver = {
L
Lennert Buytenhek 已提交
3009 3010 3011
	.probe		= mv643xx_eth_probe,
	.remove		= mv643xx_eth_remove,
	.shutdown	= mv643xx_eth_shutdown,
3012
	.driver = {
L
Lennert Buytenhek 已提交
3013
		.name	= MV643XX_ETH_NAME,
3014 3015 3016 3017
		.owner	= THIS_MODULE,
	},
};

3018
static int __init mv643xx_eth_init_module(void)
3019
{
3020
	int rc;
3021

3022 3023 3024 3025 3026 3027
	rc = platform_driver_register(&mv643xx_eth_shared_driver);
	if (!rc) {
		rc = platform_driver_register(&mv643xx_eth_driver);
		if (rc)
			platform_driver_unregister(&mv643xx_eth_shared_driver);
	}
L
Lennert Buytenhek 已提交
3028

3029
	return rc;
3030
}
L
Lennert Buytenhek 已提交
3031
module_init(mv643xx_eth_init_module);
3032

3033
static void __exit mv643xx_eth_cleanup_module(void)
3034
{
3035 3036
	platform_driver_unregister(&mv643xx_eth_driver);
	platform_driver_unregister(&mv643xx_eth_shared_driver);
3037
}
3038
module_exit(mv643xx_eth_cleanup_module);
L
Linus Torvalds 已提交
3039

3040 3041
MODULE_AUTHOR("Rabeeh Khoury, Assaf Hoffman, Matthew Dharm, "
	      "Manish Lachwani, Dale Farnsworth and Lennert Buytenhek");
3042
MODULE_DESCRIPTION("Ethernet driver for Marvell MV643XX");
L
Lennert Buytenhek 已提交
3043
MODULE_LICENSE("GPL");
3044
MODULE_ALIAS("platform:" MV643XX_ETH_SHARED_NAME);
L
Lennert Buytenhek 已提交
3045
MODULE_ALIAS("platform:" MV643XX_ETH_NAME);