mv643xx_eth.c 65.6 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_16_64BIT		(4 << 1)
140 141
#define BLM_RX_NO_SWAP			(1 << 4)
#define BLM_TX_NO_SWAP			(1 << 5)
142
#define TX_BURST_SIZE_16_64BIT		(4 << 22)
143 144 145

#if defined(__BIG_ENDIAN)
#define PORT_SDMA_CONFIG_DEFAULT_VALUE		\
L
Lennert Buytenhek 已提交
146 147
		(RX_BURST_SIZE_16_64BIT	|	\
		TX_BURST_SIZE_16_64BIT)
148 149
#elif defined(__LITTLE_ENDIAN)
#define PORT_SDMA_CONFIG_DEFAULT_VALUE		\
L
Lennert Buytenhek 已提交
150
		(RX_BURST_SIZE_16_64BIT	|	\
151 152
		BLM_RX_NO_SWAP		|	\
		BLM_TX_NO_SWAP		|	\
L
Lennert Buytenhek 已提交
153
		TX_BURST_SIZE_16_64BIT)
154 155 156 157
#else
#error One of __BIG_ENDIAN or __LITTLE_ENDIAN must be defined
#endif

158 159 160 161 162 163 164

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

174 175
#define DEFAULT_RX_QUEUE_SIZE		128
#define DEFAULT_TX_QUEUE_SIZE		256
176 177


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

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

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

217
/* RX & TX descriptor command */
218
#define BUFFER_OWNED_BY_DMA		0x80000000
219 220

/* RX & TX descriptor status */
221
#define ERROR_SUMMARY			0x00000001
222 223

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

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

241
#define TX_IHL_SHIFT			11
242 243


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

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

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

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

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

283 284 285 286
#define TX_BW_CONTROL_ABSENT		0
#define TX_BW_CONTROL_OLD_LAYOUT	1
#define TX_BW_CONTROL_NEW_LAYOUT	2

287 288

/* per-port *****************************************************************/
289
struct mib_counters {
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 317 318 319 320 321
	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;
};

322
struct rx_queue {
323 324
	int index;

325 326 327 328 329 330 331 332 333 334 335 336
	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;
};

337
struct tx_queue {
338 339
	int index;

340
	int tx_ring_size;
341

342 343 344
	int tx_desc_count;
	int tx_curr_desc;
	int tx_used_desc;
345

346
	struct tx_desc *tx_desc_area;
347 348
	dma_addr_t tx_desc_dma;
	int tx_desc_area_size;
349 350

	struct sk_buff_head tx_skb;
351 352 353 354

	unsigned long tx_packets;
	unsigned long tx_bytes;
	unsigned long tx_dropped;
355 356 357 358
};

struct mv643xx_eth_private {
	struct mv643xx_eth_shared_private *shared;
359
	void __iomem *base;
L
Lennert Buytenhek 已提交
360
	int port_num;
361

L
Lennert Buytenhek 已提交
362
	struct net_device *dev;
363

364
	struct phy_device *phy;
365

366 367
	struct timer_list mib_counters_timer;
	spinlock_t mib_counters_lock;
L
Lennert Buytenhek 已提交
368
	struct mib_counters mib_counters;
369

L
Lennert Buytenhek 已提交
370
	struct work_struct tx_timeout_task;
371

372 373 374 375 376 377 378 379
	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;

380 381 382
	int skb_size;
	struct sk_buff_head rx_recycle;

383 384 385 386 387 388
	/*
	 * RX state.
	 */
	int default_rx_ring_size;
	unsigned long rx_desc_sram_addr;
	int rx_desc_sram_size;
389
	int rxq_count;
390
	struct timer_list rx_oom;
391
	struct rx_queue rxq[8];
392 393 394 395 396 397 398

	/*
	 * TX state.
	 */
	int default_tx_ring_size;
	unsigned long tx_desc_sram_addr;
	int tx_desc_sram_size;
399
	int txq_count;
400
	struct tx_queue txq[8];
401
};
L
Linus Torvalds 已提交
402

403

404
/* port register accessors **************************************************/
405
static inline u32 rdl(struct mv643xx_eth_private *mp, int offset)
406
{
407
	return readl(mp->shared->base + offset);
408
}
409

410 411 412 413 414
static inline u32 rdlp(struct mv643xx_eth_private *mp, int offset)
{
	return readl(mp->base + offset);
}

415
static inline void wrl(struct mv643xx_eth_private *mp, int offset, u32 data)
416
{
417
	writel(data, mp->shared->base + offset);
418
}
419

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

425

426
/* rxq/txq helper functions *************************************************/
427
static struct mv643xx_eth_private *rxq_to_mp(struct rx_queue *rxq)
428
{
429
	return container_of(rxq, struct mv643xx_eth_private, rxq[rxq->index]);
430
}
431

432 433
static struct mv643xx_eth_private *txq_to_mp(struct tx_queue *txq)
{
434
	return container_of(txq, struct mv643xx_eth_private, txq[txq->index]);
435 436
}

437
static void rxq_enable(struct rx_queue *rxq)
438
{
439
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
440
	wrlp(mp, RXQ_COMMAND, 1 << rxq->index);
441
}
L
Linus Torvalds 已提交
442

443 444 445
static void rxq_disable(struct rx_queue *rxq)
{
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
446
	u8 mask = 1 << rxq->index;
L
Linus Torvalds 已提交
447

448 449
	wrlp(mp, RXQ_COMMAND, mask << 8);
	while (rdlp(mp, RXQ_COMMAND) & mask)
450
		udelay(10);
451 452
}

453 454 455 456 457 458 459
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);
460
	wrlp(mp, TXQ_CURRENT_DESC_PTR(txq->index), addr);
461 462
}

463
static void txq_enable(struct tx_queue *txq)
L
Linus Torvalds 已提交
464
{
465
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
466
	wrlp(mp, TXQ_COMMAND, 1 << txq->index);
L
Linus Torvalds 已提交
467 468
}

469
static void txq_disable(struct tx_queue *txq)
L
Linus Torvalds 已提交
470
{
471
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
472
	u8 mask = 1 << txq->index;
473

474 475
	wrlp(mp, TXQ_COMMAND, mask << 8);
	while (rdlp(mp, TXQ_COMMAND) & mask)
476 477 478
		udelay(10);
}

479
static void txq_maybe_wake(struct tx_queue *txq)
480 481
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
482
	struct netdev_queue *nq = netdev_get_tx_queue(mp->dev, txq->index);
483

484 485 486 487 488 489
	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 已提交
490 491
}

492

493
/* rx napi ******************************************************************/
494
static int rxq_process(struct rx_queue *rxq, int budget)
L
Linus Torvalds 已提交
495
{
496 497 498
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	struct net_device_stats *stats = &mp->dev->stats;
	int rx;
L
Linus Torvalds 已提交
499

500
	rx = 0;
501
	while (rx < budget && rxq->rx_desc_count) {
L
Lennert Buytenhek 已提交
502
		struct rx_desc *rx_desc;
503
		unsigned int cmd_sts;
L
Lennert Buytenhek 已提交
504
		struct sk_buff *skb;
505
		u16 byte_cnt;
506

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

509
		cmd_sts = rx_desc->cmd_sts;
510
		if (cmd_sts & BUFFER_OWNED_BY_DMA)
511 512
			break;
		rmb();
L
Linus Torvalds 已提交
513

514 515
		skb = rxq->rx_skb[rxq->rx_curr_desc];
		rxq->rx_skb[rxq->rx_curr_desc] = NULL;
516

517 518 519
		rxq->rx_curr_desc++;
		if (rxq->rx_curr_desc == rxq->rx_ring_size)
			rxq->rx_curr_desc = 0;
520

521
		dma_unmap_single(NULL, rx_desc->buf_ptr,
522
				 rx_desc->buf_size, DMA_FROM_DEVICE);
523 524
		rxq->rx_desc_count--;
		rx++;
525

526 527
		mp->work_rx_refill |= 1 << rxq->index;

528 529
		byte_cnt = rx_desc->byte_cnt;

530 531
		/*
		 * Update statistics.
L
Lennert Buytenhek 已提交
532 533 534 535 536
		 *
		 * 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).
537
		 */
L
Linus Torvalds 已提交
538
		stats->rx_packets++;
539
		stats->rx_bytes += byte_cnt - 2;
540

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

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

		dev_kfree_skb(skb);
L
Linus Torvalds 已提交
578
	}
L
Lennert Buytenhek 已提交
579

580 581 582
	if (rx < budget)
		mp->work_rx &= ~(1 << rxq->index);

583
	return rx;
L
Linus Torvalds 已提交
584 585
}

