mv643xx_eth.c 71.1 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
	struct napi_struct napi;
396
	u8 oom;
397 398 399 400 401 402
	u8 work_link;
	u8 work_tx;
	u8 work_tx_end;
	u8 work_rx;
	u8 work_rx_refill;

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
		if (skb == NULL) {
664
			mp->oom = 1;
665 666
			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
	p->good_octets_received += mib_read(mp, 0x00);
	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_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);
1287
	spin_unlock_bh(&mp->mib_counters_lock);
1288 1289 1290 1291 1292 1293 1294 1295 1296

	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);
1297 1298
}

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
/* 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);
}


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

1387 1388 1389 1390 1391 1392 1393 1394
#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) }

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

1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437
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),
1438 1439 1440
	LROSTAT(lro_aggregated),
	LROSTAT(lro_flushed),
	LROSTAT(lro_no_desc),
1441 1442
};

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

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

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

	return err;
}

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

1468
	port_status = rdlp(mp, PORT_STATUS);
1469

1470 1471
	cmd->supported = SUPPORTED_MII;
	cmd->advertising = ADVERTISED_MII;
1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486
	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;
1487 1488 1489 1490 1491 1492 1493 1494 1495 1496
	cmd->port = PORT_MII;
	cmd->phy_address = 0;
	cmd->transceiver = XCVR_INTERNAL;
	cmd->autoneg = AUTONEG_DISABLE;
	cmd->maxtxpkt = 1;
	cmd->maxrxpkt = 1;

	return 0;
}

1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507
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 已提交
1508 1509
static int
mv643xx_eth_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
L
Linus Torvalds 已提交
1510
{
1511
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1512

1513 1514 1515
	if (mp->phy == NULL)
		return -EINVAL;

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

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

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

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

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

1541
	return genphy_restart_aneg(mp->phy);
1542 1543
}

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

1549 1550 1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570
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;
}

1571 1572 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
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;
}

1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628
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 已提交
1629 1630
static void mv643xx_eth_get_strings(struct net_device *dev,
				    uint32_t stringset, uint8_t *data)
1631 1632
{
	int i;
L
Linus Torvalds 已提交
1633

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

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

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

1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666
	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 已提交
1667
	}
1668
}
L
Linus Torvalds 已提交
1669

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

	return -EOPNOTSUPP;
1676
}
L
Linus Torvalds 已提交
1677

1678
static const struct ethtool_ops mv643xx_eth_ethtool_ops = {
L
Lennert Buytenhek 已提交
1679 1680 1681 1682 1683
	.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,
1684 1685
	.get_coalesce		= mv643xx_eth_get_coalesce,
	.set_coalesce		= mv643xx_eth_set_coalesce,
1686 1687
	.get_ringparam		= mv643xx_eth_get_ringparam,
	.set_ringparam		= mv643xx_eth_set_ringparam,
1688 1689
	.get_rx_csum		= mv643xx_eth_get_rx_csum,
	.set_rx_csum		= mv643xx_eth_set_rx_csum,
1690
	.set_tx_csum		= ethtool_op_set_tx_csum,
1691
	.set_sg			= ethtool_op_set_sg,
L
Lennert Buytenhek 已提交
1692 1693
	.get_strings		= mv643xx_eth_get_strings,
	.get_ethtool_stats	= mv643xx_eth_get_ethtool_stats,
1694 1695
	.get_flags		= ethtool_op_get_flags,
	.set_flags		= ethtool_op_set_flags,
1696
	.get_sset_count		= mv643xx_eth_get_sset_count,
1697
};
L
Linus Torvalds 已提交
1698

1699

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

1706 1707 1708 1709 1710 1711
	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;
1712
}
L
Linus Torvalds 已提交
1713

1714
static void uc_addr_set(struct mv643xx_eth_private *mp, unsigned char *addr)
1715
{
1716 1717 1718
	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]);
1719
}
1720

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

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

1729 1730 1731 1732 1733 1734
	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;
1735

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

1739
	return nibbles;
L
Linus Torvalds 已提交
1740 1741
}

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

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

1751 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
	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 已提交
1779 1780
}

1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798
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;
}

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

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

1811 1812 1813
oom:
		port_num = mp->port_num;
		accept = 0x01010101;
L
Lennert Buytenhek 已提交
1814 1815 1816
		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);
1817 1818 1819
		}
		return;
	}
1820

1821
	mc_spec = kmalloc(0x200, GFP_ATOMIC);
1822 1823 1824 1825 1826 1827
	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 已提交
1828

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

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

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

	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;
1870
}
1871 1872


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

1881 1882
	rxq->index = index;

1883
	rxq->rx_ring_size = mp->rx_ring_size;
1884 1885 1886 1887 1888 1889 1890

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

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

1891
	if (index == 0 && size <= mp->rx_desc_sram_size) {
1892 1893 1894 1895 1896 1897 1898
		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);
1899 1900
	}

1901 1902 1903 1904 1905 1906
	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 已提交
1907

1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918
	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++) {
1919 1920 1921 1922 1923 1924
		int nexti;

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

1925 1926 1927 1928
		rx_desc[i].next_desc_ptr = rxq->rx_desc_dma +
					nexti * sizeof(struct rx_desc);
	}

1929 1930 1931 1932 1933 1934 1935 1936 1937 1938 1939 1940 1941
	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));

1942 1943 1944 1945
	return 0;


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

out:
	return -ENOMEM;
1955
}
1956

1957
static void rxq_deinit(struct rx_queue *rxq)
1958
{
1959 1960 1961 1962
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	int i;

	rxq_disable(rxq);
1963

1964 1965 1966 1967
	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 已提交
1968
		}
1969
	}
L
Linus Torvalds 已提交
1970

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

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

	kfree(rxq->rx_skb);
1985
}
L
Linus Torvalds 已提交
1986

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

1994 1995
	txq->index = index;

1996
	txq->tx_ring_size = mp->tx_ring_size;
1997 1998 1999 2000 2001 2002 2003

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

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

2004
	if (index == 0 && size <= mp->tx_desc_sram_size) {
2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
		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);
2017
		return -ENOMEM;
2018
	}
2019 2020 2021 2022 2023 2024
	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++) {
2025
		struct tx_desc *txd = tx_desc + i;
2026 2027 2028 2029 2030
		int nexti;

		nexti = i + 1;
		if (nexti == txq->tx_ring_size)
			nexti = 0;
2031 2032 2033

		txd->cmd_sts = 0;
		txd->next_desc_ptr = txq->tx_desc_dma +
2034 2035 2036
					nexti * sizeof(struct tx_desc);
	}

2037
	skb_queue_head_init(&txq->tx_skb);
2038

2039
	return 0;
2040
}
L
Linus Torvalds 已提交
2041

2042
static void txq_deinit(struct tx_queue *txq)
2043
{
2044
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
2045

2046
	txq_disable(txq);
2047
	txq_reclaim(txq, txq->tx_ring_size, 1);
L
Linus Torvalds 已提交
2048

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

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


2060
/* netdev ops and related ***************************************************/
2061 2062 2063 2064 2065
static int mv643xx_eth_collect_events(struct mv643xx_eth_private *mp)
{
	u32 int_cause;
	u32 int_cause_ext;

2066
	int_cause = rdlp(mp, INT_CAUSE) & (INT_TX_END | INT_RX | INT_EXT);
2067 2068 2069 2070 2071
	if (int_cause == 0)
		return 0;

	int_cause_ext = 0;
	if (int_cause & INT_EXT)
2072
		int_cause_ext = rdlp(mp, INT_CAUSE_EXT);
2073 2074 2075

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

	int_cause_ext &= INT_EXT_LINK_PHY | INT_EXT_TX;
	if (int_cause_ext) {
2084
		wrlp(mp, INT_CAUSE_EXT, ~int_cause_ext);
2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
		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;

2101
	wrlp(mp, INT_MASK, 0);
2102 2103 2104 2105 2106
	napi_schedule(&mp->napi);

	return IRQ_HANDLED;
}

2107 2108 2109 2110 2111 2112 2113 2114
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;

2115
	port_status = rdlp(mp, PORT_STATUS);
2116 2117 2118 2119 2120 2121 2122 2123
	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);

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

