mv643xx_eth.c 66.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
Linus Torvalds 已提交
54 55 56
#include <asm/io.h>
#include <asm/types.h>
#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

/*
 * Per-port registers.
 */
83
#define PORT_CONFIG(p)			(0x0400 + ((p) << 10))
84
#define  UNICAST_PROMISCUOUS_MODE	0x00000001
85 86 87 88 89 90
#define PORT_CONFIG_EXT(p)		(0x0404 + ((p) << 10))
#define MAC_ADDR_LOW(p)			(0x0414 + ((p) << 10))
#define MAC_ADDR_HIGH(p)		(0x0418 + ((p) << 10))
#define SDMA_CONFIG(p)			(0x041c + ((p) << 10))
#define PORT_SERIAL_CONTROL(p)		(0x043c + ((p) << 10))
#define PORT_STATUS(p)			(0x0444 + ((p) << 10))
91
#define  TX_FIFO_EMPTY			0x00000400
92
#define  TX_IN_PROGRESS			0x00000080
93 94 95 96 97 98
#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
99
#define  LINK_UP			0x00000002
100
#define TXQ_COMMAND(p)			(0x0448 + ((p) << 10))
101 102
#define TXQ_FIX_PRIO_CONF(p)		(0x044c + ((p) << 10))
#define TX_BW_RATE(p)			(0x0450 + ((p) << 10))
103
#define TX_BW_MTU(p)			(0x0458 + ((p) << 10))
104
#define TX_BW_BURST(p)			(0x045c + ((p) << 10))
105
#define INT_CAUSE(p)			(0x0460 + ((p) << 10))
106
#define  INT_TX_END			0x07f80000
107
#define  INT_RX				0x000003fc
108
#define  INT_EXT			0x00000002
109
#define INT_CAUSE_EXT(p)		(0x0464 + ((p) << 10))
110 111
#define  INT_EXT_LINK_PHY		0x00110000
#define  INT_EXT_TX			0x000000ff
112 113 114
#define INT_MASK(p)			(0x0468 + ((p) << 10))
#define INT_MASK_EXT(p)			(0x046c + ((p) << 10))
#define TX_FIFO_URGENT_THRESHOLD(p)	(0x0474 + ((p) << 10))
115 116 117 118
#define TXQ_FIX_PRIO_CONF_MOVED(p)	(0x04dc + ((p) << 10))
#define TX_BW_RATE_MOVED(p)		(0x04e0 + ((p) << 10))
#define TX_BW_MTU_MOVED(p)		(0x04e8 + ((p) << 10))
#define TX_BW_BURST_MOVED(p)		(0x04ec + ((p) << 10))
119
#define RXQ_CURRENT_DESC_PTR(p, q)	(0x060c + ((p) << 10) + ((q) << 4))
120
#define RXQ_COMMAND(p)			(0x0680 + ((p) << 10))
121 122 123 124
#define TXQ_CURRENT_DESC_PTR(p, q)	(0x06c0 + ((p) << 10) + ((q) << 2))
#define TXQ_BW_TOKENS(p, q)		(0x0700 + ((p) << 10) + ((q) << 4))
#define TXQ_BW_CONF(p, q)		(0x0704 + ((p) << 10) + ((q) << 4))
#define TXQ_BW_WRR_CONF(p, q)		(0x0708 + ((p) << 10) + ((q) << 4))
125 126 127 128
#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))
129

130 131 132 133

/*
 * SDMA configuration register.
 */
134
#define RX_BURST_SIZE_16_64BIT		(4 << 1)
135 136
#define BLM_RX_NO_SWAP			(1 << 4)
#define BLM_TX_NO_SWAP			(1 << 5)
137
#define TX_BURST_SIZE_16_64BIT		(4 << 22)
138 139 140

#if defined(__BIG_ENDIAN)
#define PORT_SDMA_CONFIG_DEFAULT_VALUE		\
141 142
		RX_BURST_SIZE_16_64BIT	|	\
		TX_BURST_SIZE_16_64BIT
143 144
#elif defined(__LITTLE_ENDIAN)
#define PORT_SDMA_CONFIG_DEFAULT_VALUE		\
145
		RX_BURST_SIZE_16_64BIT	|	\
146 147
		BLM_RX_NO_SWAP		|	\
		BLM_TX_NO_SWAP		|	\
148
		TX_BURST_SIZE_16_64BIT
149 150 151 152
#else
#error One of __BIG_ENDIAN or __LITTLE_ENDIAN must be defined
#endif

153 154 155 156 157 158 159

/*
 * 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)
160
#define MAX_RX_PACKET_9700BYTE			(5 << 17)
161 162 163 164 165 166 167
#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)
168

169 170
#define DEFAULT_RX_QUEUE_SIZE		128
#define DEFAULT_TX_QUEUE_SIZE		256
171 172


173 174
/*
 * RX/TX descriptors.
175 176
 */
#if defined(__BIG_ENDIAN)
177
struct rx_desc {
178 179 180 181 182 183 184
	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		*/
};

185
struct tx_desc {
186 187 188 189 190 191 192
	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)
193
struct rx_desc {
194 195 196 197 198 199 200
	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		*/
};

201
struct tx_desc {
202 203 204 205 206 207 208 209 210 211
	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

212
/* RX & TX descriptor command */
213
#define BUFFER_OWNED_BY_DMA		0x80000000
214 215

/* RX & TX descriptor status */
216
#define ERROR_SUMMARY			0x00000001
217 218

/* RX descriptor status */
219 220 221 222
#define LAYER_4_CHECKSUM_OK		0x40000000
#define RX_ENABLE_INTERRUPT		0x20000000
#define RX_FIRST_DESC			0x08000000
#define RX_LAST_DESC			0x04000000
223 224

/* TX descriptor command */
225 226 227 228 229 230 231 232
#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
233 234
#define MAC_HDR_EXTRA_4_BYTES		0x00008000
#define MAC_HDR_EXTRA_8_BYTES		0x00000200
235

236
#define TX_IHL_SHIFT			11
237 238


239
/* global *******************************************************************/
240
struct mv643xx_eth_shared_private {
L
Lennert Buytenhek 已提交
241 242 243
	/*
	 * Ethernet controller base address.
	 */
244
	void __iomem *base;
245

246 247 248 249 250
	/*
	 * Points at the right SMI instance to use.
	 */
	struct mv643xx_eth_shared_private *smi;

L
Lennert Buytenhek 已提交
251
	/*
252
	 * Provides access to local SMI interface.
L
Lennert Buytenhek 已提交
253
	 */
254
	struct mii_bus *smi_bus;
255

256 257 258 259 260 261 262 263 264
	/*
	 * 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 已提交
265 266 267
	/*
	 * Per-port MBUS window access register value.
	 */
268 269
	u32 win_protect;

L
Lennert Buytenhek 已提交
270 271 272
	/*
	 * Hardware-specific parameters.
	 */
273
	unsigned int t_clk;
274
	int extended_rx_coal_limit;
275
	int tx_bw_control;
276 277
};

278 279 280 281
#define TX_BW_CONTROL_ABSENT		0
#define TX_BW_CONTROL_OLD_LAYOUT	1
#define TX_BW_CONTROL_NEW_LAYOUT	2

282 283

/* per-port *****************************************************************/
284
struct mib_counters {
285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316
	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;
};

317
struct rx_queue {
318 319
	int index;

320 321 322 323 324 325 326 327 328 329 330 331
	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;
};

332
struct tx_queue {
333 334
	int index;

335
	int tx_ring_size;
336

337 338 339
	int tx_desc_count;
	int tx_curr_desc;
	int tx_used_desc;
340

341
	struct tx_desc *tx_desc_area;
342 343
	dma_addr_t tx_desc_dma;
	int tx_desc_area_size;
344 345

	struct sk_buff_head tx_skb;
346 347 348 349

	unsigned long tx_packets;
	unsigned long tx_bytes;
	unsigned long tx_dropped;
350 351 352 353
};

struct mv643xx_eth_private {
	struct mv643xx_eth_shared_private *shared;
L
Lennert Buytenhek 已提交
354
	int port_num;
355

L
Lennert Buytenhek 已提交
356
	struct net_device *dev;
357

358
	struct phy_device *phy;
359

360 361
	struct timer_list mib_counters_timer;
	spinlock_t mib_counters_lock;
L
Lennert Buytenhek 已提交
362
	struct mib_counters mib_counters;
363

L
Lennert Buytenhek 已提交
364
	struct work_struct tx_timeout_task;
365

366 367 368 369 370 371 372 373
	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;

374 375 376
	int skb_size;
	struct sk_buff_head rx_recycle;

377 378 379 380 381 382
	/*
	 * RX state.
	 */
	int default_rx_ring_size;
	unsigned long rx_desc_sram_addr;
	int rx_desc_sram_size;
383
	int rxq_count;
384
	struct timer_list rx_oom;
385
	struct rx_queue rxq[8];
386 387 388 389 390 391 392

	/*
	 * TX state.
	 */
	int default_tx_ring_size;
	unsigned long tx_desc_sram_addr;
	int tx_desc_sram_size;
393
	int txq_count;
394
	struct tx_queue txq[8];
395
};
L
Linus Torvalds 已提交
396

397

398
/* port register accessors **************************************************/
399
static inline u32 rdl(struct mv643xx_eth_private *mp, int offset)
400
{
401
	return readl(mp->shared->base + offset);
402
}
403

404
static inline void wrl(struct mv643xx_eth_private *mp, int offset, u32 data)
405
{
406
	writel(data, mp->shared->base + offset);
407
}
408 409


410
/* rxq/txq helper functions *************************************************/
411
static struct mv643xx_eth_private *rxq_to_mp(struct rx_queue *rxq)
412
{
413
	return container_of(rxq, struct mv643xx_eth_private, rxq[rxq->index]);
414
}
415

416 417
static struct mv643xx_eth_private *txq_to_mp(struct tx_queue *txq)
{
418
	return container_of(txq, struct mv643xx_eth_private, txq[txq->index]);
419 420
}

421
static void rxq_enable(struct rx_queue *rxq)
422
{
423
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
424
	wrl(mp, RXQ_COMMAND(mp->port_num), 1 << rxq->index);
425
}
L
Linus Torvalds 已提交
426

427 428 429
static void rxq_disable(struct rx_queue *rxq)
{
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
430
	u8 mask = 1 << rxq->index;
L
Linus Torvalds 已提交
431

432 433 434
	wrl(mp, RXQ_COMMAND(mp->port_num), mask << 8);
	while (rdl(mp, RXQ_COMMAND(mp->port_num)) & mask)
		udelay(10);
435 436
}

437 438 439 440 441 442 443 444 445 446 447
static void txq_reset_hw_ptr(struct tx_queue *txq)
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
	int off = TXQ_CURRENT_DESC_PTR(mp->port_num, txq->index);
	u32 addr;

