mv643xx_eth.c 67.9 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>
L
Linus Torvalds 已提交
56
#include <asm/system.h>
57

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

61 62 63 64

/*
 * Registers shared between all ports.
 */
65 66
#define PHY_ADDR			0x0000
#define SMI_REG				0x0004
67 68 69 70 71 72 73
#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
74 75 76 77 78
#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))
79 80

/*
81 82
 * Main per-port registers.  These live at offset 0x0400 for
 * port #0, 0x0800 for port #1, and 0x0c00 for port #2.
83
 */
84
#define PORT_CONFIG			0x0000
85
#define  UNICAST_PROMISCUOUS_MODE	0x00000001
86 87 88 89 90 91
#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
92
#define  TX_FIFO_EMPTY			0x00000400
93
#define  TX_IN_PROGRESS			0x00000080
94 95 96 97 98 99
#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
100
#define  LINK_UP			0x00000002
101 102 103 104 105 106
#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
107
#define  INT_TX_END			0x07f80000
108
#define  INT_RX				0x000003fc
109
#define  INT_EXT			0x00000002
110
#define INT_CAUSE_EXT			0x0064
111 112
#define  INT_EXT_LINK_PHY		0x00110000
#define  INT_EXT_TX			0x000000ff
113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129
#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.
 */
130 131 132 133
#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))
134

135 136 137 138

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

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

160 161 162 163 164 165 166

/*
 * 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)
167
#define MAX_RX_PACKET_9700BYTE			(5 << 17)
168 169 170 171 172 173 174
#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)
175

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


180 181
/*
 * RX/TX descriptors.
182 183
 */
#if defined(__BIG_ENDIAN)
184
struct rx_desc {
185 186 187 188 189 190 191
	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		*/
};

192
struct tx_desc {
193 194 195 196 197 198 199
	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)
200
struct rx_desc {
201 202 203 204 205 206 207
	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		*/
};

208
struct tx_desc {
209 210 211 212 213 214 215 216 217 218
	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

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

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

/* RX descriptor status */
226 227 228 229
#define LAYER_4_CHECKSUM_OK		0x40000000
#define RX_ENABLE_INTERRUPT		0x20000000
#define RX_FIRST_DESC			0x08000000
#define RX_LAST_DESC			0x04000000
230 231

/* TX descriptor command */
232 233 234 235 236 237 238 239
#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
240 241
#define MAC_HDR_EXTRA_4_BYTES		0x00008000
#define MAC_HDR_EXTRA_8_BYTES		0x00000200
242

243
#define TX_IHL_SHIFT			11
244 245


246
/* global *******************************************************************/
247
struct mv643xx_eth_shared_private {
L
Lennert Buytenhek 已提交
248 249 250
	/*
	 * Ethernet controller base address.
	 */
251
	void __iomem *base;
252

253 254 255 256 257
	/*
	 * Points at the right SMI instance to use.
	 */
	struct mv643xx_eth_shared_private *smi;

L
Lennert Buytenhek 已提交
258
	/*
259
	 * Provides access to local SMI interface.
L
Lennert Buytenhek 已提交
260
	 */
261
	struct mii_bus *smi_bus;
262

263 264 265 266 267 268 269 270 271
	/*
	 * 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 已提交
272 273 274
	/*
	 * Per-port MBUS window access register value.
	 */
275 276
	u32 win_protect;

L
Lennert Buytenhek 已提交
277 278 279
	/*
	 * Hardware-specific parameters.
	 */
280
	unsigned int t_clk;
281
	int extended_rx_coal_limit;
282
	int tx_bw_control;
283 284
};

285 286 287 288
#define TX_BW_CONTROL_ABSENT		0
#define TX_BW_CONTROL_OLD_LAYOUT	1
#define TX_BW_CONTROL_NEW_LAYOUT	2

289 290 291
static int mv643xx_eth_open(struct net_device *dev);
static int mv643xx_eth_stop(struct net_device *dev);

292 293

/* per-port *****************************************************************/
294
struct mib_counters {
295 296 297 298 299 300 301 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
	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;
};

327
struct rx_queue {
328 329
	int index;

330 331 332 333 334 335 336 337 338 339 340 341
	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;
};

342
struct tx_queue {
343 344
	int index;

345
	int tx_ring_size;
346

347 348 349
	int tx_desc_count;
	int tx_curr_desc;
	int tx_used_desc;
350

351
	struct tx_desc *tx_desc_area;
352 353
	dma_addr_t tx_desc_dma;
	int tx_desc_area_size;
354 355

	struct sk_buff_head tx_skb;
356 357 358 359

	unsigned long tx_packets;
	unsigned long tx_bytes;
	unsigned long tx_dropped;
360 361 362 363
};

struct mv643xx_eth_private {
	struct mv643xx_eth_shared_private *shared;
364
	void __iomem *base;
L
Lennert Buytenhek 已提交
365
	int port_num;
366

L
Lennert Buytenhek 已提交
367
	struct net_device *dev;
368

369
	struct phy_device *phy;
370

371 372
	struct timer_list mib_counters_timer;
	spinlock_t mib_counters_lock;
L
Lennert Buytenhek 已提交
373
	struct mib_counters mib_counters;
374

L
Lennert Buytenhek 已提交
375
	struct work_struct tx_timeout_task;
376

377 378 379 380 381 382 383 384
	struct napi_struct napi;
	u8 work_link;
	u8 work_tx;
	u8 work_tx_end;
	u8 work_rx;
	u8 work_rx_refill;
	u8 work_rx_oom;

385 386 387
	int skb_size;
	struct sk_buff_head rx_recycle;

388 389 390
	/*
	 * RX state.
	 */
391
	int rx_ring_size;
392 393
	unsigned long rx_desc_sram_addr;
	int rx_desc_sram_size;
394
	int rxq_count;
395
	struct timer_list rx_oom;
396
	struct rx_queue rxq[8];
397 398 399 400

	/*
	 * TX state.
	 */
401
	int tx_ring_size;
402 403
	unsigned long tx_desc_sram_addr;
	int tx_desc_sram_size;
404
	int txq_count;
405
	struct tx_queue txq[8];
406
};
L
Linus Torvalds 已提交
407

408

409
/* port register accessors **************************************************/
410
static inline u32 rdl(struct mv643xx_eth_private *mp, int offset)
411
{
412
	return readl(mp->shared->base + offset);
413
}
414

415 416 417 418 419
static inline u32 rdlp(struct mv643xx_eth_private *mp, int offset)
{
	return readl(mp->base + offset);
}

420
static inline void wrl(struct mv643xx_eth_private *mp, int offset, u32 data)
421
{
422
	writel(data, mp->shared->base + offset);
423
}
424

425 426 427 428 429
static inline void wrlp(struct mv643xx_eth_private *mp, int offset, u32 data)
{
	writel(data, mp->base + offset);
}

430

431
/* rxq/txq helper functions *************************************************/
432
static struct mv643xx_eth_private *rxq_to_mp(struct rx_queue *rxq)
433
{
434
	return container_of(rxq, struct mv643xx_eth_private, rxq[rxq->index]);
435
}
436

437 438
static struct mv643xx_eth_private *txq_to_mp(struct tx_queue *txq)
{
439
	return container_of(txq, struct mv643xx_eth_private, txq[txq->index]);
440 441
}

442
static void rxq_enable(struct rx_queue *rxq)
443
{
444
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
445
	wrlp(mp, RXQ_COMMAND, 1 << rxq->index);
446
}
L
Linus Torvalds 已提交
447

448 449 450
static void rxq_disable(struct rx_queue *rxq)
{
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
451
	u8 mask = 1 << rxq->index;
L
Linus Torvalds 已提交
452

453 454
	wrlp(mp, RXQ_COMMAND, mask << 8);
	while (rdlp(mp, RXQ_COMMAND) & mask)
455
		udelay(10);
456 457
}

458 459 460 461 462 463 464
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);
465
	wrlp(mp, TXQ_CURRENT_DESC_PTR(txq->index), addr);
466 467
}

468
static void txq_enable(struct tx_queue *txq)
L
Linus Torvalds 已提交
469
{
470
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
471
	wrlp(mp, TXQ_COMMAND, 1 << txq->index);
L
Linus Torvalds 已提交
472 473
}

474
static void txq_disable(struct tx_queue *txq)
L
Linus Torvalds 已提交
475
{
476
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
477
	u8 mask = 1 << txq->index;
478

479 480
	wrlp(mp, TXQ_COMMAND, mask << 8);
	while (rdlp(mp, TXQ_COMMAND) & mask)
481 482 483
		udelay(10);
}

484
static void txq_maybe_wake(struct tx_queue *txq)
485 486
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
487
	struct netdev_queue *nq = netdev_get_tx_queue(mp->dev, txq->index);
488

489 490 491 492 493 494
	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 已提交
495 496
}

497