2127
				txq_reclaim(txq, txq->tx_ring_size, 1);
2128
				txq_reset_hw_ptr(txq);
2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155
			}
		}
		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");

2156
	if (!netif_carrier_ok(dev))
2157 2158 2159
		netif_carrier_on(dev);
}

2160
static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
2161
{
2162 2163
	struct mv643xx_eth_private *mp;
	int work_done;
2164

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

2167 2168 2169 2170
	if (unlikely(mp->oom)) {
		mp->oom = 0;
		del_timer(&mp->rx_oom);
	}
L
Linus Torvalds 已提交
2171

2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182
	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 已提交
2183

2184 2185 2186 2187
		queue_mask = mp->work_tx | mp->work_tx_end | mp->work_rx;
		if (likely(!mp->oom))
			queue_mask |= mp->work_rx_refill;

2188 2189 2190 2191 2192
		if (!queue_mask) {
			if (mv643xx_eth_collect_events(mp))
				continue;
			break;
		}
L
Linus Torvalds 已提交
2193

2194 2195 2196 2197 2198 2199 2200 2201 2202 2203 2204 2205 2206 2207
		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);
2208
		} else if (!mp->oom && (mp->work_rx_refill & queue_mask)) {
2209 2210 2211 2212
			work_done += rxq_refill(mp->rxq + queue, work_tbd);
		} else {
			BUG();
		}