	addr = (u32)txq->tx_desc_dma;
	addr += txq->tx_curr_desc * sizeof(struct tx_desc);
	wrl(mp, off, addr);
}

448
static void txq_enable(struct tx_queue *txq)
L
Linus Torvalds 已提交
449
{
450
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
451
	wrl(mp, TXQ_COMMAND(mp->port_num), 1 << txq->index);
L
Linus Torvalds 已提交
452 453
}

454
static void txq_disable(struct tx_queue *txq)
L
Linus Torvalds 已提交
455
{
456
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
457
	u8 mask = 1 << txq->index;
458

459 460 461 462 463
	wrl(mp, TXQ_COMMAND(mp->port_num), mask << 8);
	while (rdl(mp, TXQ_COMMAND(mp->port_num)) & mask)
		udelay(10);
}

464
static void txq_maybe_wake(struct tx_queue *txq)
465 466
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
467
	struct netdev_queue *nq = netdev_get_tx_queue(mp->dev, txq->index);
468

469 470 471 472 473 474
	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 已提交
475 476
}

477

478
/* rx napi ******************************************************************/
479
static int rxq_process(struct rx_queue *rxq, int budget)
L
Linus Torvalds 已提交
480
{
481 482 483
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	struct net_device_stats *stats = &mp->dev->stats;
	int rx;
L
Linus Torvalds 已提交
484

485
	rx = 0;
486
	while (rx < budget && rxq->rx_desc_count) {
L
Lennert Buytenhek 已提交
487
		struct rx_desc *rx_desc;
488
		unsigned int cmd_sts;
L
Lennert Buytenhek 已提交
489
		struct sk_buff *skb;
490
		u16 byte_cnt;
491

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

494
		cmd_sts = rx_desc->cmd_sts;
495
		if (cmd_sts & BUFFER_OWNED_BY_DMA)
496 497
			break;
		rmb();
L
Linus Torvalds 已提交
498

499 500
		skb = rxq->rx_skb[rxq->rx_curr_desc];
		rxq->rx_skb[rxq->rx_curr_desc] = NULL;
501

502 503 504
		rxq->rx_curr_desc++;
		if (rxq->rx_curr_desc == rxq->rx_ring_size)
			rxq->rx_curr_desc = 0;
505

506
		dma_unmap_single(NULL, rx_desc->buf_ptr,
507
				 rx_desc->buf_size, DMA_FROM_DEVICE);
508 509
		rxq->rx_desc_count--;
		rx++;
510

511 512
		mp->work_rx_refill |= 1 << rxq->index;

513 514
		byte_cnt = rx_desc->byte_cnt;

515 516
		/*
		 * Update statistics.
L
Lennert Buytenhek 已提交
517 518 519 520 521
		 *
		 * 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).
522
		 */
L
Linus Torvalds 已提交
523
		stats->rx_packets++;
524
		stats->rx_bytes += byte_cnt - 2;
525

L
Linus Torvalds 已提交
526
		/*
L
Lennert Buytenhek 已提交
527 528 529
		 * 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 已提交
530
		 */
531
		if (((cmd_sts & (RX_FIRST_DESC | RX_LAST_DESC)) !=
532
					(RX_FIRST_DESC | RX_LAST_DESC))
533
				|| (cmd_sts & ERROR_SUMMARY)) {
L
Linus Torvalds 已提交
534
			stats->rx_dropped++;
L
Lennert Buytenhek 已提交
535

536
			if ((cmd_sts & (RX_FIRST_DESC | RX_LAST_DESC)) !=
537
				(RX_FIRST_DESC | RX_LAST_DESC)) {
L
Linus Torvalds 已提交
538
				if (net_ratelimit())
L
Lennert Buytenhek 已提交
539 540 541
					dev_printk(KERN_ERR, &mp->dev->dev,
						   "received packet spanning "
						   "multiple descriptors\n");
L
Linus Torvalds 已提交
542
			}
L
Lennert Buytenhek 已提交
543

544
			if (cmd_sts & ERROR_SUMMARY)
L
Linus Torvalds 已提交
545 546
				stats->rx_errors++;

547
			dev_kfree_skb(skb);
L
Linus Torvalds 已提交
548 549 550 551 552
		} else {
			/*
			 * The -4 is for the CRC in the trailer of the
			 * received packet
			 */
553
			skb_put(skb, byte_cnt - 2 - 4);
L
Linus Torvalds 已提交
554

555
			if (cmd_sts & LAYER_4_CHECKSUM_OK)
L
Linus Torvalds 已提交
556
				skb->ip_summed = CHECKSUM_UNNECESSARY;
557
			skb->protocol = eth_type_trans(skb, mp->dev);
L
Linus Torvalds 已提交
558 559 560
			netif_receive_skb(skb);
		}
	}
L
Lennert Buytenhek 已提交
561

562 563 564
	if (rx < budget)
		mp->work_rx &= ~(1 << rxq->index);

565
	return rx;
L
Linus Torvalds 已提交
566 567
}

568
static int rxq_refill(struct rx_queue *rxq, int budget)
569
{
570 571
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	int refilled;
572

573 574 575 576 577
	refilled = 0;
	while (refilled < budget && rxq->rx_desc_count < rxq->rx_ring_size) {
		struct sk_buff *skb;
		int unaligned;
		int rx;
578

579 580 581 582 583
		skb = __skb_dequeue(&mp->rx_recycle);
		if (skb == NULL)
			skb = dev_alloc_skb(mp->skb_size +
					    dma_get_cache_alignment() - 1);

584 585 586 587
		if (skb == NULL) {
			mp->work_rx_oom |= 1 << rxq->index;
			goto oom;
		}
588

589 590 591
		unaligned = (u32)skb->data & (dma_get_cache_alignment() - 1);
		if (unaligned)
			skb_reserve(skb, dma_get_cache_alignment() - unaligned);
592

593 594
		refilled++;
		rxq->rx_desc_count++;
595

596 597 598
		rx = rxq->rx_used_desc++;
		if (rxq->rx_used_desc == rxq->rx_ring_size)
			rxq->rx_used_desc = 0;
599

600
		rxq->rx_desc_area[rx].buf_ptr = dma_map_single(NULL, skb->data,
601 602
						mp->skb_size, DMA_FROM_DEVICE);
		rxq->rx_desc_area[rx].buf_size = mp->skb_size;
603 604 605 606 607
		rxq->rx_skb[rx] = skb;
		wmb();
		rxq->rx_desc_area[rx].cmd_sts = BUFFER_OWNED_BY_DMA |
						RX_ENABLE_INTERRUPT;
		wmb();
608

609 610 611 612 613 614 615 616 617 618 619 620 621
		/*
		 * 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;
622 623
}

624 625 626

/* tx ***********************************************************************/
static inline unsigned int has_tiny_unaligned_frags(struct sk_buff *skb)
L
Linus Torvalds 已提交
627
{
628
	int frag;
L
Linus Torvalds 已提交
629

630
	for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
631 632
		skb_frag_t *fragp = &skb_shinfo(skb)->frags[frag];
		if (fragp->size <= 8 && fragp->page_offset & 7)
633
			return 1;
L
Linus Torvalds 已提交
634
	}
635

636 637
	return 0;
}
638

639
static int txq_alloc_desc_index(struct tx_queue *txq)
640 641
{
	int tx_desc_curr;
642

643
	BUG_ON(txq->tx_desc_count >= txq->tx_ring_size);
L
Linus Torvalds 已提交
644

645 646 647
	tx_desc_curr = txq->tx_curr_desc++;
	if (txq->tx_curr_desc == txq->tx_ring_size)
		txq->tx_curr_desc = 0;
648

649
	BUG_ON(txq->tx_curr_desc == txq->tx_used_desc);
650

651 652
	return tx_desc_curr;
}
653

654
static void txq_submit_frag_skb(struct tx_queue *txq, struct sk_buff *skb)
655
{
656
	int nr_frags = skb_shinfo(skb)->nr_frags;
657
	int frag;
L
Linus Torvalds 已提交
658

659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679
	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];
		tx_index = txq_alloc_desc_index(txq);
		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;
		}

680 681 682 683 684 685 686
		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 已提交
687 688
}

689 690 691 692
static inline __be16 sum16_as_be(__sum16 sum)
{
	return (__force __be16)sum;
}
L
Linus Torvalds 已提交
693

694
static int txq_submit_skb(struct tx_queue *txq, struct sk_buff *skb)
L
Linus Torvalds 已提交
695
{
696
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
697
	int nr_frags = skb_shinfo(skb)->nr_frags;
698
	int tx_index;
699
	struct tx_desc *desc;
700
	u32 cmd_sts;
701
	u16 l4i_chk;
702
	int length;
L
Linus Torvalds 已提交
703

704
	cmd_sts = TX_FIRST_DESC | GEN_CRC | BUFFER_OWNED_BY_DMA;
705
	l4i_chk = 0;
706 707

	if (skb->ip_summed == CHECKSUM_PARTIAL) {
708
		int tag_bytes;
709 710 711

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

713 714 715 716 717 718 719
		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;
		}
720

721
		if (tag_bytes & 4)
722
			cmd_sts |= MAC_HDR_EXTRA_4_BYTES;
723
		if (tag_bytes & 8)
724
			cmd_sts |= MAC_HDR_EXTRA_8_BYTES;
725 726 727 728

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

730 731
		switch (ip_hdr(skb)->protocol) {
		case IPPROTO_UDP:
732
			cmd_sts |= UDP_FRAME;
733
			l4i_chk = ntohs(sum16_as_be(udp_hdr(skb)->check));
734 735
			break;
		case IPPROTO_TCP:
736
			l4i_chk = ntohs(sum16_as_be(tcp_hdr(skb)->check));
737 738 739 740 741
			break;
		default:
			BUG();
		}
	} else {
742
no_csum:
743
		/* Errata BTS #50, IHL must be 5 if no HW checksum */
744
		cmd_sts |= 5 << TX_IHL_SHIFT;
745 746
	}