498
/* rx napi ******************************************************************/
499
static int rxq_process(struct rx_queue *rxq, int budget)
L
Linus Torvalds 已提交
500
{
501 502 503
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	struct net_device_stats *stats = &mp->dev->stats;
	int rx;
L
Linus Torvalds 已提交
504

505
	rx = 0;
506
	while (rx < budget && rxq->rx_desc_count) {
L
Lennert Buytenhek 已提交
507
		struct rx_desc *rx_desc;
508
		unsigned int cmd_sts;
L
Lennert Buytenhek 已提交
509
		struct sk_buff *skb;
510
		u16 byte_cnt;
511

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

514
		cmd_sts = rx_desc->cmd_sts;
515
		if (cmd_sts & BUFFER_OWNED_BY_DMA)
516 517
			break;
		rmb();
L
Linus Torvalds 已提交
518

519 520
		skb = rxq->rx_skb[rxq->rx_curr_desc];
		rxq->rx_skb[rxq->rx_curr_desc] = NULL;
521

522 523 524
		rxq->rx_curr_desc++;
		if (rxq->rx_curr_desc == rxq->rx_ring_size)
			rxq->rx_curr_desc = 0;
525

526
		dma_unmap_single(NULL, rx_desc->buf_ptr,
527
				 rx_desc->buf_size, DMA_FROM_DEVICE);
528 529
		rxq->rx_desc_count--;
		rx++;
530

531 532
		mp->work_rx_refill |= 1 << rxq->index;

533 534
		byte_cnt = rx_desc->byte_cnt;

535 536
		/*
		 * Update statistics.
L
Lennert Buytenhek 已提交
537 538 539 540 541
		 *
		 * 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).
542
		 */
L
Linus Torvalds 已提交
543
		stats->rx_packets++;
544
		stats->rx_bytes += byte_cnt - 2;
545

L
Linus Torvalds 已提交
546
		/*
L
Lennert Buytenhek 已提交
547 548 549
		 * 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 已提交
550
		 */
551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576
		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);
		netif_receive_skb(skb);

		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 已提交
577
		}
578 579 580 581 582

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

		dev_kfree_skb(skb);
L
Linus Torvalds 已提交
583
	}
L
Lennert Buytenhek 已提交
584

585 586 587
	if (rx < budget)
		mp->work_rx &= ~(1 << rxq->index);

588
	return rx;
L
Linus Torvalds 已提交
589 590
}

591
static int rxq_refill(struct rx_queue *rxq, int budget)
592
{
593 594
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	int refilled;
595

596 597 598 599 600
	refilled = 0;
	while (refilled < budget && rxq->rx_desc_count < rxq->rx_ring_size) {
		struct sk_buff *skb;
		int unaligned;
		int rx;
601
		struct rx_desc *rx_desc;
602

603 604 605 606 607
		skb = __skb_dequeue(&mp->rx_recycle);
		if (skb == NULL)
			skb = dev_alloc_skb(mp->skb_size +
					    dma_get_cache_alignment() - 1);

608 609 610 611
		if (skb == NULL) {
			mp->work_rx_oom |= 1 << rxq->index;
			goto oom;
		}
612

613 614 615
		unaligned = (u32)skb->data & (dma_get_cache_alignment() - 1);
		if (unaligned)
			skb_reserve(skb, dma_get_cache_alignment() - unaligned);
616

617 618
		refilled++;
		rxq->rx_desc_count++;
619

620 621 622
		rx = rxq->rx_used_desc++;
		if (rxq->rx_used_desc == rxq->rx_ring_size)
			rxq->rx_used_desc = 0;
623

624 625 626 627 628
		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;
629 630
		rxq->rx_skb[rx] = skb;
		wmb();
631
		rx_desc->cmd_sts = BUFFER_OWNED_BY_DMA | RX_ENABLE_INTERRUPT;
632
		wmb();
633

634 635 636 637 638 639 640 641 642 643 644 645 646
		/*
		 * 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;
647 648
}

649 650 651

/* tx ***********************************************************************/
static inline unsigned int has_tiny_unaligned_frags(struct sk_buff *skb)
L
Linus Torvalds 已提交
652
{
653
	int frag;
L
Linus Torvalds 已提交
654

655
	for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
656 657
		skb_frag_t *fragp = &skb_shinfo(skb)->frags[frag];
		if (fragp->size <= 8 && fragp->page_offset & 7)
658
			return 1;
L
Linus Torvalds 已提交
659
	}
660

661 662
	return 0;
}
663

664
static void txq_submit_frag_skb(struct tx_queue *txq, struct sk_buff *skb)
665
{
666
	int nr_frags = skb_shinfo(skb)->nr_frags;
667
	int frag;
L
Linus Torvalds 已提交
668

669 670 671 672 673 674
	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];
675 676 677
		tx_index = txq->tx_curr_desc++;
		if (txq->tx_curr_desc == txq->tx_ring_size)
			txq->tx_curr_desc = 0;
678 679 680 681 682 683 684 685 686 687 688 689 690 691
		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;
		}

692 693 694 695 696 697 698
		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 已提交
699 700
}

701 702 703 704
static inline __be16 sum16_as_be(__sum16 sum)
{
	return (__force __be16)sum;
}
L
Linus Torvalds 已提交
705

706
static int txq_submit_skb(struct tx_queue *txq, struct sk_buff *skb)
L
Linus Torvalds 已提交
707
{
708
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
709
	int nr_frags = skb_shinfo(skb)->nr_frags;
710
	int tx_index;
711
	struct tx_desc *desc;
712
	u32 cmd_sts;
713
	u16 l4i_chk;
714
	int length;
L
Linus Torvalds 已提交
715

716
	cmd_sts = TX_FIRST_DESC | GEN_CRC | BUFFER_OWNED_BY_DMA;
717
	l4i_chk = 0;
718 719

	if (skb->ip_summed == CHECKSUM_PARTIAL) {
720
		int tag_bytes;
721 722 723

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

725 726 727 728 729 730 731
		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;
		}
732

733
		if (tag_bytes & 4)
734
			cmd_sts |= MAC_HDR_EXTRA_4_BYTES;
735
		if (tag_bytes & 8)
736
			cmd_sts |= MAC_HDR_EXTRA_8_BYTES;
737 738 739 740

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

742 743
		switch (ip_hdr(skb)->protocol) {
		case IPPROTO_UDP:
744
			cmd_sts |= UDP_FRAME;
745
			l4i_chk = ntohs(sum16_as_be(udp_hdr(skb)->check));
746 747
			break;
		case IPPROTO_TCP:
748
			l4i_chk = ntohs(sum16_as_be(tcp_hdr(skb)->check));
749 750 751 752 753
			break;
		default:
			BUG();
		}
	} else {
754
no_csum:
755
		/* Errata BTS #50, IHL must be 5 if no HW checksum */
756
		cmd_sts |= 5 << TX_IHL_SHIFT;
757 758
	}

759 760 761
	tx_index = txq->tx_curr_desc++;
	if (txq->tx_curr_desc == txq->tx_ring_size)
		txq->tx_curr_desc = 0;
762 763 764 765 766 767 768 769 770 771 772 773 774 775
	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);

776 777
	__skb_queue_tail(&txq->tx_skb, skb);

778 779 780 781
	/* ensure all other descriptors are written before first cmd_sts */
	wmb();
	desc->cmd_sts = cmd_sts;

782 783
	/* clear TX_END status */
	mp->work_tx_end &= ~(1 << txq->index);
784

785 786
	/* ensure all descriptors are written before poking hardware */
	wmb();
787
	txq_enable(txq);
788

789
	txq->tx_desc_count += nr_frags + 1;
790 791

	return 0;
L
Linus Torvalds 已提交
792 793
}

L
Lennert Buytenhek 已提交
794
static int mv643xx_eth_xmit(struct sk_buff *skb, struct net_device *dev)
L
Linus Torvalds 已提交
795
{
796
	struct mv643xx_eth_private *mp = netdev_priv(dev);
797
	int queue;
798
	struct tx_queue *txq;
799
	struct netdev_queue *nq;
800

801 802 803 804
	queue = skb_get_queue_mapping(skb);
	txq = mp->txq + queue;
	nq = netdev_get_tx_queue(dev, queue);

805
	if (has_tiny_unaligned_frags(skb) && __skb_linearize(skb)) {
806
		txq->tx_dropped++;
L
Lennert Buytenhek 已提交
807 808 809
		dev_printk(KERN_DEBUG, &dev->dev,
			   "failed to linearize skb with tiny "
			   "unaligned fragment\n");
810 811 812
		return NETDEV_TX_BUSY;
	}

813
	if (txq->tx_ring_size - txq->tx_desc_count < MAX_SKB_FRAGS + 1) {
814 815
		if (net_ratelimit())
			dev_printk(KERN_ERR, &dev->dev, "tx queue full?!\n");
816 817
		kfree_skb(skb);
		return NETDEV_TX_OK;
818 819
	}

820 821 822 823 824 825
	if (!txq_submit_skb(txq, skb)) {
		int entries_left;

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

827 828 829 830
		entries_left = txq->tx_ring_size - txq->tx_desc_count;
		if (entries_left < MAX_SKB_FRAGS + 1)
			netif_tx_stop_queue(nq);
	}
831 832

	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
833 834
}

835

836 837 838 839
/* tx napi ******************************************************************/
static void txq_kick(struct tx_queue *txq)
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
840
	struct netdev_queue *nq = netdev_get_tx_queue(mp->dev, txq->index);
841 842 843
	u32 hw_desc_ptr;
	u32 expected_ptr;