2213
	}
L
Lennert Buytenhek 已提交
2214

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

2222 2223
	return work_done;
}
2224

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2290 2291
	/*
	 * Receive all unmatched unicast, TCP, UDP, BPDU and broadcast
2292 2293
	 * frames to RX queue #0, and include the pseudo-header when
	 * calculating receive checksums.
2294
	 */
2295
	wrlp(mp, PORT_CONFIG, 0x02000000);
2296

2297 2298 2299
	/*
	 * Treat BPDUs as normal multicasts, and disable partition mode.
	 */
2300
	wrlp(mp, PORT_CONFIG_EXT, 0x00000000);
2301

2302 2303 2304 2305 2306
	/*
	 * Add configured unicast addresses to address filter table.
	 */
	mv643xx_eth_program_unicast_filter(mp->dev);

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

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

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

2322 2323 2324 2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341
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;
}

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

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

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

2359 2360
	mv643xx_eth_recalc_skb_size(mp);

2361 2362
	napi_enable(&mp->napi);

2363 2364
	skb_queue_head_init(&mp->rx_recycle);

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

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

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

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

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

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

2395 2396
	return 0;

2397

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

	return err;
2405 2406
}

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

2412 2413 2414 2415
	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);
2416 2417

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

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

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

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

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

2442
	napi_disable(&mp->napi);
2443

2444 2445
	del_timer_sync(&mp->rx_oom);

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

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

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

2455 2456
	skb_queue_purge(&mp->rx_recycle);

2457 2458 2459 2460
	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 已提交
2461

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

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

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

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

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

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

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

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

2489 2490 2491 2492
	/*
	 * 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 已提交
2493
	 * due to memory being full.
2494 2495 2496
	 */
	mv643xx_eth_stop(dev);
	if (mv643xx_eth_open(dev)) {
L
Lennert Buytenhek 已提交
2497 2498 2499
		dev_printk(KERN_ERR, &dev->dev,
			   "fatal error on re-opening device after "
			   "MTU change\n");
2500 2501 2502
	}

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

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

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

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

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

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

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

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

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

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


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

2552 2553 2554 2555 2556
	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));
2557 2558
	}

2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575
	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;
2576 2577
}

2578 2579 2580 2581 2582 2583 2584
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.
	 */
2585 2586
	writel(0x02000000, msp->base + 0x0400 + SDMA_CONFIG);
	if (readl(msp->base + 0x0400 + SDMA_CONFIG) & 0x02000000)
2587 2588 2589
		msp->extended_rx_coal_limit = 1;
	else
		msp->extended_rx_coal_limit = 0;
2590 2591

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

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

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

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

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

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

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

		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;
2652 2653
		msp->smi = msp;
	} else {
2654
		msp->smi = platform_get_drvdata(pd->shared_smi);
2655
	}
2656

2657 2658 2659 2660 2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674
	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;
		}
	}

2675 2676 2677 2678 2679 2680
	/*
	 * (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 已提交
2681 2682 2683 2684
	/*
	 * Detect hardware parameters.
	 */
	msp->t_clk = (pd != NULL && pd->t_clk != 0) ? pd->t_clk : 133000000;
2685
	infer_hw_params(msp);
L
Lennert Buytenhek 已提交
2686 2687 2688

	platform_set_drvdata(pdev, msp);

2689 2690
	return 0;

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

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

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

	return 0;
2716 2717
}

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

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

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

2738
static int phy_addr_get(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2739
{
L
Lennert Buytenhek 已提交
2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756
	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);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

	pscr = MAX_RX_PACKET_9700BYTE | SERIAL_PORT_CONTROL_RESERVED;
2841
	if (mp->phy == NULL) {
2842 2843 2844 2845 2846 2847 2848 2849 2850 2851 2852 2853 2854
		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;
	}

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

2858 2859 2860 2861 2862 2863 2864 2865 2866 2867 2868 2869 2870 2871 2872
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
};

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

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

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

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

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

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

2905
	mp->dev = dev;
2906

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

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

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

	SET_ETHTOOL_OPS(dev, &mv643xx_eth_ethtool_ops);
2917

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

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

	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);

2933 2934 2935 2936 2937 2938
	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 已提交
2939

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

2944 2945
	dev->netdev_ops = &mv643xx_eth_netdev_ops;

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

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

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

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

2957 2958
	netif_carrier_off(dev);

2959 2960
	wrlp(mp, SDMA_CONFIG, PORT_SDMA_CONFIG_DEFAULT_VALUE);

2961
	set_rx_coal(mp, 250);
2962 2963
	set_tx_coal(mp, 0);

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

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

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

2974
	return 0;
L
Linus Torvalds 已提交
2975

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

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

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

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

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

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

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

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

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

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

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

3023 3024 3025 3026 3027 3028
	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 已提交
3029

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

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

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