747 748 749 750 751 752 753 754 755 756 757 758 759 760 761
	tx_index = txq_alloc_desc_index(txq);
	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);

762 763
	__skb_queue_tail(&txq->tx_skb, skb);

764 765 766 767
	/* ensure all other descriptors are written before first cmd_sts */
	wmb();
	desc->cmd_sts = cmd_sts;

768 769
	/* clear TX_END status */
	mp->work_tx_end &= ~(1 << txq->index);
770

771 772
	/* ensure all descriptors are written before poking hardware */
	wmb();
773
	txq_enable(txq);
774

775
	txq->tx_desc_count += nr_frags + 1;
776 777

	return 0;
L
Linus Torvalds 已提交
778 779
}

L
Lennert Buytenhek 已提交
780
static int mv643xx_eth_xmit(struct sk_buff *skb, struct net_device *dev)
L
Linus Torvalds 已提交
781
{
782
	struct mv643xx_eth_private *mp = netdev_priv(dev);
783
	int queue;
784
	struct tx_queue *txq;
785
	struct netdev_queue *nq;
786

787 788 789 790
	queue = skb_get_queue_mapping(skb);
	txq = mp->txq + queue;
	nq = netdev_get_tx_queue(dev, queue);

791
	if (has_tiny_unaligned_frags(skb) && __skb_linearize(skb)) {
792
		txq->tx_dropped++;
L
Lennert Buytenhek 已提交
793 794 795
		dev_printk(KERN_DEBUG, &dev->dev,
			   "failed to linearize skb with tiny "
			   "unaligned fragment\n");
796 797 798
		return NETDEV_TX_BUSY;
	}

799
	if (txq->tx_ring_size - txq->tx_desc_count < MAX_SKB_FRAGS + 1) {
800 801
		if (net_ratelimit())
			dev_printk(KERN_ERR, &dev->dev, "tx queue full?!\n");
802 803
		kfree_skb(skb);
		return NETDEV_TX_OK;
804 805
	}

806 807 808 809 810 811
	if (!txq_submit_skb(txq, skb)) {
		int entries_left;

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

813 814 815 816
		entries_left = txq->tx_ring_size - txq->tx_desc_count;
		if (entries_left < MAX_SKB_FRAGS + 1)
			netif_tx_stop_queue(nq);
	}
817 818

	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
819 820
}

821

822 823 824 825
/* tx napi ******************************************************************/
static void txq_kick(struct tx_queue *txq)
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
826
	struct netdev_queue *nq = netdev_get_tx_queue(mp->dev, txq->index);
827 828 829
	u32 hw_desc_ptr;
	u32 expected_ptr;

830
	__netif_tx_lock(nq, smp_processor_id());
831 832 833 834 835 836 837 838 839 840 841 842

	if (rdl(mp, TXQ_COMMAND(mp->port_num)) & (1 << txq->index))
		goto out;

	hw_desc_ptr = rdl(mp, TXQ_CURRENT_DESC_PTR(mp->port_num, txq->index));
	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:
843
	__netif_tx_unlock(nq);
844 845 846 847 848 849 850

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

854
	__netif_tx_lock(nq, smp_processor_id());
855 856 857 858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879

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

880 881 882
		skb = NULL;
		if (cmd_sts & TX_LAST_DESC)
			skb = __skb_dequeue(&txq->tx_skb);
883 884 885 886 887 888

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

889 890 891 892 893 894 895
		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);
		}
896

897 898 899 900 901 902 903 904
		if (skb != NULL) {
			if (skb_queue_len(&mp->rx_recycle) <
					mp->default_rx_ring_size &&
			    skb_recycle_check(skb, mp->skb_size))
				__skb_queue_head(&mp->rx_recycle, skb);
			else
				dev_kfree_skb(skb);
		}
905 906
	}

907 908
	__netif_tx_unlock(nq);

909 910 911 912 913 914 915
	if (reclaimed < budget)
		mp->work_tx &= ~(1 << txq->index);

	return reclaimed;
}


916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
/* 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;

939 940
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
941 942 943
		wrl(mp, TX_BW_RATE(mp->port_num), token_rate);
		wrl(mp, TX_BW_MTU(mp->port_num), mtu);
		wrl(mp, TX_BW_BURST(mp->port_num), bucket_size);
944 945 946 947 948 949
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
		wrl(mp, TX_BW_RATE_MOVED(mp->port_num), token_rate);
		wrl(mp, TX_BW_MTU_MOVED(mp->port_num), mtu);
		wrl(mp, TX_BW_BURST_MOVED(mp->port_num), bucket_size);
		break;
950
	}
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966
}

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;

967 968
	wrl(mp, TXQ_BW_TOKENS(mp->port_num, txq->index), token_rate << 14);
	wrl(mp, TXQ_BW_CONF(mp->port_num, txq->index),
969 970 971 972 973 974 975 976 977 978 979 980
			(bucket_size << 10) | token_rate);
}

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.
	 */
981 982 983
	off = 0;
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
984
		off = TXQ_FIX_PRIO_CONF(mp->port_num);
985 986 987 988 989
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
		off = TXQ_FIX_PRIO_CONF_MOVED(mp->port_num);
		break;
	}
990

991 992 993 994 995
	if (off) {
		val = rdl(mp, off);
		val |= 1 << txq->index;
		wrl(mp, off, val);
	}
996 997 998 999 1000 1001 1002 1003 1004 1005 1006
}

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.
	 */
1007 1008 1009
	off = 0;
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
1010
		off = TXQ_FIX_PRIO_CONF(mp->port_num);
1011 1012 1013 1014 1015
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
		off = TXQ_FIX_PRIO_CONF_MOVED(mp->port_num);
		break;
	}
1016

1017 1018 1019 1020
	if (off) {
		val = rdl(mp, off);
		val &= ~(1 << txq->index);
		wrl(mp, off, val);
1021

1022 1023 1024 1025
		/*
		 * Configure WRR weight for this queue.
		 */
		off = TXQ_BW_WRR_CONF(mp->port_num, txq->index);
1026

1027 1028 1029 1030
		val = rdl(mp, off);
		val = (val & ~0xff) | (weight & 0xff);
		wrl(mp, off, val);
	}
1031 1032 1033
}


1034
/* mii management interface *************************************************/
1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046
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;
}
1047

1048
static int smi_is_done(struct mv643xx_eth_shared_private *msp)
L
Linus Torvalds 已提交
1049
{
1050 1051
	return !(readl(msp->base + SMI_REG) & SMI_BUSY);
}
L
Linus Torvalds 已提交
1052

1053 1054 1055 1056
static int smi_wait_ready(struct mv643xx_eth_shared_private *msp)
{
	if (msp->err_interrupt == NO_IRQ) {
		int i;
1057

1058 1059 1060 1061
		for (i = 0; !smi_is_done(msp); i++) {
			if (i == 10)
				return -ETIMEDOUT;
			msleep(10);
1062
		}
1063 1064 1065 1066

		return 0;
	}

1067 1068 1069 1070 1071 1072
	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;
	}
1073 1074 1075 1076

	return 0;
}

1077
static int smi_bus_read(struct mii_bus *bus, int addr, int reg)
1078
{
1079
	struct mv643xx_eth_shared_private *msp = bus->priv;
1080 1081 1082 1083
	void __iomem *smi_reg = msp->base + SMI_REG;
	int ret;

	if (smi_wait_ready(msp)) {
1084 1085
		printk("mv643xx_eth: SMI bus busy timeout\n");
		return -ETIMEDOUT;
L
Linus Torvalds 已提交
1086 1087
	}

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

1090
	if (smi_wait_ready(msp)) {
1091 1092
		printk("mv643xx_eth: SMI bus busy timeout\n");
		return -ETIMEDOUT;
1093 1094 1095 1096
	}

	ret = readl(smi_reg);
	if (!(ret & SMI_READ_VALID)) {
1097 1098
		printk("mv643xx_eth: SMI bus read not valid\n");
		return -ENODEV;
1099 1100
	}

1101
	return ret & 0xffff;
L
Linus Torvalds 已提交
1102 1103
}

1104
static int smi_bus_write(struct mii_bus *bus, int addr, int reg, u16 val)
L
Linus Torvalds 已提交
1105
{
1106
	struct mv643xx_eth_shared_private *msp = bus->priv;
1107
	void __iomem *smi_reg = msp->base + SMI_REG;
L
Linus Torvalds 已提交
1108

1109
	if (smi_wait_ready(msp)) {
1110
		printk("mv643xx_eth: SMI bus busy timeout\n");
1111
		return -ETIMEDOUT;
L
Linus Torvalds 已提交
1112 1113
	}

L
Lennert Buytenhek 已提交
1114
	writel(SMI_OPCODE_WRITE | (reg << 21) |
1115
		(addr << 16) | (val & 0xffff), smi_reg);
1116

1117 1118 1119 1120
	if (smi_wait_ready(msp)) {
		printk("mv643xx_eth: SMI bus busy timeout\n");
		return -ETIMEDOUT;
	}
1121 1122

	return 0;
1123
}
L
Linus Torvalds 已提交
1124

1125

1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
/* 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 已提交
1151
static inline u32 mib_read(struct mv643xx_eth_private *mp, int offset)
1152
{
L
Lennert Buytenhek 已提交
1153
	return rdl(mp, MIB_COUNTERS(mp->port_num) + offset);
L
Linus Torvalds 已提交
1154 1155
}

L
Lennert Buytenhek 已提交
1156
static void mib_counters_clear(struct mv643xx_eth_private *mp)
1157
{
L
Lennert Buytenhek 已提交
1158 1159 1160 1161
	int i;

	for (i = 0; i < 0x80; i += 4)
		mib_read(mp, i);
1162
}
1163

L
Lennert Buytenhek 已提交
1164
static void mib_counters_update(struct mv643xx_eth_private *mp)
1165
{
1166
	struct mib_counters *p = &mp->mib_counters;
1167

1168
	spin_lock(&mp->mib_counters_lock);
L
Lennert Buytenhek 已提交
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200
	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);
1201 1202 1203 1204 1205 1206 1207 1208 1209 1210
	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);
1211 1212
}

1213 1214

/* ethtool ******************************************************************/
1215
struct mv643xx_eth_stats {
1216 1217
	char stat_string[ETH_GSTRING_LEN];
	int sizeof_stat;
1218 1219
	int netdev_off;
	int mp_off;
1220 1221
};