586
static int rxq_refill(struct rx_queue *rxq, int budget)
587
{
588 589
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	int refilled;
590

591 592 593 594 595
	refilled = 0;
	while (refilled < budget && rxq->rx_desc_count < rxq->rx_ring_size) {
		struct sk_buff *skb;
		int unaligned;
		int rx;
596
		struct rx_desc *rx_desc;
597

598 599 600 601 602
		skb = __skb_dequeue(&mp->rx_recycle);
		if (skb == NULL)
			skb = dev_alloc_skb(mp->skb_size +
					    dma_get_cache_alignment() - 1);

603 604 605 606
		if (skb == NULL) {
			mp->work_rx_oom |= 1 << rxq->index;
			goto oom;
		}
607

608 609 610
		unaligned = (u32)skb->data & (dma_get_cache_alignment() - 1);
		if (unaligned)
			skb_reserve(skb, dma_get_cache_alignment() - unaligned);
611

612 613
		refilled++;
		rxq->rx_desc_count++;
614

615 616 617
		rx = rxq->rx_used_desc++;
		if (rxq->rx_used_desc == rxq->rx_ring_size)
			rxq->rx_used_desc = 0;
618

619 620 621 622 623
		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;
624 625
		rxq->rx_skb[rx] = skb;
		wmb();
626
		rx_desc->cmd_sts = BUFFER_OWNED_BY_DMA | RX_ENABLE_INTERRUPT;
627
		wmb();
628

629 630 631 632 633 634 635 636 637 638 639 640 641
		/*
		 * 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;
642 643
}

644 645 646

/* tx ***********************************************************************/
static inline unsigned int has_tiny_unaligned_frags(struct sk_buff *skb)
L
Linus Torvalds 已提交
647
{
648
	int frag;
L
Linus Torvalds 已提交
649

650
	for (frag = 0; frag < skb_shinfo(skb)->nr_frags; frag++) {
651 652
		skb_frag_t *fragp = &skb_shinfo(skb)->frags[frag];
		if (fragp->size <= 8 && fragp->page_offset & 7)
653
			return 1;
L
Linus Torvalds 已提交
654
	}
655

656 657
	return 0;
}
658

659
static void txq_submit_frag_skb(struct tx_queue *txq, struct sk_buff *skb)
660
{
661
	int nr_frags = skb_shinfo(skb)->nr_frags;
662
	int frag;
L
Linus Torvalds 已提交
663

664 665 666 667 668 669
	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];
670 671 672
		tx_index = txq->tx_curr_desc++;
		if (txq->tx_curr_desc == txq->tx_ring_size)
			txq->tx_curr_desc = 0;
673 674 675 676 677 678 679 680 681 682 683 684 685 686
		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;
		}

687 688 689 690 691 692 693
		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 已提交
694 695
}

696 697 698 699
static inline __be16 sum16_as_be(__sum16 sum)
{
	return (__force __be16)sum;
}
L
Linus Torvalds 已提交
700

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

711
	cmd_sts = TX_FIRST_DESC | GEN_CRC | BUFFER_OWNED_BY_DMA;
712
	l4i_chk = 0;
713 714

	if (skb->ip_summed == CHECKSUM_PARTIAL) {
715
		int tag_bytes;
716 717 718

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

720 721 722 723 724 725 726
		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;
		}
727

728
		if (tag_bytes & 4)
729
			cmd_sts |= MAC_HDR_EXTRA_4_BYTES;
730
		if (tag_bytes & 8)
731
			cmd_sts |= MAC_HDR_EXTRA_8_BYTES;
732 733 734 735

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

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

754 755 756
	tx_index = txq->tx_curr_desc++;
	if (txq->tx_curr_desc == txq->tx_ring_size)
		txq->tx_curr_desc = 0;
757 758 759 760 761 762 763 764 765 766 767 768 769 770
	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);

771 772
	__skb_queue_tail(&txq->tx_skb, skb);

773 774 775 776
	/* ensure all other descriptors are written before first cmd_sts */
	wmb();
	desc->cmd_sts = cmd_sts;

777 778
	/* clear TX_END status */
	mp->work_tx_end &= ~(1 << txq->index);
779

780 781
	/* ensure all descriptors are written before poking hardware */
	wmb();
782
	txq_enable(txq);
783

784
	txq->tx_desc_count += nr_frags + 1;
785 786

	return 0;
L
Linus Torvalds 已提交
787 788
}

L
Lennert Buytenhek 已提交
789
static int mv643xx_eth_xmit(struct sk_buff *skb, struct net_device *dev)
L
Linus Torvalds 已提交
790
{
791
	struct mv643xx_eth_private *mp = netdev_priv(dev);
792
	int queue;
793
	struct tx_queue *txq;
794
	struct netdev_queue *nq;
795

796 797 798 799
	queue = skb_get_queue_mapping(skb);
	txq = mp->txq + queue;
	nq = netdev_get_tx_queue(dev, queue);

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

808
	if (txq->tx_ring_size - txq->tx_desc_count < MAX_SKB_FRAGS + 1) {
809 810
		if (net_ratelimit())
			dev_printk(KERN_ERR, &dev->dev, "tx queue full?!\n");
811 812
		kfree_skb(skb);
		return NETDEV_TX_OK;
813 814
	}

815 816 817 818 819 820
	if (!txq_submit_skb(txq, skb)) {
		int entries_left;

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

822 823 824 825
		entries_left = txq->tx_ring_size - txq->tx_desc_count;
		if (entries_left < MAX_SKB_FRAGS + 1)
			netif_tx_stop_queue(nq);
	}
826 827

	return NETDEV_TX_OK;
L
Linus Torvalds 已提交
828 829
}

830

831 832 833 834
/* tx napi ******************************************************************/
static void txq_kick(struct tx_queue *txq)
{
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
835
	struct netdev_queue *nq = netdev_get_tx_queue(mp->dev, txq->index);
836 837 838
	u32 hw_desc_ptr;
	u32 expected_ptr;

839
	__netif_tx_lock(nq, smp_processor_id());
840

841
	if (rdlp(mp, TXQ_COMMAND) & (1 << txq->index))
842 843
		goto out;

844
	hw_desc_ptr = rdlp(mp, TXQ_CURRENT_DESC_PTR(txq->index));
845 846 847 848 849 850 851
	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:
852
	__netif_tx_unlock(nq);
853 854 855 856 857 858 859

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

863
	__netif_tx_lock(nq, smp_processor_id());
864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888

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

889 890 891
		skb = NULL;
		if (cmd_sts & TX_LAST_DESC)
			skb = __skb_dequeue(&txq->tx_skb);
892 893 894 895 896 897

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

898 899 900 901 902 903 904
		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);
		}
905

906 907 908
		if (skb != NULL) {
			if (skb_queue_len(&mp->rx_recycle) <
					mp->default_rx_ring_size &&
909 910
			    skb_recycle_check(skb, mp->skb_size +
					dma_get_cache_alignment() - 1))
911 912 913 914
				__skb_queue_head(&mp->rx_recycle, skb);
			else
				dev_kfree_skb(skb);
		}
915 916
	}

917 918
	__netif_tx_unlock(nq);

919 920 921 922 923 924 925
	if (reclaimed < budget)
		mp->work_tx &= ~(1 << txq->index);

	return reclaimed;
}


926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948
/* 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;

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

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;

977 978
	wrlp(mp, TXQ_BW_TOKENS(txq->index), token_rate << 14);
	wrlp(mp, TXQ_BW_CONF(txq->index), (bucket_size << 10) | token_rate);
979 980 981 982 983 984 985 986 987 988 989
}

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.
	 */
990 991 992
	off = 0;
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
993
		off = TXQ_FIX_PRIO_CONF;
994 995
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
996
		off = TXQ_FIX_PRIO_CONF_MOVED;
997 998
		break;
	}
999

1000
	if (off) {
1001
		val = rdlp(mp, off);
1002
		val |= 1 << txq->index;
1003
		wrlp(mp, off, val);
1004
	}
1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015
}

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.
	 */
1016 1017 1018
	off = 0;
	switch (mp->shared->tx_bw_control) {
	case TX_BW_CONTROL_OLD_LAYOUT:
1019
		off = TXQ_FIX_PRIO_CONF;
1020 1021
		break;
	case TX_BW_CONTROL_NEW_LAYOUT:
1022
		off = TXQ_FIX_PRIO_CONF_MOVED;
1023 1024
		break;
	}