844
	__netif_tx_lock(nq, smp_processor_id());
845

846
	if (rdlp(mp, TXQ_COMMAND) & (1 << txq->index))
847 848
		goto out;

849
	hw_desc_ptr = rdlp(mp, TXQ_CURRENT_DESC_PTR(txq->index));
850 851 852 853 854 855 856
	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:
857
	__netif_tx_unlock(nq);
858 859 860 861 862 863 864

	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);
865
	struct netdev_queue *nq = netdev_get_tx_queue(mp->dev, txq->index);
866 867
	int reclaimed;

868
	__netif_tx_lock(nq, smp_processor_id());
869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893

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

894 895 896
		skb = NULL;
		if (cmd_sts & TX_LAST_DESC)
			skb = __skb_dequeue(&txq->tx_skb);
897 898 899 900 901 902

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

903 904 905 906 907 908 909
		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);
		}
910

911 912
		if (skb != NULL) {
			if (skb_queue_len(&mp->rx_recycle) <
913
					mp->rx_ring_size &&
914 915
			    skb_recycle_check(skb, mp->skb_size +
					dma_get_cache_alignment() - 1))
916 917 918 919
				__skb_queue_head(&mp->rx_recycle, skb);
			else
				dev_kfree_skb(skb);
		}
920 921
	}

922 923
	__netif_tx_unlock(nq);

924 925 926 927 928 929 930
	if (reclaimed < budget)
		mp->work_tx &= ~(1 << txq->index);

	return reclaimed;
}


931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953
/* 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;

954 955
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
956 957 958
		wrlp(mp, TX_BW_RATE, token_rate);
		wrlp(mp, TX_BW_MTU, mtu);
		wrlp(mp, TX_BW_BURST, bucket_size);
959 960
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
961 962 963
		wrlp(mp, TX_BW_RATE_MOVED, token_rate);
		wrlp(mp, TX_BW_MTU_MOVED, mtu);
		wrlp(mp, TX_BW_BURST_MOVED, bucket_size);
964
		break;
965
	}
966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981
}

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;

982 983
	wrlp(mp, TXQ_BW_TOKENS(txq->index), token_rate << 14);
	wrlp(mp, TXQ_BW_CONF(txq->index), (bucket_size << 10) | token_rate);
984 985 986 987 988 989 990 991 992 993 994
}

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.
	 */
995 996 997
	off = 0;
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
998
		off = TXQ_FIX_PRIO_CONF;
999 1000
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
1001
		off = TXQ_FIX_PRIO_CONF_MOVED;
1002 1003
		break;
	}
1004

1005
	if (off) {
1006
		val = rdlp(mp, off);
1007
		val |= 1 << txq->index;
1008
		wrlp(mp, off, val);
1009
	}
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020
}

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.
	 */
1021 1022 1023
	off = 0;
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
1024
		off = TXQ_FIX_PRIO_CONF;
1025 1026
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
1027
		off = TXQ_FIX_PRIO_CONF_MOVED;
1028 1029
		break;
	}
1030

1031
	if (off) {
1032
		val = rdlp(mp, off);
1033
		val &= ~(1 << txq->index);
1034
		wrlp(mp, off, val);
1035

1036 1037 1038
		/*
		 * Configure WRR weight for this queue.
		 */
1039

1040
		val = rdlp(mp, off);
1041
		val = (val & ~0xff) | (weight & 0xff);
1042
		wrlp(mp, TXQ_BW_WRR_CONF(txq->index), val);
1043
	}
1044 1045 1046
}


1047
/* mii management interface *************************************************/
1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059
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;
}
1060

1061
static int smi_is_done(struct mv643xx_eth_shared_private *msp)
L
Linus Torvalds 已提交
1062
{
1063 1064
	return !(readl(msp->base + SMI_REG) & SMI_BUSY);
}
L
Linus Torvalds 已提交
1065

1066 1067 1068 1069
static int smi_wait_ready(struct mv643xx_eth_shared_private *msp)
{
	if (msp->err_interrupt == NO_IRQ) {
		int i;
1070

1071 1072 1073 1074
		for (i = 0; !smi_is_done(msp); i++) {
			if (i == 10)
				return -ETIMEDOUT;
			msleep(10);
1075
		}
1076 1077 1078 1079

		return 0;
	}

1080 1081 1082 1083 1084 1085
	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;
	}
1086 1087 1088 1089

	return 0;
}

1090
static int smi_bus_read(struct mii_bus *bus, int addr, int reg)
1091
{
1092
	struct mv643xx_eth_shared_private *msp = bus->priv;
1093 1094 1095 1096
	void __iomem *smi_reg = msp->base + SMI_REG;
	int ret;

	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1097
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1098
		return -ETIMEDOUT;
L
Linus Torvalds 已提交
1099 1100
	}

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

1103
	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1104
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1105
		return -ETIMEDOUT;
1106 1107 1108 1109
	}

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

1114
	return ret & 0xffff;
L
Linus Torvalds 已提交
1115 1116
}

1117
static int smi_bus_write(struct mii_bus *bus, int addr, int reg, u16 val)
L
Linus Torvalds 已提交
1118
{
1119
	struct mv643xx_eth_shared_private *msp = bus->priv;
1120
	void __iomem *smi_reg = msp->base + SMI_REG;
L
Linus Torvalds 已提交
1121

1122
	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1123
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1124
		return -ETIMEDOUT;
L
Linus Torvalds 已提交
1125 1126
	}

L
Lennert Buytenhek 已提交
1127
	writel(SMI_OPCODE_WRITE | (reg << 21) |
1128
		(addr << 16) | (val & 0xffff), smi_reg);
1129

1130
	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1131
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1132 1133
		return -ETIMEDOUT;
	}
1134 1135

	return 0;
1136
}
L
Linus Torvalds 已提交
1137

1138

1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
/* 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;
}

L
Lennert Buytenhek 已提交
1164
static inline u32 mib_read(struct mv643xx_eth_private *mp, int offset)
1165
{
L
Lennert Buytenhek 已提交
1166
	return rdl(mp, MIB_COUNTERS(mp->port_num) + offset);
L
Linus Torvalds 已提交
1167 1168
}

L
Lennert Buytenhek 已提交
1169
static void mib_counters_clear(struct mv643xx_eth_private *mp)
1170
{
L
Lennert Buytenhek 已提交
1171 1172 1173 1174
	int i;

	for (i = 0; i < 0x80; i += 4)
		mib_read(mp, i);
1175
}
1176

L
Lennert Buytenhek 已提交
1177
static void mib_counters_update(struct mv643xx_eth_private *mp)
1178
{
1179
	struct mib_counters *p = &mp->mib_counters;
1180

1181
	spin_lock(&mp->mib_counters_lock);
L
Lennert Buytenhek 已提交
1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213
	p->good_octets_received += mib_read(mp, 0x00);
	p->good_octets_received += (u64)mib_read(mp, 0x04) << 32;
	p->bad_octets_received += mib_read(mp, 0x08);
	p->internal_mac_transmit_err += mib_read(mp, 0x0c);
	p->good_frames_received += mib_read(mp, 0x10);
	p->bad_frames_received += mib_read(mp, 0x14);
	p->broadcast_frames_received += mib_read(mp, 0x18);
	p->multicast_frames_received += mib_read(mp, 0x1c);
	p->frames_64_octets += mib_read(mp, 0x20);
	p->frames_65_to_127_octets += mib_read(mp, 0x24);
	p->frames_128_to_255_octets += mib_read(mp, 0x28);
	p->frames_256_to_511_octets += mib_read(mp, 0x2c);
	p->frames_512_to_1023_octets += mib_read(mp, 0x30);
	p->frames_1024_to_max_octets += mib_read(mp, 0x34);
	p->good_octets_sent += mib_read(mp, 0x38);
	p->good_octets_sent += (u64)mib_read(mp, 0x3c) << 32;
	p->good_frames_sent += mib_read(mp, 0x40);
	p->excessive_collision += mib_read(mp, 0x44);
	p->multicast_frames_sent += mib_read(mp, 0x48);
	p->broadcast_frames_sent += mib_read(mp, 0x4c);
	p->unrec_mac_control_received += mib_read(mp, 0x50);
	p->fc_sent += mib_read(mp, 0x54);
	p->good_fc_received += mib_read(mp, 0x58);
	p->bad_fc_received += mib_read(mp, 0x5c);
	p->undersize_received += mib_read(mp, 0x60);
	p->fragments_received += mib_read(mp, 0x64);
	p->oversize_received += mib_read(mp, 0x68);
	p->jabber_received += mib_read(mp, 0x6c);
	p->mac_receive_error += mib_read(mp, 0x70);
	p->bad_crc_event += mib_read(mp, 0x74);
	p->collision += mib_read(mp, 0x78);
	p->late_collision += mib_read(mp, 0x7c);
1214 1215 1216 1217 1218 1219 1220 1221 1222 1223
	spin_unlock(&mp->mib_counters_lock);

	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);
1224 1225
}

1226

1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271 1272 1273 1274 1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301 1302 1303 1304 1305
/* 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);
}


1306
/* ethtool ******************************************************************/
1307
struct mv643xx_eth_stats {
1308 1309
	char stat_string[ETH_GSTRING_LEN];
	int sizeof_stat;
1310 1311
	int netdev_off;
	int mp_off;
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
#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) }

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),
1361 1362
};