1222 1223 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
#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),
1269 1270
};

1271
static int mv643xx_eth_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1272
{
1273
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1274 1275
	int err;

1276 1277 1278
	err = phy_read_status(mp->phy);
	if (err == 0)
		err = phy_ethtool_gset(mp->phy, cmd);
1279

L
Lennert Buytenhek 已提交
1280 1281 1282
	/*
	 * The MAC does not support 1000baseT_Half.
	 */
1283 1284 1285 1286 1287 1288
	cmd->supported &= ~SUPPORTED_1000baseT_Half;
	cmd->advertising &= ~ADVERTISED_1000baseT_Half;

	return err;
}

1289 1290
static int mv643xx_eth_get_settings_phyless(struct net_device *dev, struct ethtool_cmd *cmd)
{
1291 1292 1293 1294 1295
	struct mv643xx_eth_private *mp = netdev_priv(dev);
	u32 port_status;

	port_status = rdl(mp, PORT_STATUS(mp->port_num));

1296 1297
	cmd->supported = SUPPORTED_MII;
	cmd->advertising = ADVERTISED_MII;
1298 1299 1300 1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312
	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;
1313 1314 1315 1316 1317 1318 1319 1320 1321 1322
	cmd->port = PORT_MII;
	cmd->phy_address = 0;
	cmd->transceiver = XCVR_INTERNAL;
	cmd->autoneg = AUTONEG_DISABLE;
	cmd->maxtxpkt = 1;
	cmd->maxrxpkt = 1;

	return 0;
}

1323
static int mv643xx_eth_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
L
Linus Torvalds 已提交
1324
{
1325
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1326

L
Lennert Buytenhek 已提交
1327 1328 1329 1330 1331
	/*
	 * The MAC does not support 1000baseT_Half.
	 */
	cmd->advertising &= ~ADVERTISED_1000baseT_Half;

1332
	return phy_ethtool_sset(mp->phy, cmd);
1333
}
L
Linus Torvalds 已提交
1334

1335 1336 1337 1338 1339
static int mv643xx_eth_set_settings_phyless(struct net_device *dev, struct ethtool_cmd *cmd)
{
	return -EINVAL;
}

L
Lennert Buytenhek 已提交
1340 1341
static void mv643xx_eth_get_drvinfo(struct net_device *dev,
				    struct ethtool_drvinfo *drvinfo)
1342
{
1343 1344
	strncpy(drvinfo->driver,  mv643xx_eth_driver_name, 32);
	strncpy(drvinfo->version, mv643xx_eth_driver_version, 32);
1345
	strncpy(drvinfo->fw_version, "N/A", 32);
L
Lennert Buytenhek 已提交
1346
	strncpy(drvinfo->bus_info, "platform", 32);
1347
	drvinfo->n_stats = ARRAY_SIZE(mv643xx_eth_stats);
1348
}
L
Linus Torvalds 已提交
1349

L
Lennert Buytenhek 已提交
1350
static int mv643xx_eth_nway_reset(struct net_device *dev)
1351
{
1352
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
1353

1354
	return genphy_restart_aneg(mp->phy);
1355
}
L
Linus Torvalds 已提交
1356

1357 1358 1359 1360 1361
static int mv643xx_eth_nway_reset_phyless(struct net_device *dev)
{
	return -EINVAL;
}

1362 1363
static u32 mv643xx_eth_get_link(struct net_device *dev)
{
1364
	return !!netif_carrier_ok(dev);
1365 1366
}

L
Lennert Buytenhek 已提交
1367 1368
static void mv643xx_eth_get_strings(struct net_device *dev,
				    uint32_t stringset, uint8_t *data)
1369 1370
{
	int i;
L
Linus Torvalds 已提交
1371

L
Lennert Buytenhek 已提交
1372 1373
	if (stringset == ETH_SS_STATS) {
		for (i = 0; i < ARRAY_SIZE(mv643xx_eth_stats); i++) {
1374
			memcpy(data + i * ETH_GSTRING_LEN,
1375
				mv643xx_eth_stats[i].stat_string,
1376
				ETH_GSTRING_LEN);
1377 1378 1379
		}
	}
}
L
Linus Torvalds 已提交
1380

L
Lennert Buytenhek 已提交
1381 1382 1383
static void mv643xx_eth_get_ethtool_stats(struct net_device *dev,
					  struct ethtool_stats *stats,
					  uint64_t *data)
1384
{
1385
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1386
	int i;
L
Linus Torvalds 已提交
1387

1388
	mv643xx_eth_get_stats(dev);
L
Lennert Buytenhek 已提交
1389
	mib_counters_update(mp);
L
Linus Torvalds 已提交
1390

1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403
	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 已提交
1404
	}
1405
}
L
Linus Torvalds 已提交
1406

L
Lennert Buytenhek 已提交
1407
static int mv643xx_eth_get_sset_count(struct net_device *dev, int sset)
1408
{
L
Lennert Buytenhek 已提交
1409
	if (sset == ETH_SS_STATS)
1410
		return ARRAY_SIZE(mv643xx_eth_stats);
L
Lennert Buytenhek 已提交
1411 1412

	return -EOPNOTSUPP;
1413
}
L
Linus Torvalds 已提交
1414

1415
static const struct ethtool_ops mv643xx_eth_ethtool_ops = {
L
Lennert Buytenhek 已提交
1416 1417 1418 1419 1420
	.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,
1421
	.set_sg			= ethtool_op_set_sg,
L
Lennert Buytenhek 已提交
1422 1423
	.get_strings		= mv643xx_eth_get_strings,
	.get_ethtool_stats	= mv643xx_eth_get_ethtool_stats,
1424
	.get_sset_count		= mv643xx_eth_get_sset_count,
1425
};
L
Linus Torvalds 已提交
1426

1427 1428 1429 1430 1431
static const struct ethtool_ops mv643xx_eth_ethtool_ops_phyless = {
	.get_settings		= mv643xx_eth_get_settings_phyless,
	.set_settings		= mv643xx_eth_set_settings_phyless,
	.get_drvinfo		= mv643xx_eth_get_drvinfo,
	.nway_reset		= mv643xx_eth_nway_reset_phyless,
1432
	.get_link		= mv643xx_eth_get_link,
1433 1434 1435 1436 1437 1438
	.set_sg			= ethtool_op_set_sg,
	.get_strings		= mv643xx_eth_get_strings,
	.get_ethtool_stats	= mv643xx_eth_get_ethtool_stats,
	.get_sset_count		= mv643xx_eth_get_sset_count,
};

1439

1440
/* address handling *********************************************************/
1441
static void uc_addr_get(struct mv643xx_eth_private *mp, unsigned char *addr)
1442 1443 1444
{
	unsigned int mac_h;
	unsigned int mac_l;
L
Linus Torvalds 已提交
1445

L
Lennert Buytenhek 已提交
1446 1447
	mac_h = rdl(mp, MAC_ADDR_HIGH(mp->port_num));
	mac_l = rdl(mp, MAC_ADDR_LOW(mp->port_num));
L
Linus Torvalds 已提交
1448

1449 1450 1451 1452 1453 1454
	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;
1455
}
L
Linus Torvalds 已提交
1456

1457
static void init_mac_tables(struct mv643xx_eth_private *mp)
1458
{
L
Lennert Buytenhek 已提交
1459
	int i;
L
Linus Torvalds 已提交
1460

L
Lennert Buytenhek 已提交
1461 1462 1463
	for (i = 0; i < 0x100; i += 4) {
		wrl(mp, SPECIAL_MCAST_TABLE(mp->port_num) + i, 0);
		wrl(mp, OTHER_MCAST_TABLE(mp->port_num) + i, 0);
1464
	}
L
Lennert Buytenhek 已提交
1465 1466 1467

	for (i = 0; i < 0x10; i += 4)
		wrl(mp, UNICAST_TABLE(mp->port_num) + i, 0);
1468
}
1469

1470
static void set_filter_table_entry(struct mv643xx_eth_private *mp,
L
Lennert Buytenhek 已提交
1471
				   int table, unsigned char entry)
1472 1473
{
	unsigned int table_reg;
1474

1475
	/* Set "accepts frame bit" at specified table entry */
L
Lennert Buytenhek 已提交
1476 1477 1478
	table_reg = rdl(mp, table + (entry & 0xfc));
	table_reg |= 0x01 << (8 * (entry & 3));
	wrl(mp, table + (entry & 0xfc), table_reg);
L
Linus Torvalds 已提交
1479 1480
}

1481
static void uc_addr_set(struct mv643xx_eth_private *mp, unsigned char *addr)
L
Linus Torvalds 已提交
1482
{
1483 1484 1485
	unsigned int mac_h;
	unsigned int mac_l;
	int table;
L
Linus Torvalds 已提交
1486

L
Lennert Buytenhek 已提交
1487 1488
	mac_l = (addr[4] << 8) | addr[5];
	mac_h = (addr[0] << 24) | (addr[1] << 16) | (addr[2] << 8) | addr[3];
1489

L
Lennert Buytenhek 已提交
1490 1491
	wrl(mp, MAC_ADDR_LOW(mp->port_num), mac_l);
	wrl(mp, MAC_ADDR_HIGH(mp->port_num), mac_h);
L
Linus Torvalds 已提交
1492

L
Lennert Buytenhek 已提交
1493
	table = UNICAST_TABLE(mp->port_num);
1494
	set_filter_table_entry(mp, table, addr[5] & 0x0f);
L
Linus Torvalds 已提交
1495 1496
}