1025

1026
	if (off) {
1027
		val = rdlp(mp, off);
1028
		val &= ~(1 << txq->index);
1029
		wrlp(mp, off, val);
1030

1031 1032 1033
		/*
		 * Configure WRR weight for this queue.
		 */
1034

1035
		val = rdlp(mp, off);
1036
		val = (val & ~0xff) | (weight & 0xff);
1037
		wrlp(mp, TXQ_BW_WRR_CONF(txq->index), val);
1038
	}
1039 1040 1041
}


1042
/* mii management interface *************************************************/
1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054
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;
}
1055

1056
static int smi_is_done(struct mv643xx_eth_shared_private *msp)
L
Linus Torvalds 已提交
1057
{
1058 1059
	return !(readl(msp->base + SMI_REG) & SMI_BUSY);
}
L
Linus Torvalds 已提交
1060

1061 1062 1063 1064
static int smi_wait_ready(struct mv643xx_eth_shared_private *msp)
{
	if (msp->err_interrupt == NO_IRQ) {
		int i;
1065

1066 1067 1068 1069
		for (i = 0; !smi_is_done(msp); i++) {
			if (i == 10)
				return -ETIMEDOUT;
			msleep(10);
1070
		}
1071 1072 1073 1074

		return 0;
	}

1075 1076 1077 1078 1079 1080
	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;
	}
1081 1082 1083 1084

	return 0;
}

1085
static int smi_bus_read(struct mii_bus *bus, int addr, int reg)
1086
{
1087
	struct mv643xx_eth_shared_private *msp = bus->priv;
1088 1089 1090 1091
	void __iomem *smi_reg = msp->base + SMI_REG;
	int ret;

	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1092
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1093
		return -ETIMEDOUT;
L
Linus Torvalds 已提交
1094 1095
	}

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

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

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

1109
	return ret & 0xffff;
L
Linus Torvalds 已提交
1110 1111
}

1112
static int smi_bus_write(struct mii_bus *bus, int addr, int reg, u16 val)
L
Linus Torvalds 已提交
1113
{
1114
	struct mv643xx_eth_shared_private *msp = bus->priv;
1115
	void __iomem *smi_reg = msp->base + SMI_REG;
L
Linus Torvalds 已提交
1116

1117
	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1118
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1119
		return -ETIMEDOUT;
L
Linus Torvalds 已提交
1120 1121
	}

L
Lennert Buytenhek 已提交
1122
	writel(SMI_OPCODE_WRITE | (reg << 21) |
1123
		(addr << 16) | (val & 0xffff), smi_reg);
1124

1125
	if (smi_wait_ready(msp)) {
L
Lennert Buytenhek 已提交
1126
		printk(KERN_WARNING "mv643xx_eth: SMI bus busy timeout\n");
1127 1128
		return -ETIMEDOUT;
	}
1129 1130

	return 0;
1131
}
L
Linus Torvalds 已提交
1132

1133

1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158
/* 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 已提交
1159
static inline u32 mib_read(struct mv643xx_eth_private *mp, int offset)
1160
{
L
Lennert Buytenhek 已提交
1161
	return rdl(mp, MIB_COUNTERS(mp->port_num) + offset);
L
Linus Torvalds 已提交
1162 1163
}

L
Lennert Buytenhek 已提交
1164
static void mib_counters_clear(struct mv643xx_eth_private *mp)
1165
{
L
Lennert Buytenhek 已提交
1166 1167 1168 1169
	int i;

	for (i = 0; i < 0x80; i += 4)
		mib_read(mp, i);
1170
}
1171

L
Lennert Buytenhek 已提交
1172
static void mib_counters_update(struct mv643xx_eth_private *mp)
1173
{
1174
	struct mib_counters *p = &mp->mib_counters;
1175

1176
	spin_lock(&mp->mib_counters_lock);
L
Lennert Buytenhek 已提交
1177 1178 1179 1180 1181 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
	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);
1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
	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);
1219 1220
}

1221 1222

/* ethtool ******************************************************************/
1223
struct mv643xx_eth_stats {
1224 1225
	char stat_string[ETH_GSTRING_LEN];
	int sizeof_stat;
1226 1227
	int netdev_off;
	int mp_off;
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
#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),
1277 1278
};

L
Lennert Buytenhek 已提交
1279 1280
static int
mv643xx_eth_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
1281
{
1282
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1283 1284
	int err;

1285 1286 1287
	err = phy_read_status(mp->phy);
	if (err == 0)
		err = phy_ethtool_gset(mp->phy, cmd);
1288

L
Lennert Buytenhek 已提交
1289 1290 1291
	/*
	 * The MAC does not support 1000baseT_Half.
	 */
1292 1293 1294 1295 1296 1297
	cmd->supported &= ~SUPPORTED_1000baseT_Half;
	cmd->advertising &= ~ADVERTISED_1000baseT_Half;

	return err;
}

L
Lennert Buytenhek 已提交
1298 1299 1300
static int
mv643xx_eth_get_settings_phyless(struct net_device *dev,
				 struct ethtool_cmd *cmd)
1301
{
1302 1303 1304
	struct mv643xx_eth_private *mp = netdev_priv(dev);
	u32 port_status;

1305
	port_status = rdlp(mp, PORT_STATUS);
1306

1307 1308
	cmd->supported = SUPPORTED_MII;
	cmd->advertising = ADVERTISED_MII;
1309 1310 1311 1312 1313 1314 1315 1316 1317 1318 1319 1320 1321 1322 1323
	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;
1324 1325 1326 1327 1328 1329 1330 1331 1332 1333
	cmd->port = PORT_MII;
	cmd->phy_address = 0;
	cmd->transceiver = XCVR_INTERNAL;
	cmd->autoneg = AUTONEG_DISABLE;
	cmd->maxtxpkt = 1;
	cmd->maxrxpkt = 1;

	return 0;
}

L
Lennert Buytenhek 已提交
1334 1335
static int
mv643xx_eth_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
L
Linus Torvalds 已提交
1336
{
1337
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1338

L
Lennert Buytenhek 已提交
1339 1340 1341 1342 1343
	/*
	 * The MAC does not support 1000baseT_Half.
	 */
	cmd->advertising &= ~ADVERTISED_1000baseT_Half;

1344
	return phy_ethtool_sset(mp->phy, cmd);
1345
}
L
Linus Torvalds 已提交
1346

L
Lennert Buytenhek 已提交
1347 1348 1349
static int
mv643xx_eth_set_settings_phyless(struct net_device *dev,
				 struct ethtool_cmd *cmd)
1350 1351 1352 1353
{
	return -EINVAL;
}

L
Lennert Buytenhek 已提交
1354 1355
static void mv643xx_eth_get_drvinfo(struct net_device *dev,
				    struct ethtool_drvinfo *drvinfo)
1356
{
1357 1358
	strncpy(drvinfo->driver,  mv643xx_eth_driver_name, 32);
	strncpy(drvinfo->version, mv643xx_eth_driver_version, 32);
1359
	strncpy(drvinfo->fw_version, "N/A", 32);
L
Lennert Buytenhek 已提交
1360
	strncpy(drvinfo->bus_info, "platform", 32);
1361
	drvinfo->n_stats = ARRAY_SIZE(mv643xx_eth_stats);
1362
}
L
Linus Torvalds 已提交
1363

L
Lennert Buytenhek 已提交
1364
static int mv643xx_eth_nway_reset(struct net_device *dev)
1365
{
1366
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
1367

1368
	return genphy_restart_aneg(mp->phy);
1369
}
L
Linus Torvalds 已提交
1370

1371 1372 1373 1374 1375
static int mv643xx_eth_nway_reset_phyless(struct net_device *dev)
{
	return -EINVAL;
}

1376 1377
static u32 mv643xx_eth_get_link(struct net_device *dev)
{
1378
	return !!netif_carrier_ok(dev);
1379 1380
}

L
Lennert Buytenhek 已提交
1381 1382
static void mv643xx_eth_get_strings(struct net_device *dev,
				    uint32_t stringset, uint8_t *data)