L
Lennert Buytenhek 已提交
1363
static int
1364 1365
mv643xx_eth_get_settings_phy(struct mv643xx_eth_private *mp,
			     struct ethtool_cmd *cmd)
1366 1367 1368
{
	int err;

1369 1370 1371
	err = phy_read_status(mp->phy);
	if (err == 0)
		err = phy_ethtool_gset(mp->phy, cmd);
1372

L
Lennert Buytenhek 已提交
1373 1374 1375
	/*
	 * The MAC does not support 1000baseT_Half.
	 */
1376 1377 1378 1379 1380 1381
	cmd->supported &= ~SUPPORTED_1000baseT_Half;
	cmd->advertising &= ~ADVERTISED_1000baseT_Half;

	return err;
}

L
Lennert Buytenhek 已提交
1382
static int
1383
mv643xx_eth_get_settings_phyless(struct mv643xx_eth_private *mp,
L
Lennert Buytenhek 已提交
1384
				 struct ethtool_cmd *cmd)
1385
{
1386 1387
	u32 port_status;

1388
	port_status = rdlp(mp, PORT_STATUS);
1389

1390 1391
	cmd->supported = SUPPORTED_MII;
	cmd->advertising = ADVERTISED_MII;
1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406
	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;
1407 1408 1409 1410 1411 1412 1413 1414 1415 1416
	cmd->port = PORT_MII;
	cmd->phy_address = 0;
	cmd->transceiver = XCVR_INTERNAL;
	cmd->autoneg = AUTONEG_DISABLE;
	cmd->maxtxpkt = 1;
	cmd->maxrxpkt = 1;

	return 0;
}

1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427
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 已提交
1428 1429
static int
mv643xx_eth_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
L
Linus Torvalds 已提交
1430
{
1431
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1432

1433 1434 1435
	if (mp->phy == NULL)
		return -EINVAL;

L
Lennert Buytenhek 已提交
1436 1437 1438 1439 1440
	/*
	 * The MAC does not support 1000baseT_Half.
	 */
	cmd->advertising &= ~ADVERTISED_1000baseT_Half;

1441
	return phy_ethtool_sset(mp->phy, cmd);
1442
}
L
Linus Torvalds 已提交
1443

L
Lennert Buytenhek 已提交
1444 1445
static void mv643xx_eth_get_drvinfo(struct net_device *dev,
				    struct ethtool_drvinfo *drvinfo)
1446
{
1447 1448
	strncpy(drvinfo->driver,  mv643xx_eth_driver_name, 32);
	strncpy(drvinfo->version, mv643xx_eth_driver_version, 32);
1449
	strncpy(drvinfo->fw_version, "N/A", 32);
L
Lennert Buytenhek 已提交
1450
	strncpy(drvinfo->bus_info, "platform", 32);
1451
	drvinfo->n_stats = ARRAY_SIZE(mv643xx_eth_stats);
1452
}
L
Linus Torvalds 已提交
1453

L
Lennert Buytenhek 已提交
1454
static int mv643xx_eth_nway_reset(struct net_device *dev)
1455
{
1456
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
1457

1458 1459
	if (mp->phy == NULL)
		return -EINVAL;
L
Linus Torvalds 已提交
1460

1461
	return genphy_restart_aneg(mp->phy);
1462 1463
}

1464 1465
static u32 mv643xx_eth_get_link(struct net_device *dev)
{
1466
	return !!netif_carrier_ok(dev);
1467 1468
}

1469 1470 1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490
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;
}

1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530
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;
}

L
Lennert Buytenhek 已提交
1531 1532
static void mv643xx_eth_get_strings(struct net_device *dev,
				    uint32_t stringset, uint8_t *data)
1533 1534
{
	int i;
L
Linus Torvalds 已提交
1535

L
Lennert Buytenhek 已提交
1536 1537
	if (stringset == ETH_SS_STATS) {
		for (i = 0; i < ARRAY_SIZE(mv643xx_eth_stats); i++) {
1538
			memcpy(data + i * ETH_GSTRING_LEN,
1539
				mv643xx_eth_stats[i].stat_string,
1540
				ETH_GSTRING_LEN);
1541 1542 1543
		}
	}
}
L
Linus Torvalds 已提交
1544

L
Lennert Buytenhek 已提交
1545 1546 1547
static void mv643xx_eth_get_ethtool_stats(struct net_device *dev,
					  struct ethtool_stats *stats,
					  uint64_t *data)
1548
{
1549
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1550
	int i;
L
Linus Torvalds 已提交
1551

1552
	mv643xx_eth_get_stats(dev);
L
Lennert Buytenhek 已提交
1553
	mib_counters_update(mp);
L
Linus Torvalds 已提交
1554

1555 1556 1557 1558 1559 1560 1561 1562 1563 1564 1565 1566 1567
	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 已提交
1568
	}
1569
}
L
Linus Torvalds 已提交
1570

L
Lennert Buytenhek 已提交
1571
static int mv643xx_eth_get_sset_count(struct net_device *dev, int sset)
1572
{
L
Lennert Buytenhek 已提交
1573
	if (sset == ETH_SS_STATS)
1574
		return ARRAY_SIZE(mv643xx_eth_stats);
L
Lennert Buytenhek 已提交
1575 1576

	return -EOPNOTSUPP;
1577
}
L
Linus Torvalds 已提交
1578

1579
static const struct ethtool_ops mv643xx_eth_ethtool_ops = {
L
Lennert Buytenhek 已提交
1580 1581 1582 1583 1584
	.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,
1585 1586
	.get_coalesce		= mv643xx_eth_get_coalesce,
	.set_coalesce		= mv643xx_eth_set_coalesce,
1587 1588
	.get_ringparam		= mv643xx_eth_get_ringparam,
	.set_ringparam		= mv643xx_eth_set_ringparam,
1589
	.set_sg			= ethtool_op_set_sg,
L
Lennert Buytenhek 已提交
1590 1591
	.get_strings		= mv643xx_eth_get_strings,
	.get_ethtool_stats	= mv643xx_eth_get_ethtool_stats,
1592
	.get_sset_count		= mv643xx_eth_get_sset_count,
1593
};
L
Linus Torvalds 已提交
1594

1595

1596
/* address handling *********************************************************/
1597
static void uc_addr_get(struct mv643xx_eth_private *mp, unsigned char *addr)
1598
{
1599 1600
	unsigned int mac_h = rdlp(mp, MAC_ADDR_HIGH);
	unsigned int mac_l = rdlp(mp, MAC_ADDR_LOW);
L
Linus Torvalds 已提交
1601

1602 1603 1604 1605 1606 1607
	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;
1608
}
L
Linus Torvalds 已提交
1609

1610
static void uc_addr_set(struct mv643xx_eth_private *mp, unsigned char *addr)
1611
{
1612 1613 1614
	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]);
1615
}
1616

1617
static u32 uc_addr_filter_mask(struct net_device *dev)
1618
{
1619 1620
	struct dev_addr_list *uc_ptr;
	u32 nibbles;
L
Linus Torvalds 已提交
1621

1622 1623
	if (dev->flags & IFF_PROMISC)
		return 0;
L
Linus Torvalds 已提交
1624

1625 1626 1627 1628 1629 1630
	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;
1631

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

1635
	return nibbles;
L
Linus Torvalds 已提交
1636 1637
}

1638
static void mv643xx_eth_program_unicast_filter(struct net_device *dev)
L
Linus Torvalds 已提交
1639
{
1640
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1641 1642 1643
	u32 port_config;
	u32 nibbles;
	int i;
L
Linus Torvalds 已提交
1644

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

1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674
	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 已提交
1675 1676
}

1677 1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694
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;
}

1695
static void mv643xx_eth_program_multicast_filter(struct net_device *dev)
L
Linus Torvalds 已提交
1696
{
L
Lennert Buytenhek 已提交
1697
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1698 1699
	u32 *mc_spec;
	u32 *mc_other;
L
Lennert Buytenhek 已提交
1700 1701
	struct dev_addr_list *addr;
	int i;
1702

L
Lennert Buytenhek 已提交
1703
	if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
1704 1705 1706
		int port_num;
		u32 accept;
		int i;
1707

1708 1709 1710
oom:
		port_num = mp->port_num;
		accept = 0x01010101;
L
Lennert Buytenhek 已提交
1711 1712 1713
		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);
1714 1715 1716
		}
		return;
	}
1717

1718 1719 1720 1721 1722 1723 1724
	mc_spec = kmalloc(0x200, GFP_KERNEL);
	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 已提交
1725

L
Lennert Buytenhek 已提交
1726 1727
	for (addr = dev->mc_list; addr != NULL; addr = addr->next) {
		u8 *a = addr->da_addr;
1728 1729
		u32 *table;
		int entry;
L
Linus Torvalds 已提交
1730

L
Lennert Buytenhek 已提交
1731
		if (memcmp(a, "\x01\x00\x5e\x00\x00", 5) == 0) {
1732 1733
			table = mc_spec;
			entry = a[5];
L
Lennert Buytenhek 已提交
1734
		} else {
1735 1736
			table = mc_other;
			entry = addr_crc(a);
L
Lennert Buytenhek 已提交
1737
		}
1738

1739
		table[entry >> 2] |= 1 << (8 * (entry & 3));
L
Lennert Buytenhek 已提交
1740
	}