L
Lennert Buytenhek 已提交
1497
static int mv643xx_eth_set_mac_address(struct net_device *dev, void *addr)
L
Linus Torvalds 已提交
1498
{
1499
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
1500

L
Lennert Buytenhek 已提交
1501 1502 1503
	/* +2 is for the offset of the HW addr type */
	memcpy(dev->dev_addr, addr + 2, 6);

1504 1505
	init_mac_tables(mp);
	uc_addr_set(mp, dev->dev_addr);
L
Linus Torvalds 已提交
1506 1507 1508 1509

	return 0;
}

1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527
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;
}

L
Lennert Buytenhek 已提交
1528
static void mv643xx_eth_set_rx_mode(struct net_device *dev)
L
Linus Torvalds 已提交
1529
{
L
Lennert Buytenhek 已提交
1530 1531 1532 1533
	struct mv643xx_eth_private *mp = netdev_priv(dev);
	u32 port_config;
	struct dev_addr_list *addr;
	int i;
1534

L
Lennert Buytenhek 已提交
1535 1536 1537 1538 1539 1540
	port_config = rdl(mp, PORT_CONFIG(mp->port_num));
	if (dev->flags & IFF_PROMISC)
		port_config |= UNICAST_PROMISCUOUS_MODE;
	else
		port_config &= ~UNICAST_PROMISCUOUS_MODE;
	wrl(mp, PORT_CONFIG(mp->port_num), port_config);
L
Linus Torvalds 已提交
1541

L
Lennert Buytenhek 已提交
1542 1543 1544
	if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
		int port_num = mp->port_num;
		u32 accept = 0x01010101;
1545

L
Lennert Buytenhek 已提交
1546 1547 1548
		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);
1549 1550 1551
		}
		return;
	}
1552

L
Lennert Buytenhek 已提交
1553 1554 1555
	for (i = 0; i < 0x100; i += 4) {
		wrl(mp, SPECIAL_MCAST_TABLE(mp->port_num) + i, 0);
		wrl(mp, OTHER_MCAST_TABLE(mp->port_num) + i, 0);
L
Linus Torvalds 已提交
1556 1557
	}

L
Lennert Buytenhek 已提交
1558 1559 1560
	for (addr = dev->mc_list; addr != NULL; addr = addr->next) {
		u8 *a = addr->da_addr;
		int table;
1561

L
Lennert Buytenhek 已提交
1562 1563
		if (addr->da_addrlen != 6)
			continue;
L
Linus Torvalds 已提交
1564

L
Lennert Buytenhek 已提交
1565 1566 1567 1568 1569
		if (memcmp(a, "\x01\x00\x5e\x00\x00", 5) == 0) {
			table = SPECIAL_MCAST_TABLE(mp->port_num);
			set_filter_table_entry(mp, table, a[5]);
		} else {
			int crc = addr_crc(a);
L
Linus Torvalds 已提交
1570

L
Lennert Buytenhek 已提交
1571 1572 1573 1574
			table = OTHER_MCAST_TABLE(mp->port_num);
			set_filter_table_entry(mp, table, crc);
		}
	}
1575
}
1576 1577


1578
/* rx/tx queue initialisation ***********************************************/
1579
static int rxq_init(struct mv643xx_eth_private *mp, int index)
1580
{
1581
	struct rx_queue *rxq = mp->rxq + index;
1582 1583
	struct rx_desc *rx_desc;
	int size;
1584 1585
	int i;

1586 1587
	rxq->index = index;

1588 1589 1590 1591 1592 1593 1594 1595
	rxq->rx_ring_size = mp->default_rx_ring_size;

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

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

1596
	if (index == 0 && size <= mp->rx_desc_sram_size) {
1597 1598 1599 1600 1601 1602 1603
		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);
1604 1605
	}

1606 1607 1608 1609 1610 1611
	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 已提交
1612

1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623
	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++) {
1624 1625 1626 1627 1628 1629
		int nexti;

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

1630 1631 1632 1633 1634 1635 1636 1637
		rx_desc[i].next_desc_ptr = rxq->rx_desc_dma +
					nexti * sizeof(struct rx_desc);
	}

	return 0;


out_free:
1638
	if (index == 0 && size <= mp->rx_desc_sram_size)
1639 1640 1641 1642 1643 1644 1645 1646
		iounmap(rxq->rx_desc_area);
	else
		dma_free_coherent(NULL, size,
				  rxq->rx_desc_area,
				  rxq->rx_desc_dma);

out:
	return -ENOMEM;
1647
}
1648

1649
static void rxq_deinit(struct rx_queue *rxq)
1650
{
1651 1652 1653 1654
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	int i;

	rxq_disable(rxq);
1655

1656 1657 1658 1659
	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 已提交
1660
		}
1661
	}
L
Linus Torvalds 已提交
1662

1663 1664 1665 1666 1667 1668
	if (rxq->rx_desc_count) {
		dev_printk(KERN_ERR, &mp->dev->dev,
			   "error freeing rx ring -- %d skbs stuck\n",
			   rxq->rx_desc_count);
	}

1669
	if (rxq->index == 0 &&
1670
	    rxq->rx_desc_area_size <= mp->rx_desc_sram_size)
1671
		iounmap(rxq->rx_desc_area);
1672
	else
1673 1674 1675 1676
		dma_free_coherent(NULL, rxq->rx_desc_area_size,
				  rxq->rx_desc_area, rxq->rx_desc_dma);

	kfree(rxq->rx_skb);
1677
}
L
Linus Torvalds 已提交
1678

1679
static int txq_init(struct mv643xx_eth_private *mp, int index)
1680
{
1681
	struct tx_queue *txq = mp->txq + index;
1682 1683
	struct tx_desc *tx_desc;
	int size;
1684
	int i;
L
Linus Torvalds 已提交
1685

1686 1687
	txq->index = index;

1688 1689 1690 1691 1692 1693 1694 1695
	txq->tx_ring_size = mp->default_tx_ring_size;

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

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

1696
	if (index == 0 && size <= mp->tx_desc_sram_size) {
1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708
		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);
1709
		return -ENOMEM;
1710
	}
1711 1712 1713 1714 1715 1716
	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++) {
1717
		struct tx_desc *txd = tx_desc + i;
1718 1719 1720 1721 1722
		int nexti;

		nexti = i + 1;
		if (nexti == txq->tx_ring_size)
			nexti = 0;
1723 1724 1725

		txd->cmd_sts = 0;
		txd->next_desc_ptr = txq->tx_desc_dma +
1726 1727 1728
					nexti * sizeof(struct tx_desc);
	}

1729
	skb_queue_head_init(&txq->tx_skb);
1730

1731
	return 0;
1732
}
L
Linus Torvalds 已提交
1733

1734
static void txq_deinit(struct tx_queue *txq)
1735
{
1736
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
1737

1738
	txq_disable(txq);
1739
	txq_reclaim(txq, txq->tx_ring_size, 1);
L
Linus Torvalds 已提交
1740

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

1743
	if (txq->index == 0 &&
1744
	    txq->tx_desc_area_size <= mp->tx_desc_sram_size)
1745
		iounmap(txq->tx_desc_area);
1746
	else
1747 1748
		dma_free_coherent(NULL, txq->tx_desc_area_size,
				  txq->tx_desc_area, txq->tx_desc_dma);
1749
}
L
Linus Torvalds 已提交
1750 1751


1752
/* netdev ops and related ***************************************************/
1753 1754 1755 1756 1757 1758 1759 1760 1761 1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772 1773 1774 1775 1776 1777 1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
static int mv643xx_eth_collect_events(struct mv643xx_eth_private *mp)
{
	u32 int_cause;
	u32 int_cause_ext;

	int_cause = rdl(mp, INT_CAUSE(mp->port_num)) &
			(INT_TX_END | INT_RX | INT_EXT);
	if (int_cause == 0)
		return 0;

	int_cause_ext = 0;
	if (int_cause & INT_EXT)
		int_cause_ext = rdl(mp, INT_CAUSE_EXT(mp->port_num));

	int_cause &= INT_TX_END | INT_RX;
	if (int_cause) {
		wrl(mp, INT_CAUSE(mp->port_num), ~int_cause);
		mp->work_tx_end |= ((int_cause & INT_TX_END) >> 19) &
				~(rdl(mp, TXQ_COMMAND(mp->port_num)) & 0xff);
		mp->work_rx |= (int_cause & INT_RX) >> 2;
	}

	int_cause_ext &= INT_EXT_LINK_PHY | INT_EXT_TX;
	if (int_cause_ext) {
		wrl(mp, INT_CAUSE_EXT(mp->port_num), ~int_cause_ext);
		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;

	wrl(mp, INT_MASK(mp->port_num), 0);
	napi_schedule(&mp->napi);

	return IRQ_HANDLED;
}

1800 1801 1802 1803 1804 1805 1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816
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;

	port_status = rdl(mp, PORT_STATUS(mp->port_num));
	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);

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

1820
				txq_reclaim(txq, txq->tx_ring_size, 1);
1821
				txq_reset_hw_ptr(txq);
1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845 1846 1847 1848
			}
		}
		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");

1849
	if (!netif_carrier_ok(dev))
1850 1851 1852
		netif_carrier_on(dev);
}

1853
static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
1854
{
1855 1856
	struct mv643xx_eth_private *mp;
	int work_done;
1857

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

1860 1861
	mp->work_rx_refill |= mp->work_rx_oom;
	mp->work_rx_oom = 0;
L
Linus Torvalds 已提交
1862

1863 1864 1865 1866 1867 1868 1869 1870 1871 1872 1873
	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 已提交
1874

1875 1876 1877 1878 1879 1880 1881
		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 已提交
1882

1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897 1898 1899 1900 1901
		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();
		}
1902
	}
L
Lennert Buytenhek 已提交
1903

1904 1905 1906 1907 1908
	if (work_done < budget) {
		if (mp->work_rx_oom)
			mod_timer(&mp->rx_oom, jiffies + (HZ / 10));
		napi_complete(napi);
		wrl(mp, INT_MASK(mp->port_num), INT_TX_END | INT_RX | INT_EXT);
1909
	}
1910

1911 1912
	return work_done;
}
1913

1914 1915 1916
static inline void oom_timer_wrapper(unsigned long data)
{
	struct mv643xx_eth_private *mp = (void *)data;
L
Linus Torvalds 已提交
1917

1918
	napi_schedule(&mp->napi);
L
Linus Torvalds 已提交
1919 1920
}