1383 1384
{
	int i;
L
Linus Torvalds 已提交
1385

L
Lennert Buytenhek 已提交
1386 1387
	if (stringset == ETH_SS_STATS) {
		for (i = 0; i < ARRAY_SIZE(mv643xx_eth_stats); i++) {
1388
			memcpy(data + i * ETH_GSTRING_LEN,
1389
				mv643xx_eth_stats[i].stat_string,
1390
				ETH_GSTRING_LEN);
1391 1392 1393
		}
	}
}
L
Linus Torvalds 已提交
1394

L
Lennert Buytenhek 已提交
1395 1396 1397
static void mv643xx_eth_get_ethtool_stats(struct net_device *dev,
					  struct ethtool_stats *stats,
					  uint64_t *data)
1398
{
1399
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1400
	int i;
L
Linus Torvalds 已提交
1401

1402
	mv643xx_eth_get_stats(dev);
L
Lennert Buytenhek 已提交
1403
	mib_counters_update(mp);
L
Linus Torvalds 已提交
1404

1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417
	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 已提交
1418
	}
1419
}
L
Linus Torvalds 已提交
1420

L
Lennert Buytenhek 已提交
1421
static int mv643xx_eth_get_sset_count(struct net_device *dev, int sset)
1422
{
L
Lennert Buytenhek 已提交
1423
	if (sset == ETH_SS_STATS)
1424
		return ARRAY_SIZE(mv643xx_eth_stats);
L
Lennert Buytenhek 已提交
1425 1426

	return -EOPNOTSUPP;
1427
}
L
Linus Torvalds 已提交
1428

1429
static const struct ethtool_ops mv643xx_eth_ethtool_ops = {
L
Lennert Buytenhek 已提交
1430 1431 1432 1433 1434
	.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,
1435
	.set_sg			= ethtool_op_set_sg,
L
Lennert Buytenhek 已提交
1436 1437
	.get_strings		= mv643xx_eth_get_strings,
	.get_ethtool_stats	= mv643xx_eth_get_ethtool_stats,
1438
	.get_sset_count		= mv643xx_eth_get_sset_count,
1439
};
L
Linus Torvalds 已提交
1440

1441 1442 1443 1444 1445
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,
1446
	.get_link		= mv643xx_eth_get_link,
1447 1448 1449 1450 1451 1452
	.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,
};

1453

1454
/* address handling *********************************************************/
1455
static void uc_addr_get(struct mv643xx_eth_private *mp, unsigned char *addr)
1456
{
1457 1458
	unsigned int mac_h = rdlp(mp, MAC_ADDR_HIGH);
	unsigned int mac_l = rdlp(mp, MAC_ADDR_LOW);
L
Linus Torvalds 已提交
1459

1460 1461 1462 1463 1464 1465
	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;
1466
}
L
Linus Torvalds 已提交
1467

1468
static void uc_addr_set(struct mv643xx_eth_private *mp, unsigned char *addr)
1469
{
1470 1471 1472
	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]);
1473
}
1474

1475
static u32 uc_addr_filter_mask(struct net_device *dev)
1476
{
1477 1478
	struct dev_addr_list *uc_ptr;
	u32 nibbles;
L
Linus Torvalds 已提交
1479

1480 1481
	if (dev->flags & IFF_PROMISC)
		return 0;
L
Linus Torvalds 已提交
1482

1483 1484 1485 1486 1487 1488
	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;
1489

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

1493
	return nibbles;
L
Linus Torvalds 已提交
1494 1495
}

1496
static void mv643xx_eth_program_unicast_filter(struct net_device *dev)
L
Linus Torvalds 已提交
1497
{
1498
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1499 1500 1501
	u32 port_config;
	u32 nibbles;
	int i;
L
Linus Torvalds 已提交
1502

1503
	uc_addr_set(mp, dev->dev_addr);
L
Linus Torvalds 已提交
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 1531 1532
	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 已提交
1533 1534
}

1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552
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;
}

1553
static void mv643xx_eth_program_multicast_filter(struct net_device *dev)
L
Linus Torvalds 已提交
1554
{
L
Lennert Buytenhek 已提交
1555
	struct mv643xx_eth_private *mp = netdev_priv(dev);
1556 1557
	u32 *mc_spec;
	u32 *mc_other;
L
Lennert Buytenhek 已提交
1558 1559
	struct dev_addr_list *addr;
	int i;
1560

L
Lennert Buytenhek 已提交
1561
	if (dev->flags & (IFF_PROMISC | IFF_ALLMULTI)) {
1562 1563 1564
		int port_num;
		u32 accept;
		int i;
1565

1566 1567 1568
oom:
		port_num = mp->port_num;
		accept = 0x01010101;
L
Lennert Buytenhek 已提交
1569 1570 1571
		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);
1572 1573 1574
		}
		return;
	}
1575

1576 1577 1578 1579 1580 1581 1582
	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 已提交
1583

L
Lennert Buytenhek 已提交
1584 1585
	for (addr = dev->mc_list; addr != NULL; addr = addr->next) {
		u8 *a = addr->da_addr;
1586 1587
		u32 *table;
		int entry;
L
Linus Torvalds 已提交
1588

L
Lennert Buytenhek 已提交
1589
		if (memcmp(a, "\x01\x00\x5e\x00\x00", 5) == 0) {
1590 1591
			table = mc_spec;
			entry = a[5];
L
Lennert Buytenhek 已提交
1592
		} else {
1593 1594
			table = mc_other;
			entry = addr_crc(a);
L
Lennert Buytenhek 已提交
1595
		}
1596 1597

		table[entry >> 2] |= 1 << (entry & 3);
L
Lennert Buytenhek 已提交
1598
	}
1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624

	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;
1625
}
1626 1627


1628
/* rx/tx queue initialisation ***********************************************/
1629
static int rxq_init(struct mv643xx_eth_private *mp, int index)
1630
{
1631
	struct rx_queue *rxq = mp->rxq + index;
1632 1633
	struct rx_desc *rx_desc;
	int size;
1634 1635
	int i;

1636 1637
	rxq->index = index;

1638 1639 1640 1641 1642 1643 1644 1645
	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);

1646
	if (index == 0 && size <= mp->rx_desc_sram_size) {
1647 1648 1649 1650 1651 1652 1653
		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);
1654 1655
	}

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

1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673
	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++) {
1674 1675 1676 1677 1678 1679
		int nexti;

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

1680 1681 1682 1683 1684 1685 1686 1687
		rx_desc[i].next_desc_ptr = rxq->rx_desc_dma +
					nexti * sizeof(struct rx_desc);
	}

	return 0;


out_free:
1688
	if (index == 0 && size <= mp->rx_desc_sram_size)
1689 1690 1691 1692 1693 1694 1695 1696
		iounmap(rxq->rx_desc_area);
	else
		dma_free_coherent(NULL, size,
				  rxq->rx_desc_area,
				  rxq->rx_desc_dma);

out:
	return -ENOMEM;
1697
}
1698

1699
static void rxq_deinit(struct rx_queue *rxq)
1700
{
1701 1702 1703 1704
	struct mv643xx_eth_private *mp = rxq_to_mp(rxq);
	int i;

	rxq_disable(rxq);
1705

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

1713 1714 1715 1716 1717 1718
	if (rxq->rx_desc_count) {
		dev_printk(KERN_ERR, &mp->dev->dev,
			   "error freeing rx ring -- %d skbs stuck\n",
			   rxq->rx_desc_count);
	}

1719
	if (rxq->index == 0 &&
1720
	    rxq->rx_desc_area_size <= mp->rx_desc_sram_size)
1721
		iounmap(rxq->rx_desc_area);
1722
	else
1723 1724 1725 1726
		dma_free_coherent(NULL, rxq->rx_desc_area_size,
				  rxq->rx_desc_area, rxq->rx_desc_dma);

	kfree(rxq->rx_skb);
1727
}
L
Linus Torvalds 已提交
1728

1729
static int txq_init(struct mv643xx_eth_private *mp, int index)
1730
{
1731
	struct tx_queue *txq = mp->txq + index;
1732 1733
	struct tx_desc *tx_desc;
	int size;
1734
	int i;
L
Linus Torvalds 已提交
1735

1736 1737
	txq->index = index;

1738 1739 1740 1741 1742 1743 1744 1745
	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);

1746
	if (index == 0 && size <= mp->tx_desc_sram_size) {
1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758
		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);
1759
		return -ENOMEM;
1760
	}
1761 1762 1763 1764 1765 1766
	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++) {
1767
		struct tx_desc *txd = tx_desc + i;
1768 1769 1770 1771 1772
		int nexti;

		nexti = i + 1;
		if (nexti == txq->tx_ring_size)
			nexti = 0;
1773 1774 1775

		txd->cmd_sts = 0;
		txd->next_desc_ptr = txq->tx_desc_dma +
1776 1777 1778
					nexti * sizeof(struct tx_desc);
	}