1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766

	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;
1767
}
1768 1769


1770
/* rx/tx queue initialisation ***********************************************/
1771
static int rxq_init(struct mv643xx_eth_private *mp, int index)
1772
{
1773
	struct rx_queue *rxq = mp->rxq + index;
1774 1775
	struct rx_desc *rx_desc;
	int size;
1776 1777
	int i;

1778 1779
	rxq->index = index;

1780
	rxq->rx_ring_size = mp->rx_ring_size;
1781 1782 1783 1784 1785 1786 1787

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

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

1788
	if (index == 0 && size <= mp->rx_desc_sram_size) {
1789 1790 1791 1792 1793 1794 1795
		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);
1796 1797
	}

1798 1799 1800 1801 1802 1803
	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 已提交
1804

1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815
	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++) {
1816 1817 1818 1819 1820 1821
		int nexti;

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

1822 1823 1824 1825 1826 1827 1828 1829
		rx_desc[i].next_desc_ptr = rxq->rx_desc_dma +
					nexti * sizeof(struct rx_desc);
	}

	return 0;


out_free:
1830
	if (index == 0 && size <= mp->rx_desc_sram_size)
1831 1832 1833 1834 1835 1836 1837 1838
		iounmap(rxq->rx_desc_area);
	else
		dma_free_coherent(NULL, size,
				  rxq->rx_desc_area,
				  rxq->rx_desc_dma);

out:
	return -ENOMEM;
1839
}
1840

1841
static void rxq_deinit(struct rx_queue *rxq)
1842
{
1843 1844 1845 1846
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	int i;

	rxq_disable(rxq);
1847

1848 1849 1850 1851
	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 已提交
1852
		}
1853
	}
L
Linus Torvalds 已提交
1854

1855 1856 1857 1858 1859 1860
	if (rxq->rx_desc_count) {
		dev_printk(KERN_ERR, &mp->dev->dev,
			   "error freeing rx ring -- %d skbs stuck\n",
			   rxq->rx_desc_count);
	}

1861
	if (rxq->index == 0 &&
1862
	    rxq->rx_desc_area_size <= mp->rx_desc_sram_size)
1863
		iounmap(rxq->rx_desc_area);
1864
	else
1865 1866 1867 1868
		dma_free_coherent(NULL, rxq->rx_desc_area_size,
				  rxq->rx_desc_area, rxq->rx_desc_dma);

	kfree(rxq->rx_skb);
1869
}
L
Linus Torvalds 已提交
1870

1871
static int txq_init(struct mv643xx_eth_private *mp, int index)
1872
{
1873
	struct tx_queue *txq = mp->txq + index;
1874 1875
	struct tx_desc *tx_desc;
	int size;
1876
	int i;
L
Linus Torvalds 已提交
1877

1878 1879
	txq->index = index;

1880
	txq->tx_ring_size = mp->tx_ring_size;
1881 1882 1883 1884 1885 1886 1887

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

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

1888
	if (index == 0 && size <= mp->tx_desc_sram_size) {
1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900
		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);
1901
		return -ENOMEM;
1902
	}
1903 1904 1905 1906 1907 1908
	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++) {
1909
		struct tx_desc *txd = tx_desc + i;
1910 1911 1912 1913 1914
		int nexti;

		nexti = i + 1;
		if (nexti == txq->tx_ring_size)
			nexti = 0;
1915 1916 1917

		txd->cmd_sts = 0;
		txd->next_desc_ptr = txq->tx_desc_dma +
1918 1919 1920
					nexti * sizeof(struct tx_desc);
	}

1921
	skb_queue_head_init(&txq->tx_skb);
1922

1923
	return 0;
1924
}
L
Linus Torvalds 已提交
1925

1926
static void txq_deinit(struct tx_queue *txq)
1927
{
1928
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
1929

1930
	txq_disable(txq);
1931
	txq_reclaim(txq, txq->tx_ring_size, 1);
L
Linus Torvalds 已提交
1932

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

1935
	if (txq->index == 0 &&
1936
	    txq->tx_desc_area_size <= mp->tx_desc_sram_size)
1937
		iounmap(txq->tx_desc_area);
1938
	else
1939 1940
		dma_free_coherent(NULL, txq->tx_desc_area_size,
				  txq->tx_desc_area, txq->tx_desc_dma);
1941
}
L
Linus Torvalds 已提交
1942 1943


1944
/* netdev ops and related ***************************************************/
1945 1946 1947 1948 1949
static int mv643xx_eth_collect_events(struct mv643xx_eth_private *mp)
{
	u32 int_cause;
	u32 int_cause_ext;

1950
	int_cause = rdlp(mp, INT_CAUSE) & (INT_TX_END | INT_RX | INT_EXT);
1951 1952 1953 1954 1955
	if (int_cause == 0)
		return 0;

	int_cause_ext = 0;
	if (int_cause & INT_EXT)
1956
		int_cause_ext = rdlp(mp, INT_CAUSE_EXT);
1957 1958 1959

	int_cause &= INT_TX_END | INT_RX;
	if (int_cause) {
1960
		wrlp(mp, INT_CAUSE, ~int_cause);
1961
		mp->work_tx_end |= ((int_cause & INT_TX_END) >> 19) &
1962
				~(rdlp(mp, TXQ_COMMAND) & 0xff);
1963 1964 1965 1966 1967
		mp->work_rx |= (int_cause & INT_RX) >> 2;
	}

	int_cause_ext &= INT_EXT_LINK_PHY | INT_EXT_TX;
	if (int_cause_ext) {
1968
		wrlp(mp, INT_CAUSE_EXT, ~int_cause_ext);
1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984
		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;

1985
	wrlp(mp, INT_MASK, 0);
1986 1987 1988 1989 1990
	napi_schedule(&mp->napi);

	return IRQ_HANDLED;
}

1991 1992 1993 1994 1995 1996 1997 1998
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;

1999
	port_status = rdlp(mp, PORT_STATUS);
2000 2001 2002 2003 2004 2005 2006 2007
	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);

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

2011
				txq_reclaim(txq, txq->tx_ring_size, 1);
2012
				txq_reset_hw_ptr(txq);
2013 2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
			}
		}
		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");

2040
	if (!netif_carrier_ok(dev))
2041 2042 2043
		netif_carrier_on(dev);
}

2044
static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
2045
{
2046 2047
	struct mv643xx_eth_private *mp;
	int work_done;
2048

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

2051 2052
	mp->work_rx_refill |= mp->work_rx_oom;
	mp->work_rx_oom = 0;
L
Linus Torvalds 已提交
2053

2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064
	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 已提交
2065

2066 2067 2068 2069 2070 2071 2072
		queue_mask = mp->work_tx | mp->work_tx_end |
				mp->work_rx | mp->work_rx_refill;
		if (!queue_mask) {
			if (mv643xx_eth_collect_events(mp))
				continue;
			break;
		}
L
Linus Torvalds 已提交
2073

2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092
		queue = fls(queue_mask) - 1;
		queue_mask = 1 << queue;

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

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

2095 2096 2097 2098
	if (work_done < budget) {
		if (mp->work_rx_oom)
			mod_timer(&mp->rx_oom, jiffies + (HZ / 10));
		napi_complete(napi);
2099
		wrlp(mp, INT_MASK, INT_TX_END | INT_RX | INT_EXT);
2100
	}
2101

2102 2103
	return work_done;
}
2104

2105 2106 2107
static inline void oom_timer_wrapper(unsigned long data)
{
	struct mv643xx_eth_private *mp = (void *)data;
L
Linus Torvalds 已提交
2108

2109
	napi_schedule(&mp->napi);
L
Linus Torvalds 已提交
2110 2111
}