1921
static void phy_reset(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
1922
{
1923 1924
	int data;

1925
	data = phy_read(mp->phy, MII_BMCR);
1926 1927
	if (data < 0)
		return;
L
Linus Torvalds 已提交
1928

1929
	data |= BMCR_RESET;
1930
	if (phy_write(mp->phy, MII_BMCR, data) < 0)
1931
		return;
L
Linus Torvalds 已提交
1932

1933
	do {
1934
		data = phy_read(mp->phy, MII_BMCR);
1935
	} while (data >= 0 && data & BMCR_RESET);
L
Linus Torvalds 已提交
1936 1937
}

L
Lennert Buytenhek 已提交
1938
static void port_start(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
1939
{
1940
	u32 pscr;
1941
	int i;
L
Linus Torvalds 已提交
1942

1943 1944 1945
	/*
	 * Perform PHY reset, if there is a PHY.
	 */
1946
	if (mp->phy != NULL) {
1947 1948 1949 1950 1951 1952
		struct ethtool_cmd cmd;

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

1954 1955 1956 1957 1958 1959 1960 1961 1962
	/*
	 * Configure basic link parameters.
	 */
	pscr = rdl(mp, PORT_SERIAL_CONTROL(mp->port_num));

	pscr |= SERIAL_PORT_ENABLE;
	wrl(mp, PORT_SERIAL_CONTROL(mp->port_num), pscr);

	pscr |= DO_NOT_FORCE_LINK_FAIL;
1963
	if (mp->phy == NULL)
1964 1965 1966 1967 1968
		pscr |= FORCE_LINK_PASS;
	wrl(mp, PORT_SERIAL_CONTROL(mp->port_num), pscr);

	wrl(mp, SDMA_CONFIG(mp->port_num), PORT_SDMA_CONFIG_DEFAULT_VALUE);

1969 1970 1971
	/*
	 * Configure TX path and queues.
	 */
1972
	tx_set_rate(mp, 1000000000, 16777216);
1973
	for (i = 0; i < mp->txq_count; i++) {
1974
		struct tx_queue *txq = mp->txq + i;
1975

1976
		txq_reset_hw_ptr(txq);
1977 1978
		txq_set_rate(txq, 1000000000, 16777216);
		txq_set_fixed_prio_mode(txq);
1979 1980
	}

L
Lennert Buytenhek 已提交
1981 1982 1983 1984
	/*
	 * Add configured unicast address to address filter table.
	 */
	uc_addr_set(mp, mp->dev->dev_addr);
L
Linus Torvalds 已提交
1985

1986 1987
	/*
	 * Receive all unmatched unicast, TCP, UDP, BPDU and broadcast
1988 1989
	 * frames to RX queue #0, and include the pseudo-header when
	 * calculating receive checksums.
1990
	 */
1991
	wrl(mp, PORT_CONFIG(mp->port_num), 0x02000000);
1992

1993 1994 1995
	/*
	 * Treat BPDUs as normal multicasts, and disable partition mode.
	 */
1996
	wrl(mp, PORT_CONFIG_EXT(mp->port_num), 0x00000000);
1997

1998
	/*
1999
	 * Enable the receive queues.
2000
	 */
2001
	for (i = 0; i < mp->rxq_count; i++) {
2002 2003
		struct rx_queue *rxq = mp->rxq + i;
		int off = RXQ_CURRENT_DESC_PTR(mp->port_num, i);
2004
		u32 addr;
L
Linus Torvalds 已提交
2005

2006 2007 2008
		addr = (u32)rxq->rx_desc_dma;
		addr += rxq->rx_curr_desc * sizeof(struct rx_desc);
		wrl(mp, off, addr);
L
Linus Torvalds 已提交
2009

2010 2011
		rxq_enable(rxq);
	}
L
Linus Torvalds 已提交
2012 2013
}

2014
static void set_rx_coal(struct mv643xx_eth_private *mp, unsigned int delay)
L
Linus Torvalds 已提交
2015
{
2016
	unsigned int coal = ((mp->shared->t_clk / 1000000) * delay) / 64;
2017
	u32 val;
L
Linus Torvalds 已提交
2018

2019 2020 2021 2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
	val = rdl(mp, SDMA_CONFIG(mp->port_num));
	if (mp->shared->extended_rx_coal_limit) {
		if (coal > 0xffff)
			coal = 0xffff;
		val &= ~0x023fff80;
		val |= (coal & 0x8000) << 10;
		val |= (coal & 0x7fff) << 7;
	} else {
		if (coal > 0x3fff)
			coal = 0x3fff;
		val &= ~0x003fff00;
		val |= (coal & 0x3fff) << 8;
	}
	wrl(mp, SDMA_CONFIG(mp->port_num), val);
L
Linus Torvalds 已提交
2033 2034
}

2035
static void set_tx_coal(struct mv643xx_eth_private *mp, unsigned int delay)
L
Linus Torvalds 已提交
2036
{
2037
	unsigned int coal = ((mp->shared->t_clk / 1000000) * delay) / 64;
L
Linus Torvalds 已提交
2038

L
Lennert Buytenhek 已提交
2039 2040 2041
	if (coal > 0x3fff)
		coal = 0x3fff;
	wrl(mp, TX_FIFO_URGENT_THRESHOLD(mp->port_num), (coal & 0x3fff) << 4);
2042 2043
}

2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063
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;
}

2064
static int mv643xx_eth_open(struct net_device *dev)
2065
{
2066
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2067
	int err;
2068
	int i;
2069

L
Lennert Buytenhek 已提交
2070 2071 2072
	wrl(mp, INT_CAUSE(mp->port_num), 0);
	wrl(mp, INT_CAUSE_EXT(mp->port_num), 0);
	rdl(mp, INT_CAUSE_EXT(mp->port_num));
2073

L
Lennert Buytenhek 已提交
2074
	err = request_irq(dev->irq, mv643xx_eth_irq,
2075
			  IRQF_SHARED, dev->name, dev);
2076
	if (err) {
L
Lennert Buytenhek 已提交
2077
		dev_printk(KERN_ERR, &dev->dev, "can't assign irq\n");
2078
		return -EAGAIN;
2079 2080
	}

L
Lennert Buytenhek 已提交
2081
	init_mac_tables(mp);
2082

2083 2084
	mv643xx_eth_recalc_skb_size(mp);

2085 2086
	napi_enable(&mp->napi);

2087 2088
	skb_queue_head_init(&mp->rx_recycle);

2089
	for (i = 0; i < mp->rxq_count; i++) {
2090 2091 2092
		err = rxq_init(mp, i);
		if (err) {
			while (--i >= 0)
2093
				rxq_deinit(mp->rxq + i);
2094 2095 2096
			goto out;
		}

2097
		rxq_refill(mp->rxq + i, INT_MAX);
2098 2099
	}

2100
	if (mp->work_rx_oom) {
2101 2102
		mp->rx_oom.expires = jiffies + (HZ / 10);
		add_timer(&mp->rx_oom);
2103
	}
2104

2105
	for (i = 0; i < mp->txq_count; i++) {
2106 2107 2108
		err = txq_init(mp, i);
		if (err) {
			while (--i >= 0)
2109
				txq_deinit(mp->txq + i);
2110 2111 2112
			goto out_free;
		}
	}
2113

2114 2115
	netif_carrier_off(dev);

L
Lennert Buytenhek 已提交
2116
	port_start(mp);
2117

2118 2119
	set_rx_coal(mp, 0);
	set_tx_coal(mp, 0);
2120

2121
	wrl(mp, INT_MASK_EXT(mp->port_num), INT_EXT_LINK_PHY | INT_EXT_TX);
2122
	wrl(mp, INT_MASK(mp->port_num), INT_TX_END | INT_RX | INT_EXT);
2123

2124 2125
	return 0;

2126

L
Lennert Buytenhek 已提交
2127
out_free:
2128 2129
	for (i = 0; i < mp->rxq_count; i++)
		rxq_deinit(mp->rxq + i);
L
Lennert Buytenhek 已提交
2130
out:
2131 2132 2133
	free_irq(dev->irq, dev);

	return err;
2134 2135
}

2136
static void port_reset(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2137
{
L
Lennert Buytenhek 已提交
2138
	unsigned int data;
2139
	int i;
L
Linus Torvalds 已提交
2140

2141 2142 2143 2144
	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);
2145 2146 2147 2148 2149 2150

	while (1) {
		u32 ps = rdl(mp, PORT_STATUS(mp->port_num));

		if ((ps & (TX_IN_PROGRESS | TX_FIFO_EMPTY)) == TX_FIFO_EMPTY)
			break;
2151
		udelay(10);
2152
	}
L
Linus Torvalds 已提交
2153

2154
	/* Reset the Enable bit in the Configuration Register */
L
Lennert Buytenhek 已提交
2155 2156 2157 2158 2159
	data = rdl(mp, PORT_SERIAL_CONTROL(mp->port_num));
	data &= ~(SERIAL_PORT_ENABLE		|
		  DO_NOT_FORCE_LINK_FAIL	|
		  FORCE_LINK_PASS);
	wrl(mp, PORT_SERIAL_CONTROL(mp->port_num), data);
L
Linus Torvalds 已提交
2160 2161
}

2162
static int mv643xx_eth_stop(struct net_device *dev)
L
Linus Torvalds 已提交
2163
{
2164
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2165
	int i;
L
Linus Torvalds 已提交
2166

L
Lennert Buytenhek 已提交
2167 2168
	wrl(mp, INT_MASK(mp->port_num), 0x00000000);
	rdl(mp, INT_MASK(mp->port_num));
L
Linus Torvalds 已提交
2169

2170 2171
	del_timer_sync(&mp->mib_counters_timer);

2172
	napi_disable(&mp->napi);
2173

2174 2175
	del_timer_sync(&mp->rx_oom);

2176
	netif_carrier_off(dev);
L
Linus Torvalds 已提交
2177

L
Lennert Buytenhek 已提交
2178 2179
	free_irq(dev->irq, dev);

2180
	port_reset(mp);
2181
	mv643xx_eth_get_stats(dev);
L
Lennert Buytenhek 已提交
2182
	mib_counters_update(mp);
L
Linus Torvalds 已提交
2183

2184 2185
	skb_queue_purge(&mp->rx_recycle);

2186 2187 2188 2189
	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 已提交
2190

2191
	return 0;
L
Linus Torvalds 已提交
2192 2193
}

L
Lennert Buytenhek 已提交
2194
static int mv643xx_eth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
L
Linus Torvalds 已提交
2195
{
2196
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
2197

2198 2199
	if (mp->phy != NULL)
		return phy_mii_ioctl(mp->phy, if_mii(ifr), cmd);
2200 2201

	return -EOPNOTSUPP;
L
Linus Torvalds 已提交
2202 2203
}

2204
static int mv643xx_eth_change_mtu(struct net_device *dev, int new_mtu)
L
Linus Torvalds 已提交
2205
{
2206 2207
	struct mv643xx_eth_private *mp = netdev_priv(dev);

L
Lennert Buytenhek 已提交
2208
	if (new_mtu < 64 || new_mtu > 9500)
2209
		return -EINVAL;
L
Linus Torvalds 已提交
2210

2211
	dev->mtu = new_mtu;
2212
	mv643xx_eth_recalc_skb_size(mp);
2213 2214
	tx_set_rate(mp, 1000000000, 16777216);

2215 2216
	if (!netif_running(dev))
		return 0;
L
Linus Torvalds 已提交
2217

2218 2219 2220 2221
	/*
	 * 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 已提交
2222
	 * due to memory being full.
2223 2224 2225
	 */
	mv643xx_eth_stop(dev);
	if (mv643xx_eth_open(dev)) {
L
Lennert Buytenhek 已提交
2226 2227 2228
		dev_printk(KERN_ERR, &dev->dev,
			   "fatal error on re-opening device after "
			   "MTU change\n");
2229 2230 2231
	}

	return 0;
L
Linus Torvalds 已提交
2232 2233
}

L
Lennert Buytenhek 已提交
2234
static void tx_timeout_task(struct work_struct *ugly)
L
Linus Torvalds 已提交
2235
{
L
Lennert Buytenhek 已提交
2236
	struct mv643xx_eth_private *mp;
L
Linus Torvalds 已提交
2237

L
Lennert Buytenhek 已提交
2238 2239
	mp = container_of(ugly, struct mv643xx_eth_private, tx_timeout_task);
	if (netif_running(mp->dev)) {
2240
		netif_tx_stop_all_queues(mp->dev);
L
Lennert Buytenhek 已提交
2241 2242
		port_reset(mp);
		port_start(mp);
2243
		netif_tx_wake_all_queues(mp->dev);
L
Lennert Buytenhek 已提交
2244
	}
2245 2246 2247
}

static void mv643xx_eth_tx_timeout(struct net_device *dev)
L
Linus Torvalds 已提交
2248
{
2249
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
2250

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

2253
	schedule_work(&mp->tx_timeout_task);
L
Linus Torvalds 已提交
2254 2255
}

2256
#ifdef CONFIG_NET_POLL_CONTROLLER
L
Lennert Buytenhek 已提交
2257
static void mv643xx_eth_netpoll(struct net_device *dev)
2258
{
L
Lennert Buytenhek 已提交
2259
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2260

L
Lennert Buytenhek 已提交
2261 2262
	wrl(mp, INT_MASK(mp->port_num), 0x00000000);
	rdl(mp, INT_MASK(mp->port_num));
2263

L
Lennert Buytenhek 已提交
2264
	mv643xx_eth_irq(dev->irq, dev);
2265

2266
	wrl(mp, INT_MASK(mp->port_num), INT_TX_END | INT_RX | INT_EXT);
2267
}
2268
#endif
2269 2270


2271
/* platform glue ************************************************************/
2272 2273 2274
static void
mv643xx_eth_conf_mbus_windows(struct mv643xx_eth_shared_private *msp,
			      struct mbus_dram_target_info *dram)
2275
{
2276
	void __iomem *base = msp->base;
2277 2278 2279
	u32 win_enable;
	u32 win_protect;
	int i;
2280

2281 2282 2283 2284 2285
	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));
2286 2287
	}