1779
	skb_queue_head_init(&txq->tx_skb);
1780

1781
	return 0;
1782
}
L
Linus Torvalds 已提交
1783

1784
static void txq_deinit(struct tx_queue *txq)
1785
{
1786
	struct mv643xx_eth_private *mp = txq_to_mp(txq);
1787

1788
	txq_disable(txq);
1789
	txq_reclaim(txq, txq->tx_ring_size, 1);
L
Linus Torvalds 已提交
1790

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

1793
	if (txq->index == 0 &&
1794
	    txq->tx_desc_area_size <= mp->tx_desc_sram_size)
1795
		iounmap(txq->tx_desc_area);
1796
	else
1797 1798
		dma_free_coherent(NULL, txq->tx_desc_area_size,
				  txq->tx_desc_area, txq->tx_desc_dma);
1799
}
L
Linus Torvalds 已提交
1800 1801


1802
/* netdev ops and related ***************************************************/
1803 1804 1805 1806 1807
static int mv643xx_eth_collect_events(struct mv643xx_eth_private *mp)
{
	u32 int_cause;
	u32 int_cause_ext;

1808
	int_cause = rdlp(mp, INT_CAUSE) & (INT_TX_END | INT_RX | INT_EXT);
1809 1810 1811 1812 1813
	if (int_cause == 0)
		return 0;

	int_cause_ext = 0;
	if (int_cause & INT_EXT)
1814
		int_cause_ext = rdlp(mp, INT_CAUSE_EXT);
1815 1816 1817

	int_cause &= INT_TX_END | INT_RX;
	if (int_cause) {
1818
		wrlp(mp, INT_CAUSE, ~int_cause);
1819
		mp->work_tx_end |= ((int_cause & INT_TX_END) >> 19) &
1820
				~(rdlp(mp, TXQ_COMMAND) & 0xff);
1821 1822 1823 1824 1825
		mp->work_rx |= (int_cause & INT_RX) >> 2;
	}

	int_cause_ext &= INT_EXT_LINK_PHY | INT_EXT_TX;
	if (int_cause_ext) {
1826
		wrlp(mp, INT_CAUSE_EXT, ~int_cause_ext);
1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842
		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;

1843
	wrlp(mp, INT_MASK, 0);
1844 1845 1846 1847 1848
	napi_schedule(&mp->napi);

	return IRQ_HANDLED;
}

1849 1850 1851 1852 1853 1854 1855 1856
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;

1857
	port_status = rdlp(mp, PORT_STATUS);
1858 1859 1860 1861 1862 1863 1864 1865
	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);

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

1869
				txq_reclaim(txq, txq->tx_ring_size, 1);
1870
				txq_reset_hw_ptr(txq);
1871 1872 1873 1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886 1887 1888 1889 1890 1891 1892 1893 1894 1895 1896 1897
			}
		}
		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");

1898
	if (!netif_carrier_ok(dev))
1899 1900 1901
		netif_carrier_on(dev);
}

1902
static int mv643xx_eth_poll(struct napi_struct *napi, int budget)
1903
{
1904 1905
	struct mv643xx_eth_private *mp;
	int work_done;
1906

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

1909 1910
	mp->work_rx_refill |= mp->work_rx_oom;
	mp->work_rx_oom = 0;
L
Linus Torvalds 已提交
1911

1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922
	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 已提交
1923

1924 1925 1926 1927 1928 1929 1930
		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 已提交
1931

1932 1933 1934 1935 1936 1937 1938 1939 1940 1941 1942 1943 1944 1945 1946 1947 1948 1949 1950
		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();
		}
1951
	}
L
Lennert Buytenhek 已提交
1952

1953 1954 1955 1956
	if (work_done < budget) {
		if (mp->work_rx_oom)
			mod_timer(&mp->rx_oom, jiffies + (HZ / 10));
		napi_complete(napi);
1957
		wrlp(mp, INT_MASK, INT_TX_END | INT_RX | INT_EXT);
1958
	}
1959

1960 1961
	return work_done;
}
1962

1963 1964 1965
static inline void oom_timer_wrapper(unsigned long data)
{
	struct mv643xx_eth_private *mp = (void *)data;
L
Linus Torvalds 已提交
1966

1967
	napi_schedule(&mp->napi);
L
Linus Torvalds 已提交
1968 1969
}