2112
static void phy_reset(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2113
{
2114 2115
	int data;

2116
	data = phy_read(mp->phy, MII_BMCR);
2117 2118
	if (data < 0)
		return;
L
Linus Torvalds 已提交
2119

2120
	data |= BMCR_RESET;
2121
	if (phy_write(mp->phy, MII_BMCR, data) < 0)
2122
		return;
L
Linus Torvalds 已提交
2123

2124
	do {
2125
		data = phy_read(mp->phy, MII_BMCR);
2126
	} while (data >= 0 && data & BMCR_RESET);
L
Linus Torvalds 已提交
2127 2128
}

L
Lennert Buytenhek 已提交
2129
static void port_start(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2130
{
2131
	u32 pscr;
2132
	int i;
L
Linus Torvalds 已提交
2133

2134 2135 2136
	/*
	 * Perform PHY reset, if there is a PHY.
	 */
2137
	if (mp->phy != NULL) {
2138 2139 2140 2141 2142 2143
		struct ethtool_cmd cmd;

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

2145 2146 2147
	/*
	 * Configure basic link parameters.
	 */
2148
	pscr = rdlp(mp, PORT_SERIAL_CONTROL);
2149 2150

	pscr |= SERIAL_PORT_ENABLE;
2151
	wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2152 2153

	pscr |= DO_NOT_FORCE_LINK_FAIL;
2154
	if (mp->phy == NULL)
2155
		pscr |= FORCE_LINK_PASS;
2156
	wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2157

2158
	wrlp(mp, SDMA_CONFIG, PORT_SDMA_CONFIG_DEFAULT_VALUE);
2159

2160 2161 2162
	/*
	 * Configure TX path and queues.
	 */
2163
	tx_set_rate(mp, 1000000000, 16777216);
2164
	for (i = 0; i < mp->txq_count; i++) {
2165
		struct tx_queue *txq = mp->txq + i;
2166

2167
		txq_reset_hw_ptr(txq);
2168 2169
		txq_set_rate(txq, 1000000000, 16777216);
		txq_set_fixed_prio_mode(txq);
2170 2171
	}

L
Lennert Buytenhek 已提交
2172 2173 2174
	/*
	 * Add configured unicast address to address filter table.
	 */
2175
	mv643xx_eth_program_unicast_filter(mp->dev);
L
Linus Torvalds 已提交
2176

2177 2178
	/*
	 * Receive all unmatched unicast, TCP, UDP, BPDU and broadcast
2179 2180
	 * frames to RX queue #0, and include the pseudo-header when
	 * calculating receive checksums.
2181
	 */
2182
	wrlp(mp, PORT_CONFIG, 0x02000000);
2183

2184 2185 2186
	/*
	 * Treat BPDUs as normal multicasts, and disable partition mode.
	 */
2187
	wrlp(mp, PORT_CONFIG_EXT, 0x00000000);
2188

2189
	/*
2190
	 * Enable the receive queues.
2191
	 */
2192
	for (i = 0; i < mp->rxq_count; i++) {
2193
		struct rx_queue *rxq = mp->rxq + i;
2194
		u32 addr;
L
Linus Torvalds 已提交
2195

2196 2197
		addr = (u32)rxq->rx_desc_dma;
		addr += rxq->rx_curr_desc * sizeof(struct rx_desc);
2198
		wrlp(mp, RXQ_CURRENT_DESC_PTR(i), addr);
L
Linus Torvalds 已提交
2199

2200 2201
		rxq_enable(rxq);
	}
L
Linus Torvalds 已提交
2202 2203
}

2204 2205 2206 2207 2208 2209 2210 2211 2212 2213 2214 2215 2216 2217 2218 2219 2220 2221 2222 2223
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;
}

2224
static int mv643xx_eth_open(struct net_device *dev)
2225
{
2226
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2227
	int err;
2228
	int i;
2229

2230 2231 2232
	wrlp(mp, INT_CAUSE, 0);
	wrlp(mp, INT_CAUSE_EXT, 0);
	rdlp(mp, INT_CAUSE_EXT);
2233

L
Lennert Buytenhek 已提交
2234
	err = request_irq(dev->irq, mv643xx_eth_irq,
2235
			  IRQF_SHARED, dev->name, dev);
2236
	if (err) {
L
Lennert Buytenhek 已提交
2237
		dev_printk(KERN_ERR, &dev->dev, "can't assign irq\n");
2238
		return -EAGAIN;
2239 2240
	}

2241 2242
	mv643xx_eth_recalc_skb_size(mp);

2243 2244
	napi_enable(&mp->napi);

2245 2246
	skb_queue_head_init(&mp->rx_recycle);

2247
	for (i = 0; i < mp->rxq_count; i++) {
2248 2249 2250
		err = rxq_init(mp, i);
		if (err) {
			while (--i >= 0)
2251
				rxq_deinit(mp->rxq + i);
2252 2253 2254
			goto out;
		}

2255
		rxq_refill(mp->rxq + i, INT_MAX);
2256 2257
	}

2258
	if (mp->work_rx_oom) {
2259 2260
		mp->rx_oom.expires = jiffies + (HZ / 10);
		add_timer(&mp->rx_oom);
2261
	}
2262

2263
	for (i = 0; i < mp->txq_count; i++) {
2264 2265 2266
		err = txq_init(mp, i);
		if (err) {
			while (--i >= 0)
2267
				txq_deinit(mp->txq + i);
2268 2269 2270
			goto out_free;
		}
	}
2271

2272 2273
	netif_carrier_off(dev);

L
Lennert Buytenhek 已提交
2274
	port_start(mp);
2275

2276 2277
	set_rx_coal(mp, 0);
	set_tx_coal(mp, 0);
2278

2279 2280
	wrlp(mp, INT_MASK_EXT, INT_EXT_LINK_PHY | INT_EXT_TX);
	wrlp(mp, INT_MASK, INT_TX_END | INT_RX | INT_EXT);
2281

2282 2283
	return 0;

2284

L
Lennert Buytenhek 已提交
2285
out_free:
2286 2287
	for (i = 0; i < mp->rxq_count; i++)
		rxq_deinit(mp->rxq + i);
L
Lennert Buytenhek 已提交
2288
out:
2289 2290 2291
	free_irq(dev->irq, dev);

	return err;
2292 2293
}

2294
static void port_reset(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2295
{
L
Lennert Buytenhek 已提交
2296
	unsigned int data;
2297
	int i;
L
Linus Torvalds 已提交
2298

2299 2300 2301 2302
	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);
2303 2304

	while (1) {
2305
		u32 ps = rdlp(mp, PORT_STATUS);
2306 2307 2308

		if ((ps & (TX_IN_PROGRESS | TX_FIFO_EMPTY)) == TX_FIFO_EMPTY)
			break;
2309
		udelay(10);
2310
	}
L
Linus Torvalds 已提交
2311

2312
	/* Reset the Enable bit in the Configuration Register */
2313
	data = rdlp(mp, PORT_SERIAL_CONTROL);
L
Lennert Buytenhek 已提交
2314 2315 2316
	data &= ~(SERIAL_PORT_ENABLE		|
		  DO_NOT_FORCE_LINK_FAIL	|
		  FORCE_LINK_PASS);
2317
	wrlp(mp, PORT_SERIAL_CONTROL, data);
L
Linus Torvalds 已提交
2318 2319
}

2320
static int mv643xx_eth_stop(struct net_device *dev)
L
Linus Torvalds 已提交
2321
{
2322
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2323
	int i;
L
Linus Torvalds 已提交
2324

2325
	wrlp(mp, INT_MASK_EXT, 0x00000000);
2326 2327
	wrlp(mp, INT_MASK, 0x00000000);
	rdlp(mp, INT_MASK);
L
Linus Torvalds 已提交
2328

2329 2330
	del_timer_sync(&mp->mib_counters_timer);

2331
	napi_disable(&mp->napi);
2332

2333 2334
	del_timer_sync(&mp->rx_oom);

2335
	netif_carrier_off(dev);
L
Linus Torvalds 已提交
2336

L
Lennert Buytenhek 已提交
2337 2338
	free_irq(dev->irq, dev);

2339
	port_reset(mp);
2340
	mv643xx_eth_get_stats(dev);
L
Lennert Buytenhek 已提交
2341
	mib_counters_update(mp);
L
Linus Torvalds 已提交
2342

2343 2344
	skb_queue_purge(&mp->rx_recycle);

2345 2346 2347 2348
	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 已提交
2349

2350
	return 0;
L
Linus Torvalds 已提交
2351 2352
}

L
Lennert Buytenhek 已提交
2353
static int mv643xx_eth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
L
Linus Torvalds 已提交
2354
{
2355
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
2356

2357 2358
	if (mp->phy != NULL)
		return phy_mii_ioctl(mp->phy, if_mii(ifr), cmd);
2359 2360

	return -EOPNOTSUPP;
L
Linus Torvalds 已提交
2361 2362
}

2363
static int mv643xx_eth_change_mtu(struct net_device *dev, int new_mtu)
L
Linus Torvalds 已提交
2364
{
2365 2366
	struct mv643xx_eth_private *mp = netdev_priv(dev);

L
Lennert Buytenhek 已提交
2367
	if (new_mtu < 64 || new_mtu > 9500)
2368
		return -EINVAL;
L
Linus Torvalds 已提交
2369

2370
	dev->mtu = new_mtu;
2371
	mv643xx_eth_recalc_skb_size(mp);
2372 2373
	tx_set_rate(mp, 1000000000, 16777216);

2374 2375
	if (!netif_running(dev))
		return 0;
L
Linus Torvalds 已提交
2376

2377 2378 2379 2380
	/*
	 * 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 已提交
2381
	 * due to memory being full.
2382 2383 2384
	 */
	mv643xx_eth_stop(dev);
	if (mv643xx_eth_open(dev)) {
L
Lennert Buytenhek 已提交
2385 2386 2387
		dev_printk(KERN_ERR, &dev->dev,
			   "fatal error on re-opening device after "
			   "MTU change\n");
2388 2389 2390
	}

	return 0;
L
Linus Torvalds 已提交
2391 2392
}

L
Lennert Buytenhek 已提交
2393
static void tx_timeout_task(struct work_struct *ugly)
L
Linus Torvalds 已提交
2394
{
L
Lennert Buytenhek 已提交
2395
	struct mv643xx_eth_private *mp;
L
Linus Torvalds 已提交
2396

L
Lennert Buytenhek 已提交
2397 2398
	mp = container_of(ugly, struct mv643xx_eth_private, tx_timeout_task);
	if (netif_running(mp->dev)) {
2399
		netif_tx_stop_all_queues(mp->dev);
L
Lennert Buytenhek 已提交
2400 2401
		port_reset(mp);
		port_start(mp);
2402
		netif_tx_wake_all_queues(mp->dev);
L
Lennert Buytenhek 已提交
2403
	}
2404 2405 2406
}

static void mv643xx_eth_tx_timeout(struct net_device *dev)
L
Linus Torvalds 已提交
2407
{
2408
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
2409

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

2412
	schedule_work(&mp->tx_timeout_task);
L
Linus Torvalds 已提交
2413 2414
}

2415
#ifdef CONFIG_NET_POLL_CONTROLLER
L
Lennert Buytenhek 已提交
2416
static void mv643xx_eth_netpoll(struct net_device *dev)
2417
{
L
Lennert Buytenhek 已提交
2418
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2419

2420 2421
	wrlp(mp, INT_MASK, 0x00000000);
	rdlp(mp, INT_MASK);
2422

L
Lennert Buytenhek 已提交
2423
	mv643xx_eth_irq(dev->irq, dev);
2424

2425
	wrlp(mp, INT_MASK, INT_TX_END | INT_RX | INT_EXT);
2426
}
2427
#endif
2428 2429


2430
/* platform glue ************************************************************/
2431 2432 2433
static void
mv643xx_eth_conf_mbus_windows(struct mv643xx_eth_shared_private *msp,
			      struct mbus_dram_target_info *dram)
2434
{
2435
	void __iomem *base = msp->base;
2436 2437 2438
	u32 win_enable;
	u32 win_protect;
	int i;
2439

2440 2441 2442 2443 2444
	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));
2445 2446
	}