2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304
	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;
2305 2306
}

2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318
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.
	 */
	writel(0x02000000, msp->base + SDMA_CONFIG(0));
	if (readl(msp->base + SDMA_CONFIG(0)) & 0x02000000)
		msp->extended_rx_coal_limit = 1;
	else
		msp->extended_rx_coal_limit = 0;
2319 2320

	/*
2321 2322 2323
	 * Check whether the MAC supports TX rate control, and if
	 * yes, whether its associated registers are in the old or
	 * the new place.
2324 2325
	 */
	writel(1, msp->base + TX_BW_MTU_MOVED(0));
2326 2327 2328 2329 2330 2331 2332 2333 2334
	if (readl(msp->base + TX_BW_MTU_MOVED(0)) & 1) {
		msp->tx_bw_control = TX_BW_CONTROL_NEW_LAYOUT;
	} else {
		writel(7, msp->base + TX_BW_RATE(0));
		if (readl(msp->base + TX_BW_RATE(0)) & 7)
			msp->tx_bw_control = TX_BW_CONTROL_OLD_LAYOUT;
		else
			msp->tx_bw_control = TX_BW_CONTROL_ABSENT;
	}
2335 2336
}

2337
static int mv643xx_eth_shared_probe(struct platform_device *pdev)
2338
{
2339
	static int mv643xx_eth_version_printed = 0;
2340
	struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
2341
	struct mv643xx_eth_shared_private *msp;
2342 2343
	struct resource *res;
	int ret;
2344

2345
	if (!mv643xx_eth_version_printed++)
2346 2347
		printk(KERN_NOTICE "MV-643xx 10/100/1000 ethernet "
			"driver version %s\n", mv643xx_eth_driver_version);
2348

2349 2350 2351 2352
	ret = -EINVAL;
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL)
		goto out;
2353

2354 2355 2356 2357 2358 2359
	ret = -ENOMEM;
	msp = kmalloc(sizeof(*msp), GFP_KERNEL);
	if (msp == NULL)
		goto out;
	memset(msp, 0, sizeof(*msp));

2360 2361
	msp->base = ioremap(res->start, res->end - res->start + 1);
	if (msp->base == NULL)
2362 2363
		goto out_free;

2364 2365 2366 2367
	/*
	 * Set up and register SMI bus.
	 */
	if (pd == NULL || pd->shared_smi == NULL) {
2368 2369
		msp->smi_bus = mdiobus_alloc();
		if (msp->smi_bus == NULL)
2370
			goto out_unmap;
2371 2372 2373 2374 2375 2376 2377 2378 2379 2380

		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;
2381 2382
		msp->smi = msp;
	} else {
2383
		msp->smi = platform_get_drvdata(pd->shared_smi);
2384
	}
2385

2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403
	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;
		}
	}

2404 2405 2406 2407 2408 2409
	/*
	 * (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 已提交
2410 2411 2412 2413
	/*
	 * Detect hardware parameters.
	 */
	msp->t_clk = (pd != NULL && pd->t_clk != 0) ? pd->t_clk : 133000000;
2414
	infer_hw_params(msp);
L
Lennert Buytenhek 已提交
2415 2416 2417

	platform_set_drvdata(pdev, msp);

2418 2419
	return 0;

2420 2421
out_free_mii_bus:
	mdiobus_free(msp->smi_bus);
2422 2423
out_unmap:
	iounmap(msp->base);
2424 2425 2426 2427 2428 2429 2430 2431
out_free:
	kfree(msp);
out:
	return ret;
}

static int mv643xx_eth_shared_remove(struct platform_device *pdev)
{
2432
	struct mv643xx_eth_shared_private *msp = platform_get_drvdata(pdev);
2433
	struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
2434

2435 2436 2437 2438
	if (pd == NULL || pd->shared_smi == NULL) {
		mdiobus_free(msp->smi_bus);
		mdiobus_unregister(msp->smi_bus);
	}
2439 2440
	if (msp->err_interrupt != NO_IRQ)
		free_irq(msp->err_interrupt, msp);
2441
	iounmap(msp->base);
2442 2443 2444
	kfree(msp);

	return 0;
2445 2446
}

2447
static struct platform_driver mv643xx_eth_shared_driver = {
L
Lennert Buytenhek 已提交
2448 2449
	.probe		= mv643xx_eth_shared_probe,
	.remove		= mv643xx_eth_shared_remove,
2450
	.driver = {
L
Lennert Buytenhek 已提交
2451
		.name	= MV643XX_ETH_SHARED_NAME,
2452 2453 2454 2455
		.owner	= THIS_MODULE,
	},
};

2456
static void phy_addr_set(struct mv643xx_eth_private *mp, int phy_addr)
L
Linus Torvalds 已提交
2457
{
2458
	int addr_shift = 5 * mp->port_num;
L
Lennert Buytenhek 已提交
2459
	u32 data;
L
Linus Torvalds 已提交
2460

L
Lennert Buytenhek 已提交
2461 2462 2463 2464
	data = rdl(mp, PHY_ADDR);
	data &= ~(0x1f << addr_shift);
	data |= (phy_addr & 0x1f) << addr_shift;
	wrl(mp, PHY_ADDR, data);
L
Linus Torvalds 已提交
2465 2466
}

2467
static int phy_addr_get(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2468
{
L
Lennert Buytenhek 已提交
2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490
	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);

	mp->default_rx_ring_size = DEFAULT_RX_QUEUE_SIZE;
	if (pd->rx_queue_size)
		mp->default_rx_ring_size = pd->rx_queue_size;
	mp->rx_desc_sram_addr = pd->rx_sram_addr;
	mp->rx_desc_sram_size = pd->rx_sram_size;
L
Linus Torvalds 已提交
2491

2492
	mp->rxq_count = pd->rx_queue_count ? : 1;
2493

L
Lennert Buytenhek 已提交
2494 2495 2496 2497 2498
	mp->default_tx_ring_size = DEFAULT_TX_QUEUE_SIZE;
	if (pd->tx_queue_size)
		mp->default_tx_ring_size = pd->tx_queue_size;
	mp->tx_desc_sram_addr = pd->tx_sram_addr;
	mp->tx_desc_sram_size = pd->tx_sram_size;
2499

2500
	mp->txq_count = pd->tx_queue_count ? : 1;
L
Linus Torvalds 已提交
2501 2502
}