1970
static void phy_reset(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
1971
{
1972 1973
	int data;

1974
	data = phy_read(mp->phy, MII_BMCR);
1975 1976
	if (data < 0)
		return;
L
Linus Torvalds 已提交
1977

1978
	data |= BMCR_RESET;
1979
	if (phy_write(mp->phy, MII_BMCR, data) < 0)
1980
		return;
L
Linus Torvalds 已提交
1981

1982
	do {
1983
		data = phy_read(mp->phy, MII_BMCR);
1984
	} while (data >= 0 && data & BMCR_RESET);
L
Linus Torvalds 已提交
1985 1986
}

L
Lennert Buytenhek 已提交
1987
static void port_start(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
1988
{
1989
	u32 pscr;
1990
	int i;
L
Linus Torvalds 已提交
1991

1992 1993 1994
	/*
	 * Perform PHY reset, if there is a PHY.
	 */
1995
	if (mp->phy != NULL) {
1996 1997 1998 1999 2000 2001
		struct ethtool_cmd cmd;

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

2003 2004 2005
	/*
	 * Configure basic link parameters.
	 */
2006
	pscr = rdlp(mp, PORT_SERIAL_CONTROL);
2007 2008

	pscr |= SERIAL_PORT_ENABLE;
2009
	wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2010 2011

	pscr |= DO_NOT_FORCE_LINK_FAIL;
2012
	if (mp->phy == NULL)
2013
		pscr |= FORCE_LINK_PASS;
2014
	wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2015

2016
	wrlp(mp, SDMA_CONFIG, PORT_SDMA_CONFIG_DEFAULT_VALUE);
2017

2018 2019 2020
	/*
	 * Configure TX path and queues.
	 */
2021
	tx_set_rate(mp, 1000000000, 16777216);
2022
	for (i = 0; i < mp->txq_count; i++) {
2023
		struct tx_queue *txq = mp->txq + i;
2024

2025
		txq_reset_hw_ptr(txq);
2026 2027
		txq_set_rate(txq, 1000000000, 16777216);
		txq_set_fixed_prio_mode(txq);
2028 2029
	}

L
Lennert Buytenhek 已提交
2030 2031 2032
	/*
	 * Add configured unicast address to address filter table.
	 */
2033
	mv643xx_eth_program_unicast_filter(mp->dev);
L
Linus Torvalds 已提交
2034

2035 2036
	/*
	 * Receive all unmatched unicast, TCP, UDP, BPDU and broadcast
2037 2038
	 * frames to RX queue #0, and include the pseudo-header when
	 * calculating receive checksums.
2039
	 */
2040
	wrlp(mp, PORT_CONFIG, 0x02000000);
2041

2042 2043 2044
	/*
	 * Treat BPDUs as normal multicasts, and disable partition mode.
	 */
2045
	wrlp(mp, PORT_CONFIG_EXT, 0x00000000);
2046

2047
	/*
2048
	 * Enable the receive queues.
2049
	 */
2050
	for (i = 0; i < mp->rxq_count; i++) {
2051
		struct rx_queue *rxq = mp->rxq + i;
2052
		u32 addr;
L
Linus Torvalds 已提交
2053

2054 2055
		addr = (u32)rxq->rx_desc_dma;
		addr += rxq->rx_curr_desc * sizeof(struct rx_desc);
2056
		wrlp(mp, RXQ_CURRENT_DESC_PTR(i), addr);
L
Linus Torvalds 已提交
2057

2058 2059
		rxq_enable(rxq);
	}
L
Linus Torvalds 已提交
2060 2061
}

2062
static void set_rx_coal(struct mv643xx_eth_private *mp, unsigned int delay)
L
Linus Torvalds 已提交
2063
{
2064
	unsigned int coal = ((mp->shared->t_clk / 1000000) * delay) / 64;
2065
	u32 val;
L
Linus Torvalds 已提交
2066

2067
	val = rdlp(mp, SDMA_CONFIG);
2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
	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;
	}
2080
	wrlp(mp, SDMA_CONFIG, val);
L
Linus Torvalds 已提交
2081 2082
}

2083
static void set_tx_coal(struct mv643xx_eth_private *mp, unsigned int delay)
L
Linus Torvalds 已提交
2084
{
2085
	unsigned int coal = ((mp->shared->t_clk / 1000000) * delay) / 64;
L
Linus Torvalds 已提交
2086

L
Lennert Buytenhek 已提交
2087 2088
	if (coal > 0x3fff)
		coal = 0x3fff;
2089
	wrlp(mp, TX_FIFO_URGENT_THRESHOLD, (coal & 0x3fff) << 4);
2090 2091
}

2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111
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;
}

2112
static int mv643xx_eth_open(struct net_device *dev)
2113
{
2114
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2115
	int err;
2116
	int i;
2117

2118 2119 2120
	wrlp(mp, INT_CAUSE, 0);
	wrlp(mp, INT_CAUSE_EXT, 0);
	rdlp(mp, INT_CAUSE_EXT);
2121

L
Lennert Buytenhek 已提交
2122
	err = request_irq(dev->irq, mv643xx_eth_irq,
2123
			  IRQF_SHARED, dev->name, dev);
2124
	if (err) {
L
Lennert Buytenhek 已提交
2125
		dev_printk(KERN_ERR, &dev->dev, "can't assign irq\n");
2126
		return -EAGAIN;
2127 2128
	}

2129 2130
	mv643xx_eth_recalc_skb_size(mp);

2131 2132
	napi_enable(&mp->napi);

2133 2134
	skb_queue_head_init(&mp->rx_recycle);

2135
	for (i = 0; i < mp->rxq_count; i++) {
2136 2137 2138
		err = rxq_init(mp, i);
		if (err) {
			while (--i >= 0)
2139
				rxq_deinit(mp->rxq + i);
2140 2141 2142
			goto out;
		}

2143
		rxq_refill(mp->rxq + i, INT_MAX);
2144 2145
	}

2146
	if (mp->work_rx_oom) {
2147 2148
		mp->rx_oom.expires = jiffies + (HZ / 10);
		add_timer(&mp->rx_oom);
2149
	}
2150

2151
	for (i = 0; i < mp->txq_count; i++) {
2152 2153 2154
		err = txq_init(mp, i);
		if (err) {
			while (--i >= 0)
2155
				txq_deinit(mp->txq + i);
2156 2157 2158
			goto out_free;
		}
	}
2159

2160 2161
	netif_carrier_off(dev);

L
Lennert Buytenhek 已提交
2162
	port_start(mp);
2163

2164 2165
	set_rx_coal(mp, 0);
	set_tx_coal(mp, 0);
2166

2167 2168
	wrlp(mp, INT_MASK_EXT, INT_EXT_LINK_PHY | INT_EXT_TX);
	wrlp(mp, INT_MASK, INT_TX_END | INT_RX | INT_EXT);
2169

2170 2171
	return 0;

2172

L
Lennert Buytenhek 已提交
2173
out_free:
2174 2175
	for (i = 0; i < mp->rxq_count; i++)
		rxq_deinit(mp->rxq + i);
L
Lennert Buytenhek 已提交
2176
out:
2177 2178 2179
	free_irq(dev->irq, dev);

	return err;
2180 2181
}

2182
static void port_reset(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2183
{
L
Lennert Buytenhek 已提交
2184
	unsigned int data;
2185
	int i;
L
Linus Torvalds 已提交
2186

2187 2188 2189 2190
	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);
2191 2192

	while (1) {
2193
		u32 ps = rdlp(mp, PORT_STATUS);
2194 2195 2196

		if ((ps & (TX_IN_PROGRESS | TX_FIFO_EMPTY)) == TX_FIFO_EMPTY)
			break;
2197
		udelay(10);
2198
	}
L
Linus Torvalds 已提交
2199

2200
	/* Reset the Enable bit in the Configuration Register */
2201
	data = rdlp(mp, PORT_SERIAL_CONTROL);
L
Lennert Buytenhek 已提交
2202 2203 2204
	data &= ~(SERIAL_PORT_ENABLE		|
		  DO_NOT_FORCE_LINK_FAIL	|
		  FORCE_LINK_PASS);
2205
	wrlp(mp, PORT_SERIAL_CONTROL, data);
L
Linus Torvalds 已提交
2206 2207
}

2208
static int mv643xx_eth_stop(struct net_device *dev)
L
Linus Torvalds 已提交
2209
{
2210
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2211
	int i;
L
Linus Torvalds 已提交
2212

2213 2214
	wrlp(mp, INT_MASK, 0x00000000);
	rdlp(mp, INT_MASK);
L
Linus Torvalds 已提交
2215

2216 2217
	del_timer_sync(&mp->mib_counters_timer);

2218
	napi_disable(&mp->napi);
2219

2220 2221
	del_timer_sync(&mp->rx_oom);

2222
	netif_carrier_off(dev);
L
Linus Torvalds 已提交
2223

L
Lennert Buytenhek 已提交
2224 2225
	free_irq(dev->irq, dev);

2226
	port_reset(mp);
2227
	mv643xx_eth_get_stats(dev);
L
Lennert Buytenhek 已提交
2228
	mib_counters_update(mp);
L
Linus Torvalds 已提交
2229

2230 2231
	skb_queue_purge(&mp->rx_recycle);

2232 2233 2234 2235
	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 已提交
2236

2237
	return 0;
L
Linus Torvalds 已提交
2238 2239
}

L
Lennert Buytenhek 已提交
2240
static int mv643xx_eth_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
L
Linus Torvalds 已提交
2241
{
2242
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
2243

2244 2245
	if (mp->phy != NULL)
		return phy_mii_ioctl(mp->phy, if_mii(ifr), cmd);
2246 2247

	return -EOPNOTSUPP;
L
Linus Torvalds 已提交
2248 2249
}

2250
static int mv643xx_eth_change_mtu(struct net_device *dev, int new_mtu)
L
Linus Torvalds 已提交
2251
{
2252 2253
	struct mv643xx_eth_private *mp = netdev_priv(dev);

L
Lennert Buytenhek 已提交
2254
	if (new_mtu < 64 || new_mtu > 9500)
2255
		return -EINVAL;
L
Linus Torvalds 已提交
2256

2257
	dev->mtu = new_mtu;
2258
	mv643xx_eth_recalc_skb_size(mp);
2259 2260
	tx_set_rate(mp, 1000000000, 16777216);

2261 2262
	if (!netif_running(dev))
		return 0;
L
Linus Torvalds 已提交
2263

2264 2265 2266 2267
	/*
	 * 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 已提交
2268
	 * due to memory being full.
2269 2270 2271
	 */
	mv643xx_eth_stop(dev);
	if (mv643xx_eth_open(dev)) {
L
Lennert Buytenhek 已提交
2272 2273 2274
		dev_printk(KERN_ERR, &dev->dev,
			   "fatal error on re-opening device after "
			   "MTU change\n");
2275 2276 2277
	}

	return 0;
L
Linus Torvalds 已提交
2278 2279
}

L
Lennert Buytenhek 已提交
2280
static void tx_timeout_task(struct work_struct *ugly)
L
Linus Torvalds 已提交
2281
{
L
Lennert Buytenhek 已提交
2282
	struct mv643xx_eth_private *mp;
L
Linus Torvalds 已提交
2283

L
Lennert Buytenhek 已提交
2284 2285
	mp = container_of(ugly, struct mv643xx_eth_private, tx_timeout_task);
	if (netif_running(mp->dev)) {
2286
		netif_tx_stop_all_queues(mp->dev);
L
Lennert Buytenhek 已提交
2287 2288
		port_reset(mp);
		port_start(mp);
2289
		netif_tx_wake_all_queues(mp->dev);
L
Lennert Buytenhek 已提交
2290
	}
2291 2292 2293
}

static void mv643xx_eth_tx_timeout(struct net_device *dev)
L
Linus Torvalds 已提交
2294
{
2295
	struct mv643xx_eth_private *mp = netdev_priv(dev);
L
Linus Torvalds 已提交
2296

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

2299
	schedule_work(&mp->tx_timeout_task);
L
Linus Torvalds 已提交
2300 2301
}

2302
#ifdef CONFIG_NET_POLL_CONTROLLER
L
Lennert Buytenhek 已提交
2303
static void mv643xx_eth_netpoll(struct net_device *dev)
2304
{
L
Lennert Buytenhek 已提交
2305
	struct mv643xx_eth_private *mp = netdev_priv(dev);
2306

2307 2308
	wrlp(mp, INT_MASK, 0x00000000);
	rdlp(mp, INT_MASK);
2309

L
Lennert Buytenhek 已提交
2310
	mv643xx_eth_irq(dev->irq, dev);
2311

2312
	wrlp(mp, INT_MASK, INT_TX_END | INT_RX | INT_EXT);
2313
}
2314
#endif
2315 2316


2317
/* platform glue ************************************************************/
2318 2319 2320
static void
mv643xx_eth_conf_mbus_windows(struct mv643xx_eth_shared_private *msp,
			      struct mbus_dram_target_info *dram)
2321
{
2322
	void __iomem *base = msp->base;
2323 2324 2325
	u32 win_enable;
	u32 win_protect;
	int i;
2326

2327 2328 2329 2330 2331
	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));