2447 2448 2449 2450 2451 2452 2453 2454 2455 2456 2457 2458 2459 2460 2461 2462 2463
	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;
2464 2465
}

2466 2467 2468 2469 2470 2471 2472
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.
	 */
2473 2474
	writel(0x02000000, msp->base + 0x0400 + SDMA_CONFIG);
	if (readl(msp->base + 0x0400 + SDMA_CONFIG) & 0x02000000)
2475 2476 2477
		msp->extended_rx_coal_limit = 1;
	else
		msp->extended_rx_coal_limit = 0;
2478 2479

	/*
2480 2481 2482
	 * Check whether the MAC supports TX rate control, and if
	 * yes, whether its associated registers are in the old or
	 * the new place.
2483
	 */
2484 2485
	writel(1, msp->base + 0x0400 + TX_BW_MTU_MOVED);
	if (readl(msp->base + 0x0400 + TX_BW_MTU_MOVED) & 1) {
2486 2487
		msp->tx_bw_control = TX_BW_CONTROL_NEW_LAYOUT;
	} else {
2488 2489
		writel(7, msp->base + 0x0400 + TX_BW_RATE);
		if (readl(msp->base + 0x0400 + TX_BW_RATE) & 7)
2490 2491 2492 2493
			msp->tx_bw_control = TX_BW_CONTROL_OLD_LAYOUT;
		else
			msp->tx_bw_control = TX_BW_CONTROL_ABSENT;
	}
2494 2495
}

2496
static int mv643xx_eth_shared_probe(struct platform_device *pdev)
2497
{
L
Lennert Buytenhek 已提交
2498
	static int mv643xx_eth_version_printed;
2499
	struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
2500
	struct mv643xx_eth_shared_private *msp;
2501 2502
	struct resource *res;
	int ret;
2503

2504
	if (!mv643xx_eth_version_printed++)
2505 2506
		printk(KERN_NOTICE "MV-643xx 10/100/1000 ethernet "
			"driver version %s\n", mv643xx_eth_driver_version);
2507

2508 2509 2510 2511
	ret = -EINVAL;
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL)
		goto out;
2512

2513 2514 2515 2516 2517 2518
	ret = -ENOMEM;
	msp = kmalloc(sizeof(*msp), GFP_KERNEL);
	if (msp == NULL)
		goto out;
	memset(msp, 0, sizeof(*msp));

2519 2520
	msp->base = ioremap(res->start, res->end - res->start + 1);
	if (msp->base == NULL)
2521 2522
		goto out_free;

2523 2524 2525 2526
	/*
	 * Set up and register SMI bus.
	 */
	if (pd == NULL || pd->shared_smi == NULL) {
2527 2528
		msp->smi_bus = mdiobus_alloc();
		if (msp->smi_bus == NULL)
2529
			goto out_unmap;
2530 2531 2532 2533 2534 2535 2536 2537 2538 2539

		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;
2540 2541
		msp->smi = msp;
	} else {
2542
		msp->smi = platform_get_drvdata(pd->shared_smi);
2543
	}
2544

2545 2546 2547 2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562
	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;
		}
	}

2563 2564 2565 2566 2567 2568
	/*
	 * (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 已提交
2569 2570 2571 2572
	/*
	 * Detect hardware parameters.
	 */
	msp->t_clk = (pd != NULL && pd->t_clk != 0) ? pd->t_clk : 133000000;
2573
	infer_hw_params(msp);
L
Lennert Buytenhek 已提交
2574 2575 2576

	platform_set_drvdata(pdev, msp);

2577 2578
	return 0;

2579 2580
out_free_mii_bus:
	mdiobus_free(msp->smi_bus);
2581 2582
out_unmap:
	iounmap(msp->base);
2583 2584 2585 2586 2587 2588 2589 2590
out_free:
	kfree(msp);
out:
	return ret;
}

static int mv643xx_eth_shared_remove(struct platform_device *pdev)
{
2591
	struct mv643xx_eth_shared_private *msp = platform_get_drvdata(pdev);
2592
	struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
2593

2594 2595
	if (pd == NULL || pd->shared_smi == NULL) {
		mdiobus_unregister(msp->smi_bus);
2596
		mdiobus_free(msp->smi_bus);
2597
	}
2598 2599
	if (msp->err_interrupt != NO_IRQ)
		free_irq(msp->err_interrupt, msp);
2600
	iounmap(msp->base);
2601 2602 2603
	kfree(msp);

	return 0;
2604 2605
}

2606
static struct platform_driver mv643xx_eth_shared_driver = {
L
Lennert Buytenhek 已提交
2607 2608
	.probe		= mv643xx_eth_shared_probe,
	.remove		= mv643xx_eth_shared_remove,
2609
	.driver = {
L
Lennert Buytenhek 已提交
2610
		.name	= MV643XX_ETH_SHARED_NAME,
2611 2612 2613 2614
		.owner	= THIS_MODULE,
	},
};

2615
static void phy_addr_set(struct mv643xx_eth_private *mp, int phy_addr)
L
Linus Torvalds 已提交
2616
{
2617
	int addr_shift = 5 * mp->port_num;
L
Lennert Buytenhek 已提交
2618
	u32 data;
L
Linus Torvalds 已提交
2619

L
Lennert Buytenhek 已提交
2620 2621 2622 2623
	data = rdl(mp, PHY_ADDR);
	data &= ~(0x1f << addr_shift);
	data |= (phy_addr & 0x1f) << addr_shift;
	wrl(mp, PHY_ADDR, data);
L
Linus Torvalds 已提交
2624 2625
}

2626
static int phy_addr_get(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2627
{
L
Lennert Buytenhek 已提交
2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644
	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);

2645
	mp->rx_ring_size = DEFAULT_RX_QUEUE_SIZE;
L
Lennert Buytenhek 已提交
2646
	if (pd->rx_queue_size)
2647
		mp->rx_ring_size = pd->rx_queue_size;
L
Lennert Buytenhek 已提交
2648 2649
	mp->rx_desc_sram_addr = pd->rx_sram_addr;
	mp->rx_desc_sram_size = pd->rx_sram_size;
L
Linus Torvalds 已提交
2650

2651
	mp->rxq_count = pd->rx_queue_count ? : 1;
2652

2653
	mp->tx_ring_size = DEFAULT_TX_QUEUE_SIZE;
L
Lennert Buytenhek 已提交
2654
	if (pd->tx_queue_size)
2655
		mp->tx_ring_size = pd->tx_queue_size;
L
Lennert Buytenhek 已提交
2656 2657
	mp->tx_desc_sram_addr = pd->tx_sram_addr;
	mp->tx_desc_sram_size = pd->tx_sram_size;
2658

2659
	mp->txq_count = pd->tx_queue_count ? : 1;
L
Linus Torvalds 已提交
2660 2661
}

2662 2663
static struct phy_device *phy_scan(struct mv643xx_eth_private *mp,
				   int phy_addr)
L
Linus Torvalds 已提交
2664
{
2665
	struct mii_bus *bus = mp->shared->smi->smi_bus;
2666 2667 2668 2669
	struct phy_device *phydev;
	int start;
	int num;
	int i;
2670

2671 2672 2673 2674 2675 2676 2677
	if (phy_addr == MV643XX_ETH_PHY_ADDR_DEFAULT) {
		start = phy_addr_get(mp) & 0x1f;
		num = 32;
	} else {
		start = phy_addr & 0x1f;
		num = 1;
	}
2678

2679 2680 2681
	phydev = NULL;
	for (i = 0; i < num; i++) {
		int addr = (start + i) & 0x1f;
L
Lennert Buytenhek 已提交
2682

2683 2684
		if (bus->phy_map[addr] == NULL)
			mdiobus_scan(bus, addr);
L
Linus Torvalds 已提交
2685

2686 2687 2688 2689 2690 2691
		if (phydev == NULL) {
			phydev = bus->phy_map[addr];
			if (phydev != NULL)
				phy_addr_set(mp, addr);
		}
	}
L
Linus Torvalds 已提交
2692

2693
	return phydev;
L
Linus Torvalds 已提交
2694 2695
}