2503 2504
static struct phy_device *phy_scan(struct mv643xx_eth_private *mp,
				   int phy_addr)
L
Linus Torvalds 已提交
2505
{
2506
	struct mii_bus *bus = mp->shared->smi->smi_bus;
2507 2508 2509 2510
	struct phy_device *phydev;
	int start;
	int num;
	int i;
2511

2512 2513 2514 2515 2516 2517 2518
	if (phy_addr == MV643XX_ETH_PHY_ADDR_DEFAULT) {
		start = phy_addr_get(mp) & 0x1f;
		num = 32;
	} else {
		start = phy_addr & 0x1f;
		num = 1;
	}
2519

2520 2521 2522
	phydev = NULL;
	for (i = 0; i < num; i++) {
		int addr = (start + i) & 0x1f;
L
Lennert Buytenhek 已提交
2523

2524 2525
		if (bus->phy_map[addr] == NULL)
			mdiobus_scan(bus, addr);
L
Linus Torvalds 已提交
2526

2527 2528 2529 2530 2531 2532
		if (phydev == NULL) {
			phydev = bus->phy_map[addr];
			if (phydev != NULL)
				phy_addr_set(mp, addr);
		}
	}
L
Linus Torvalds 已提交
2533

2534
	return phydev;
L
Linus Torvalds 已提交
2535 2536
}

2537
static void phy_init(struct mv643xx_eth_private *mp, int speed, int duplex)
2538
{
2539
	struct phy_device *phy = mp->phy;
2540

L
Lennert Buytenhek 已提交
2541 2542
	phy_reset(mp);

2543 2544 2545 2546 2547 2548 2549
	phy_attach(mp->dev, phy->dev.bus_id, 0, PHY_INTERFACE_MODE_GMII);

	if (speed == 0) {
		phy->autoneg = AUTONEG_ENABLE;
		phy->speed = 0;
		phy->duplex = 0;
		phy->advertising = phy->supported | ADVERTISED_Autoneg;
2550
	} else {
2551 2552 2553 2554
		phy->autoneg = AUTONEG_DISABLE;
		phy->advertising = 0;
		phy->speed = speed;
		phy->duplex = duplex;
2555
	}
2556
	phy_start_aneg(phy);
2557 2558
}

2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569
static void init_pscr(struct mv643xx_eth_private *mp, int speed, int duplex)
{
	u32 pscr;

	pscr = rdl(mp, PORT_SERIAL_CONTROL(mp->port_num));
	if (pscr & SERIAL_PORT_ENABLE) {
		pscr &= ~SERIAL_PORT_ENABLE;
		wrl(mp, PORT_SERIAL_CONTROL(mp->port_num), pscr);
	}

	pscr = MAX_RX_PACKET_9700BYTE | SERIAL_PORT_CONTROL_RESERVED;
2570
	if (mp->phy == NULL) {
2571 2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586
		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;
	}

	wrl(mp, PORT_SERIAL_CONTROL(mp->port_num), pscr);
}

2587
static int mv643xx_eth_probe(struct platform_device *pdev)
L
Linus Torvalds 已提交
2588
{
2589
	struct mv643xx_eth_platform_data *pd;
2590
	struct mv643xx_eth_private *mp;
2591 2592
	struct net_device *dev;
	struct resource *res;
L
Lennert Buytenhek 已提交
2593
	int err;
L
Linus Torvalds 已提交
2594

2595 2596
	pd = pdev->dev.platform_data;
	if (pd == NULL) {
L
Lennert Buytenhek 已提交
2597 2598
		dev_printk(KERN_ERR, &pdev->dev,
			   "no mv643xx_eth_platform_data\n");
2599 2600
		return -ENODEV;
	}
L
Linus Torvalds 已提交
2601

2602
	if (pd->shared == NULL) {
L
Lennert Buytenhek 已提交
2603 2604
		dev_printk(KERN_ERR, &pdev->dev,
			   "no mv643xx_eth_platform_data->shared\n");
2605 2606
		return -ENODEV;
	}
2607

2608
	dev = alloc_etherdev_mq(sizeof(struct mv643xx_eth_private), 8);
2609 2610
	if (!dev)
		return -ENOMEM;
L
Linus Torvalds 已提交
2611

2612
	mp = netdev_priv(dev);
L
Lennert Buytenhek 已提交
2613 2614 2615 2616 2617
	platform_set_drvdata(pdev, mp);

	mp->shared = platform_get_drvdata(pd->shared);
	mp->port_num = pd->port_number;

2618
	mp->dev = dev;
2619

L
Lennert Buytenhek 已提交
2620
	set_params(mp, pd);
2621
	dev->real_num_tx_queues = mp->txq_count;
L
Lennert Buytenhek 已提交
2622

2623 2624
	if (pd->phy_addr != MV643XX_ETH_PHY_NONE)
		mp->phy = phy_scan(mp, pd->phy_addr);
2625

2626 2627
	if (mp->phy != NULL) {
		phy_init(mp, pd->speed, pd->duplex);
2628 2629 2630 2631
		SET_ETHTOOL_OPS(dev, &mv643xx_eth_ethtool_ops);
	} else {
		SET_ETHTOOL_OPS(dev, &mv643xx_eth_ethtool_ops_phyless);
	}
2632

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

2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647

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

2648 2649 2650 2651 2652 2653
	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 已提交
2654

2655 2656 2657
	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	BUG_ON(!res);
	dev->irq = res->start;
L
Linus Torvalds 已提交
2658

2659
	dev->get_stats = mv643xx_eth_get_stats;
L
Lennert Buytenhek 已提交
2660
	dev->hard_start_xmit = mv643xx_eth_xmit;
2661 2662 2663
	dev->open = mv643xx_eth_open;
	dev->stop = mv643xx_eth_stop;
	dev->set_multicast_list = mv643xx_eth_set_rx_mode;
L
Lennert Buytenhek 已提交
2664 2665 2666
	dev->set_mac_address = mv643xx_eth_set_mac_address;
	dev->do_ioctl = mv643xx_eth_ioctl;
	dev->change_mtu = mv643xx_eth_change_mtu;
2667 2668
	dev->tx_timeout = mv643xx_eth_tx_timeout;
#ifdef CONFIG_NET_POLL_CONTROLLER
2669
	dev->poll_controller = mv643xx_eth_netpoll;
2670 2671 2672
#endif
	dev->watchdog_timeo = 2 * HZ;
	dev->base_addr = 0;
L
Linus Torvalds 已提交
2673

2674
	dev->features = NETIF_F_SG | NETIF_F_IP_CSUM;
2675
	dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM;
L
Linus Torvalds 已提交
2676

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

2679
	if (mp->shared->win_protect)
L
Lennert Buytenhek 已提交
2680
		wrl(mp, WINDOW_PROTECT(mp->port_num), mp->shared->win_protect);
L
Linus Torvalds 已提交
2681

2682 2683 2684
	err = register_netdev(dev);
	if (err)
		goto out;
L
Linus Torvalds 已提交
2685

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

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

2692
	return 0;
L
Linus Torvalds 已提交
2693

2694 2695
out:
	free_netdev(dev);
L
Linus Torvalds 已提交
2696

2697
	return err;
L
Linus Torvalds 已提交
2698 2699
}

2700
static int mv643xx_eth_remove(struct platform_device *pdev)
L
Linus Torvalds 已提交
2701
{
L
Lennert Buytenhek 已提交
2702
	struct mv643xx_eth_private *mp = platform_get_drvdata(pdev);
L
Linus Torvalds 已提交
2703

L
Lennert Buytenhek 已提交
2704
	unregister_netdev(mp->dev);
2705 2706
	if (mp->phy != NULL)
		phy_detach(mp->phy);
2707
	flush_scheduled_work();
L
Lennert Buytenhek 已提交
2708
	free_netdev(mp->dev);
2709 2710

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

2712
	return 0;
L
Linus Torvalds 已提交
2713 2714
}

2715
static void mv643xx_eth_shutdown(struct platform_device *pdev)
2716
{
L
Lennert Buytenhek 已提交
2717
	struct mv643xx_eth_private *mp = platform_get_drvdata(pdev);
2718

2719
	/* Mask all interrupts on ethernet port */
L
Lennert Buytenhek 已提交
2720 2721
	wrl(mp, INT_MASK(mp->port_num), 0);
	rdl(mp, INT_MASK(mp->port_num));
2722

L
Lennert Buytenhek 已提交
2723 2724
	if (netif_running(mp->dev))
		port_reset(mp);
2725 2726
}

2727
static struct platform_driver mv643xx_eth_driver = {
L
Lennert Buytenhek 已提交
2728 2729 2730
	.probe		= mv643xx_eth_probe,
	.remove		= mv643xx_eth_remove,
	.shutdown	= mv643xx_eth_shutdown,
2731
	.driver = {
L
Lennert Buytenhek 已提交
2732
		.name	= MV643XX_ETH_NAME,
2733 2734 2735 2736
		.owner	= THIS_MODULE,
	},
};

2737
static int __init mv643xx_eth_init_module(void)
2738
{
2739
	int rc;
2740

2741 2742 2743 2744 2745 2746
	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 已提交
2747

2748
	return rc;
2749
}
L
Lennert Buytenhek 已提交
2750
module_init(mv643xx_eth_init_module);
2751

2752
static void __exit mv643xx_eth_cleanup_module(void)
2753
{
2754 2755
	platform_driver_unregister(&mv643xx_eth_driver);
	platform_driver_unregister(&mv643xx_eth_shared_driver);
2756
}
2757
module_exit(mv643xx_eth_cleanup_module);
L
Linus Torvalds 已提交
2758

2759 2760
MODULE_AUTHOR("Rabeeh Khoury, Assaf Hoffman, Matthew Dharm, "
	      "Manish Lachwani, Dale Farnsworth and Lennert Buytenhek");
2761
MODULE_DESCRIPTION("Ethernet driver for Marvell MV643XX");
L
Lennert Buytenhek 已提交
2762
MODULE_LICENSE("GPL");
2763
MODULE_ALIAS("platform:" MV643XX_ETH_SHARED_NAME);
L
Lennert Buytenhek 已提交
2764
MODULE_ALIAS("platform:" MV643XX_ETH_NAME);