2332 2333
	}

2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350
	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;
2351 2352
}

2353 2354 2355 2356 2357 2358 2359
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.
	 */
2360 2361
	writel(0x02000000, msp->base + 0x0400 + SDMA_CONFIG);
	if (readl(msp->base + 0x0400 + SDMA_CONFIG) & 0x02000000)
2362 2363 2364
		msp->extended_rx_coal_limit = 1;
	else
		msp->extended_rx_coal_limit = 0;
2365 2366

	/*
2367 2368 2369
	 * Check whether the MAC supports TX rate control, and if
	 * yes, whether its associated registers are in the old or
	 * the new place.
2370
	 */
2371 2372
	writel(1, msp->base + 0x0400 + TX_BW_MTU_MOVED);
	if (readl(msp->base + 0x0400 + TX_BW_MTU_MOVED) & 1) {
2373 2374
		msp->tx_bw_control = TX_BW_CONTROL_NEW_LAYOUT;
	} else {
2375 2376
		writel(7, msp->base + 0x0400 + TX_BW_RATE);
		if (readl(msp->base + 0x0400 + TX_BW_RATE) & 7)
2377 2378 2379 2380
			msp->tx_bw_control = TX_BW_CONTROL_OLD_LAYOUT;
		else
			msp->tx_bw_control = TX_BW_CONTROL_ABSENT;
	}
2381 2382
}

2383
static int mv643xx_eth_shared_probe(struct platform_device *pdev)
2384
{
L
Lennert Buytenhek 已提交
2385
	static int mv643xx_eth_version_printed;
2386
	struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
2387
	struct mv643xx_eth_shared_private *msp;
2388 2389
	struct resource *res;
	int ret;
2390

2391
	if (!mv643xx_eth_version_printed++)
2392 2393
		printk(KERN_NOTICE "MV-643xx 10/100/1000 ethernet "
			"driver version %s\n", mv643xx_eth_driver_version);
2394

2395 2396 2397 2398
	ret = -EINVAL;
	res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	if (res == NULL)
		goto out;
2399

2400 2401 2402 2403 2404 2405
	ret = -ENOMEM;
	msp = kmalloc(sizeof(*msp), GFP_KERNEL);
	if (msp == NULL)
		goto out;
	memset(msp, 0, sizeof(*msp));

2406 2407
	msp->base = ioremap(res->start, res->end - res->start + 1);
	if (msp->base == NULL)
2408 2409
		goto out_free;

2410 2411 2412 2413
	/*
	 * Set up and register SMI bus.
	 */
	if (pd == NULL || pd->shared_smi == NULL) {
2414 2415
		msp->smi_bus = mdiobus_alloc();
		if (msp->smi_bus == NULL)
2416
			goto out_unmap;
2417 2418 2419 2420 2421 2422 2423 2424 2425 2426

		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;
2427 2428
		msp->smi = msp;
	} else {
2429
		msp->smi = platform_get_drvdata(pd->shared_smi);
2430
	}
2431

2432 2433 2434 2435 2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449
	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;
		}
	}

2450 2451 2452 2453 2454 2455
	/*
	 * (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 已提交
2456 2457 2458 2459
	/*
	 * Detect hardware parameters.
	 */
	msp->t_clk = (pd != NULL && pd->t_clk != 0) ? pd->t_clk : 133000000;
2460
	infer_hw_params(msp);
L
Lennert Buytenhek 已提交
2461 2462 2463

	platform_set_drvdata(pdev, msp);

2464 2465
	return 0;

2466 2467
out_free_mii_bus:
	mdiobus_free(msp->smi_bus);
2468 2469
out_unmap:
	iounmap(msp->base);
2470 2471 2472 2473 2474 2475 2476 2477
out_free:
	kfree(msp);
out:
	return ret;
}

static int mv643xx_eth_shared_remove(struct platform_device *pdev)
{
2478
	struct mv643xx_eth_shared_private *msp = platform_get_drvdata(pdev);
2479
	struct mv643xx_eth_shared_platform_data *pd = pdev->dev.platform_data;
2480

2481 2482
	if (pd == NULL || pd->shared_smi == NULL) {
		mdiobus_unregister(msp->smi_bus);
2483
		mdiobus_free(msp->smi_bus);
2484
	}
2485 2486
	if (msp->err_interrupt != NO_IRQ)
		free_irq(msp->err_interrupt, msp);
2487
	iounmap(msp->base);
2488 2489 2490
	kfree(msp);

	return 0;
2491 2492
}

2493
static struct platform_driver mv643xx_eth_shared_driver = {
L
Lennert Buytenhek 已提交
2494 2495
	.probe		= mv643xx_eth_shared_probe,
	.remove		= mv643xx_eth_shared_remove,
2496
	.driver = {
L
Lennert Buytenhek 已提交
2497
		.name	= MV643XX_ETH_SHARED_NAME,
2498 2499 2500 2501
		.owner	= THIS_MODULE,
	},
};

2502
static void phy_addr_set(struct mv643xx_eth_private *mp, int phy_addr)
L
Linus Torvalds 已提交
2503
{
2504
	int addr_shift = 5 * mp->port_num;
L
Lennert Buytenhek 已提交
2505
	u32 data;
L
Linus Torvalds 已提交
2506

L
Lennert Buytenhek 已提交
2507 2508 2509 2510
	data = rdl(mp, PHY_ADDR);
	data &= ~(0x1f << addr_shift);
	data |= (phy_addr & 0x1f) << addr_shift;
	wrl(mp, PHY_ADDR, data);
L
Linus Torvalds 已提交
2511 2512
}

2513
static int phy_addr_get(struct mv643xx_eth_private *mp)
L
Linus Torvalds 已提交
2514
{
L
Lennert Buytenhek 已提交
2515 2516 2517 2518 2519 2520 2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532 2533 2534 2535 2536
	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 已提交
2537

2538
	mp->rxq_count = pd->rx_queue_count ? : 1;
2539

L
Lennert Buytenhek 已提交
2540 2541 2542 2543 2544
	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;
2545

2546
	mp->txq_count = pd->tx_queue_count ? : 1;
L
Linus Torvalds 已提交
2547 2548
}

2549 2550
static struct phy_device *phy_scan(struct mv643xx_eth_private *mp,
				   int phy_addr)
L
Linus Torvalds 已提交
2551
{
2552
	struct mii_bus *bus = mp->shared->smi->smi_bus;
2553 2554 2555 2556
	struct phy_device *phydev;
	int start;
	int num;
	int i;
2557

2558 2559 2560 2561 2562 2563 2564
	if (phy_addr == MV643XX_ETH_PHY_ADDR_DEFAULT) {
		start = phy_addr_get(mp) & 0x1f;
		num = 32;
	} else {
		start = phy_addr & 0x1f;
		num = 1;
	}
2565

2566 2567 2568
	phydev = NULL;
	for (i = 0; i < num; i++) {
		int addr = (start + i) & 0x1f;
L
Lennert Buytenhek 已提交
2569

2570 2571
		if (bus->phy_map[addr] == NULL)
			mdiobus_scan(bus, addr);
L
Linus Torvalds 已提交
2572

2573 2574 2575 2576 2577 2578
		if (phydev == NULL) {
			phydev = bus->phy_map[addr];
			if (phydev != NULL)
				phy_addr_set(mp, addr);
		}
	}
L
Linus Torvalds 已提交
2579

2580
	return phydev;
L
Linus Torvalds 已提交
2581 2582
}