2696
static void phy_init(struct mv643xx_eth_private *mp, int speed, int duplex)
2697
{
2698
	struct phy_device *phy = mp->phy;
2699

L
Lennert Buytenhek 已提交
2700 2701
	phy_reset(mp);

2702
	phy_attach(mp->dev, dev_name(&phy->dev), 0, PHY_INTERFACE_MODE_GMII);
2703 2704 2705 2706 2707 2708

	if (speed == 0) {
		phy->autoneg = AUTONEG_ENABLE;
		phy->speed = 0;
		phy->duplex = 0;
		phy->advertising = phy->supported | ADVERTISED_Autoneg;
2709
	} else {
2710 2711 2712 2713
		phy->autoneg = AUTONEG_DISABLE;
		phy->advertising = 0;
		phy->speed = speed;
		phy->duplex = duplex;
2714
	}
2715
	phy_start_aneg(phy);
2716 2717
}

2718 2719 2720 2721
static void init_pscr(struct mv643xx_eth_private *mp, int speed, int duplex)
{
	u32 pscr;

2722
	pscr = rdlp(mp, PORT_SERIAL_CONTROL);
2723 2724
	if (pscr & SERIAL_PORT_ENABLE) {
		pscr &= ~SERIAL_PORT_ENABLE;
2725
		wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2726 2727 2728
	}

	pscr = MAX_RX_PACKET_9700BYTE | SERIAL_PORT_CONTROL_RESERVED;
2729
	if (mp->phy == NULL) {
2730 2731 2732 2733 2734 2735 2736 2737 2738 2739 2740 2741 2742
		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;
	}

2743
	wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2744 2745
}

2746
static int mv643xx_eth_probe(struct platform_device *pdev)
L
Linus Torvalds 已提交
2747
{
2748
	struct mv643xx_eth_platform_data *pd;
2749
	struct mv643xx_eth_private *mp;
2750 2751
	struct net_device *dev;
	struct resource *res;
L
Lennert Buytenhek 已提交
2752
	int err;
L
Linus Torvalds 已提交
2753

2754 2755
	pd = pdev->dev.platform_data;
	if (pd == NULL) {
L
Lennert Buytenhek 已提交
2756 2757
		dev_printk(KERN_ERR, &pdev->dev,
			   "no mv643xx_eth_platform_data\n");
2758 2759
		return -ENODEV;
	}
L
Linus Torvalds 已提交
2760

2761
	if (pd->shared == NULL) {
L
Lennert Buytenhek 已提交
2762 2763
		dev_printk(KERN_ERR, &pdev->dev,
			   "no mv643xx_eth_platform_data->shared\n");
2764 2765
		return -ENODEV;
	}
2766

2767
	dev = alloc_etherdev_mq(sizeof(struct mv643xx_eth_private), 8);
2768 2769
	if (!dev)
		return -ENOMEM;
L
Linus Torvalds 已提交
2770

2771
	mp = netdev_priv(dev);
L
Lennert Buytenhek 已提交
2772 2773 2774
	platform_set_drvdata(pdev, mp);

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

2778
	mp->dev = dev;
2779

L
Lennert Buytenhek 已提交
2780
	set_params(mp, pd);
2781
	dev->real_num_tx_queues = mp->txq_count;
L
Lennert Buytenhek 已提交
2782

2783 2784
	if (pd->phy_addr != MV643XX_ETH_PHY_NONE)
		mp->phy = phy_scan(mp, pd->phy_addr);
2785

2786
	if (mp->phy != NULL)
2787
		phy_init(mp, pd->speed, pd->duplex);
2788 2789

	SET_ETHTOOL_OPS(dev, &mv643xx_eth_ethtool_ops);
2790

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

2793 2794 2795 2796 2797 2798 2799 2800 2801 2802 2803 2804 2805

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

2806 2807 2808 2809 2810 2811
	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 已提交
2812

2813 2814 2815
	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	BUG_ON(!res);
	dev->irq = res->start;
L
Linus Torvalds 已提交
2816

2817
	dev->get_stats = mv643xx_eth_get_stats;
L
Lennert Buytenhek 已提交
2818
	dev->hard_start_xmit = mv643xx_eth_xmit;
2819 2820
	dev->open = mv643xx_eth_open;
	dev->stop = mv643xx_eth_stop;
2821
	dev->set_rx_mode = mv643xx_eth_set_rx_mode;
L
Lennert Buytenhek 已提交
2822 2823 2824
	dev->set_mac_address = mv643xx_eth_set_mac_address;
	dev->do_ioctl = mv643xx_eth_ioctl;
	dev->change_mtu = mv643xx_eth_change_mtu;
2825 2826
	dev->tx_timeout = mv643xx_eth_tx_timeout;
#ifdef CONFIG_NET_POLL_CONTROLLER
2827
	dev->poll_controller = mv643xx_eth_netpoll;
2828 2829 2830
#endif
	dev->watchdog_timeo = 2 * HZ;
	dev->base_addr = 0;
L
Linus Torvalds 已提交
2831

2832
	dev->features = NETIF_F_SG | NETIF_F_IP_CSUM;
2833
	dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM;
L
Linus Torvalds 已提交
2834

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

2837
	if (mp->shared->win_protect)
L
Lennert Buytenhek 已提交
2838
		wrl(mp, WINDOW_PROTECT(mp->port_num), mp->shared->win_protect);
L
Linus Torvalds 已提交
2839

2840 2841 2842
	err = register_netdev(dev);
	if (err)
		goto out;
L
Linus Torvalds 已提交
2843

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

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

2850
	return 0;
L
Linus Torvalds 已提交
2851

2852 2853
out:
	free_netdev(dev);
L
Linus Torvalds 已提交
2854

2855
	return err;
L
Linus Torvalds 已提交
2856 2857
}

2858
static int mv643xx_eth_remove(struct platform_device *pdev)
L
Linus Torvalds 已提交
2859
{
L
Lennert Buytenhek 已提交
2860
	struct mv643xx_eth_private *mp = platform_get_drvdata(pdev);
L
Linus Torvalds 已提交
2861

L
Lennert Buytenhek 已提交
2862
	unregister_netdev(mp->dev);
2863 2864
	if (mp->phy != NULL)
		phy_detach(mp->phy);
2865
	flush_scheduled_work();
L
Lennert Buytenhek 已提交
2866
	free_netdev(mp->dev);
2867 2868

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

2870
	return 0;
L
Linus Torvalds 已提交
2871 2872
}

2873
static void mv643xx_eth_shutdown(struct platform_device *pdev)
2874
{
L
Lennert Buytenhek 已提交
2875
	struct mv643xx_eth_private *mp = platform_get_drvdata(pdev);
2876

2877
	/* Mask all interrupts on ethernet port */
2878 2879
	wrlp(mp, INT_MASK, 0);
	rdlp(mp, INT_MASK);
2880

L
Lennert Buytenhek 已提交
2881 2882
	if (netif_running(mp->dev))
		port_reset(mp);
2883 2884
}

2885
static struct platform_driver mv643xx_eth_driver = {
L
Lennert Buytenhek 已提交
2886 2887 2888
	.probe		= mv643xx_eth_probe,
	.remove		= mv643xx_eth_remove,
	.shutdown	= mv643xx_eth_shutdown,
2889
	.driver = {
L
Lennert Buytenhek 已提交
2890
		.name	= MV643XX_ETH_NAME,
2891 2892 2893 2894
		.owner	= THIS_MODULE,
	},
};

2895
static int __init mv643xx_eth_init_module(void)
2896
{
2897
	int rc;
2898

2899 2900 2901 2902 2903 2904
	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 已提交
2905

2906
	return rc;
2907
}
L
Lennert Buytenhek 已提交
2908
module_init(mv643xx_eth_init_module);
2909

2910
static void __exit mv643xx_eth_cleanup_module(void)
2911
{
2912 2913
	platform_driver_unregister(&mv643xx_eth_driver);
	platform_driver_unregister(&mv643xx_eth_shared_driver);
2914
}
2915
module_exit(mv643xx_eth_cleanup_module);
L
Linus Torvalds 已提交
2916

2917 2918
MODULE_AUTHOR("Rabeeh Khoury, Assaf Hoffman, Matthew Dharm, "
	      "Manish Lachwani, Dale Farnsworth and Lennert Buytenhek");
2919
MODULE_DESCRIPTION("Ethernet driver for Marvell MV643XX");
L
Lennert Buytenhek 已提交
2920
MODULE_LICENSE("GPL");
2921
MODULE_ALIAS("platform:" MV643XX_ETH_SHARED_NAME);
L
Lennert Buytenhek 已提交
2922
MODULE_ALIAS("platform:" MV643XX_ETH_NAME);