2583
static void phy_init(struct mv643xx_eth_private *mp, int speed, int duplex)
2584
{
2585
	struct phy_device *phy = mp->phy;
2586

L
Lennert Buytenhek 已提交
2587 2588
	phy_reset(mp);

2589 2590 2591 2592 2593 2594 2595
	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;
2596
	} else {
2597 2598 2599 2600
		phy->autoneg = AUTONEG_DISABLE;
		phy->advertising = 0;
		phy->speed = speed;
		phy->duplex = duplex;
2601
	}
2602
	phy_start_aneg(phy);
2603 2604
}

2605 2606 2607 2608
static void init_pscr(struct mv643xx_eth_private *mp, int speed, int duplex)
{
	u32 pscr;

2609
	pscr = rdlp(mp, PORT_SERIAL_CONTROL);
2610 2611
	if (pscr & SERIAL_PORT_ENABLE) {
		pscr &= ~SERIAL_PORT_ENABLE;
2612
		wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2613 2614 2615
	}

	pscr = MAX_RX_PACKET_9700BYTE | SERIAL_PORT_CONTROL_RESERVED;
2616
	if (mp->phy == NULL) {
2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629
		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;
	}

2630
	wrlp(mp, PORT_SERIAL_CONTROL, pscr);
2631 2632
}

2633
static int mv643xx_eth_probe(struct platform_device *pdev)
L
Linus Torvalds 已提交
2634
{
2635
	struct mv643xx_eth_platform_data *pd;
2636
	struct mv643xx_eth_private *mp;
2637 2638
	struct net_device *dev;
	struct resource *res;
L
Lennert Buytenhek 已提交
2639
	int err;
L
Linus Torvalds 已提交
2640

2641 2642
	pd = pdev->dev.platform_data;
	if (pd == NULL) {
L
Lennert Buytenhek 已提交
2643 2644
		dev_printk(KERN_ERR, &pdev->dev,
			   "no mv643xx_eth_platform_data\n");
2645 2646
		return -ENODEV;
	}
L
Linus Torvalds 已提交
2647

2648
	if (pd->shared == NULL) {
L
Lennert Buytenhek 已提交
2649 2650
		dev_printk(KERN_ERR, &pdev->dev,
			   "no mv643xx_eth_platform_data->shared\n");
2651 2652
		return -ENODEV;
	}
2653

2654
	dev = alloc_etherdev_mq(sizeof(struct mv643xx_eth_private), 8);
2655 2656
	if (!dev)
		return -ENOMEM;
L
Linus Torvalds 已提交
2657

2658
	mp = netdev_priv(dev);
L
Lennert Buytenhek 已提交
2659 2660 2661
	platform_set_drvdata(pdev, mp);

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

2665
	mp->dev = dev;
2666

L
Lennert Buytenhek 已提交
2667
	set_params(mp, pd);
2668
	dev->real_num_tx_queues = mp->txq_count;
L
Lennert Buytenhek 已提交
2669

2670 2671
	if (pd->phy_addr != MV643XX_ETH_PHY_NONE)
		mp->phy = phy_scan(mp, pd->phy_addr);
2672

2673 2674
	if (mp->phy != NULL) {
		phy_init(mp, pd->speed, pd->duplex);
2675 2676 2677 2678
		SET_ETHTOOL_OPS(dev, &mv643xx_eth_ethtool_ops);
	} else {
		SET_ETHTOOL_OPS(dev, &mv643xx_eth_ethtool_ops_phyless);
	}
2679

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

2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694

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

2695 2696 2697 2698 2699 2700
	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 已提交
2701

2702 2703 2704
	res = platform_get_resource(pdev, IORESOURCE_IRQ, 0);
	BUG_ON(!res);
	dev->irq = res->start;
L
Linus Torvalds 已提交
2705

2706
	dev->get_stats = mv643xx_eth_get_stats;
L
Lennert Buytenhek 已提交
2707
	dev->hard_start_xmit = mv643xx_eth_xmit;
2708 2709
	dev->open = mv643xx_eth_open;
	dev->stop = mv643xx_eth_stop;
2710
	dev->set_rx_mode = mv643xx_eth_set_rx_mode;
L
Lennert Buytenhek 已提交
2711 2712 2713
	dev->set_mac_address = mv643xx_eth_set_mac_address;
	dev->do_ioctl = mv643xx_eth_ioctl;
	dev->change_mtu = mv643xx_eth_change_mtu;
2714 2715
	dev->tx_timeout = mv643xx_eth_tx_timeout;
#ifdef CONFIG_NET_POLL_CONTROLLER
2716
	dev->poll_controller = mv643xx_eth_netpoll;
2717 2718 2719
#endif
	dev->watchdog_timeo = 2 * HZ;
	dev->base_addr = 0;
L
Linus Torvalds 已提交
2720

2721
	dev->features = NETIF_F_SG | NETIF_F_IP_CSUM;
2722
	dev->vlan_features = NETIF_F_SG | NETIF_F_IP_CSUM;
L
Linus Torvalds 已提交
2723

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

2726
	if (mp->shared->win_protect)
L
Lennert Buytenhek 已提交
2727
		wrl(mp, WINDOW_PROTECT(mp->port_num), mp->shared->win_protect);
L
Linus Torvalds 已提交
2728

2729 2730 2731
	err = register_netdev(dev);
	if (err)
		goto out;
L
Linus Torvalds 已提交
2732

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

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

2739
	return 0;
L
Linus Torvalds 已提交
2740

2741 2742
out:
	free_netdev(dev);
L
Linus Torvalds 已提交
2743

2744
	return err;
L
Linus Torvalds 已提交
2745 2746
}

2747
static int mv643xx_eth_remove(struct platform_device *pdev)
L
Linus Torvalds 已提交
2748
{
L
Lennert Buytenhek 已提交
2749
	struct mv643xx_eth_private *mp = platform_get_drvdata(pdev);
L
Linus Torvalds 已提交
2750

L
Lennert Buytenhek 已提交
2751
	unregister_netdev(mp->dev);
2752 2753
	if (mp->phy != NULL)
		phy_detach(mp->phy);
2754
	flush_scheduled_work();
L
Lennert Buytenhek 已提交
2755
	free_netdev(mp->dev);
2756 2757

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

2759
	return 0;
L
Linus Torvalds 已提交
2760 2761
}

2762
static void mv643xx_eth_shutdown(struct platform_device *pdev)
2763
{
L
Lennert Buytenhek 已提交
2764
	struct mv643xx_eth_private *mp = platform_get_drvdata(pdev);
2765

2766
	/* Mask all interrupts on ethernet port */
2767 2768
	wrlp(mp, INT_MASK, 0);
	rdlp(mp, INT_MASK);
2769

L
Lennert Buytenhek 已提交
2770 2771
	if (netif_running(mp->dev))
		port_reset(mp);
2772 2773
}

2774
static struct platform_driver mv643xx_eth_driver = {
L
Lennert Buytenhek 已提交
2775 2776 2777
	.probe		= mv643xx_eth_probe,
	.remove		= mv643xx_eth_remove,
	.shutdown	= mv643xx_eth_shutdown,
2778
	.driver = {
L
Lennert Buytenhek 已提交
2779
		.name	= MV643XX_ETH_NAME,
2780 2781 2782 2783
		.owner	= THIS_MODULE,
	},
};

2784
static int __init mv643xx_eth_init_module(void)
2785
{
2786
	int rc;
2787

2788 2789 2790 2791 2792 2793
	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 已提交
2794

2795
	return rc;
2796
}
L
Lennert Buytenhek 已提交
2797
module_init(mv643xx_eth_init_module);
2798

2799
static void __exit mv643xx_eth_cleanup_module(void)
2800
{
2801 2802
	platform_driver_unregister(&mv643xx_eth_driver);
	platform_driver_unregister(&mv643xx_eth_shared_driver);
2803
}
2804
module_exit(mv643xx_eth_cleanup_module);
L
Linus Torvalds 已提交
2805

2806 2807
MODULE_AUTHOR("Rabeeh Khoury, Assaf Hoffman, Matthew Dharm, "
	      "Manish Lachwani, Dale Farnsworth and Lennert Buytenhek");
2808
MODULE_DESCRIPTION("Ethernet driver for Marvell MV643XX");
L
Lennert Buytenhek 已提交
2809
MODULE_LICENSE("GPL");
2810
MODULE_ALIAS("platform:" MV643XX_ETH_SHARED_NAME);
L
Lennert Buytenhek 已提交
2811
MODULE_ALIAS("platform:" MV643XX_ETH_NAME);