ep93xx_eth.c 20 KB
Newer Older
1
// SPDX-License-Identifier: GPL-2.0-or-later
2
3
4
5
6
7
/*
 * EP93xx ethernet network device driver
 * Copyright (C) 2006 Lennert Buytenhek <buytenh@wantstofly.org>
 * Dedicated to Marija Kulikova.
 */

8
9
#define pr_fmt(fmt) KBUILD_MODNAME ":%s: " fmt, __func__

10
11
12
13
14
15
16
#include <linux/dma-mapping.h>
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/netdevice.h>
#include <linux/mii.h>
#include <linux/etherdevice.h>
#include <linux/ethtool.h>
17
#include <linux/interrupt.h>
18
19
20
#include <linux/moduleparam.h>
#include <linux/platform_device.h>
#include <linux/delay.h>
21
#include <linux/io.h>
22
#include <linux/slab.h>
23

24
#include <linux/platform_data/eth-ep93xx.h>
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154

#define DRV_MODULE_NAME		"ep93xx-eth"
#define DRV_MODULE_VERSION	"0.1"

#define RX_QUEUE_ENTRIES	64
#define TX_QUEUE_ENTRIES	8

#define MAX_PKT_SIZE		2044
#define PKT_BUF_SIZE		2048

#define REG_RXCTL		0x0000
#define  REG_RXCTL_DEFAULT	0x00073800
#define REG_TXCTL		0x0004
#define  REG_TXCTL_ENABLE	0x00000001
#define REG_MIICMD		0x0010
#define  REG_MIICMD_READ	0x00008000
#define  REG_MIICMD_WRITE	0x00004000
#define REG_MIIDATA		0x0014
#define REG_MIISTS		0x0018
#define  REG_MIISTS_BUSY	0x00000001
#define REG_SELFCTL		0x0020
#define  REG_SELFCTL_RESET	0x00000001
#define REG_INTEN		0x0024
#define  REG_INTEN_TX		0x00000008
#define  REG_INTEN_RX		0x00000007
#define REG_INTSTSP		0x0028
#define  REG_INTSTS_TX		0x00000008
#define  REG_INTSTS_RX		0x00000004
#define REG_INTSTSC		0x002c
#define REG_AFP			0x004c
#define REG_INDAD0		0x0050
#define REG_INDAD1		0x0051
#define REG_INDAD2		0x0052
#define REG_INDAD3		0x0053
#define REG_INDAD4		0x0054
#define REG_INDAD5		0x0055
#define REG_GIINTMSK		0x0064
#define  REG_GIINTMSK_ENABLE	0x00008000
#define REG_BMCTL		0x0080
#define  REG_BMCTL_ENABLE_TX	0x00000100
#define  REG_BMCTL_ENABLE_RX	0x00000001
#define REG_BMSTS		0x0084
#define  REG_BMSTS_RX_ACTIVE	0x00000008
#define REG_RXDQBADD		0x0090
#define REG_RXDQBLEN		0x0094
#define REG_RXDCURADD		0x0098
#define REG_RXDENQ		0x009c
#define REG_RXSTSQBADD		0x00a0
#define REG_RXSTSQBLEN		0x00a4
#define REG_RXSTSQCURADD	0x00a8
#define REG_RXSTSENQ		0x00ac
#define REG_TXDQBADD		0x00b0
#define REG_TXDQBLEN		0x00b4
#define REG_TXDQCURADD		0x00b8
#define REG_TXDENQ		0x00bc
#define REG_TXSTSQBADD		0x00c0
#define REG_TXSTSQBLEN		0x00c4
#define REG_TXSTSQCURADD	0x00c8
#define REG_MAXFRMLEN		0x00e8

struct ep93xx_rdesc
{
	u32	buf_addr;
	u32	rdesc1;
};

#define RDESC1_NSOF		0x80000000
#define RDESC1_BUFFER_INDEX	0x7fff0000
#define RDESC1_BUFFER_LENGTH	0x0000ffff

struct ep93xx_rstat
{
	u32	rstat0;
	u32	rstat1;
};

#define RSTAT0_RFP		0x80000000
#define RSTAT0_RWE		0x40000000
#define RSTAT0_EOF		0x20000000
#define RSTAT0_EOB		0x10000000
#define RSTAT0_AM		0x00c00000
#define RSTAT0_RX_ERR		0x00200000
#define RSTAT0_OE		0x00100000
#define RSTAT0_FE		0x00080000
#define RSTAT0_RUNT		0x00040000
#define RSTAT0_EDATA		0x00020000
#define RSTAT0_CRCE		0x00010000
#define RSTAT0_CRCI		0x00008000
#define RSTAT0_HTI		0x00003f00
#define RSTAT1_RFP		0x80000000
#define RSTAT1_BUFFER_INDEX	0x7fff0000
#define RSTAT1_FRAME_LENGTH	0x0000ffff

struct ep93xx_tdesc
{
	u32	buf_addr;
	u32	tdesc1;
};

#define TDESC1_EOF		0x80000000
#define TDESC1_BUFFER_INDEX	0x7fff0000
#define TDESC1_BUFFER_ABORT	0x00008000
#define TDESC1_BUFFER_LENGTH	0x00000fff

struct ep93xx_tstat
{
	u32	tstat0;
};

#define TSTAT0_TXFP		0x80000000
#define TSTAT0_TXWE		0x40000000
#define TSTAT0_FA		0x20000000
#define TSTAT0_LCRS		0x10000000
#define TSTAT0_OW		0x04000000
#define TSTAT0_TXU		0x02000000
#define TSTAT0_ECOLL		0x01000000
#define TSTAT0_NCOLL		0x001f0000
#define TSTAT0_BUFFER_INDEX	0x00007fff

struct ep93xx_descs
{
	struct ep93xx_rdesc	rdesc[RX_QUEUE_ENTRIES];
	struct ep93xx_tdesc	tdesc[TX_QUEUE_ENTRIES];
	struct ep93xx_rstat	rstat[RX_QUEUE_ENTRIES];
	struct ep93xx_tstat	tstat[TX_QUEUE_ENTRIES];
};

struct ep93xx_priv
{
	struct resource		*res;
155
	void __iomem		*base_addr;
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
	int			irq;

	struct ep93xx_descs	*descs;
	dma_addr_t		descs_dma_addr;

	void			*rx_buf[RX_QUEUE_ENTRIES];
	void			*tx_buf[TX_QUEUE_ENTRIES];

	spinlock_t		rx_lock;
	unsigned int		rx_pointer;
	unsigned int		tx_clean_pointer;
	unsigned int		tx_pointer;
	spinlock_t		tx_pending_lock;
	unsigned int		tx_pending;

171
172
173
	struct net_device	*dev;
	struct napi_struct	napi;

174
175
176
177
178
179
180
181
182
183
184
	struct mii_if_info	mii;
	u8			mdc_divisor;
};

#define rdb(ep, off)		__raw_readb((ep)->base_addr + (off))
#define rdw(ep, off)		__raw_readw((ep)->base_addr + (off))
#define rdl(ep, off)		__raw_readl((ep)->base_addr + (off))
#define wrb(ep, off, val)	__raw_writeb((val), (ep)->base_addr + (off))
#define wrw(ep, off, val)	__raw_writew((val), (ep)->base_addr + (off))
#define wrl(ep, off, val)	__raw_writel((val), (ep)->base_addr + (off))

185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
static int ep93xx_mdio_read(struct net_device *dev, int phy_id, int reg)
{
	struct ep93xx_priv *ep = netdev_priv(dev);
	int data;
	int i;

	wrl(ep, REG_MIICMD, REG_MIICMD_READ | (phy_id << 5) | reg);

	for (i = 0; i < 10; i++) {
		if ((rdl(ep, REG_MIISTS) & REG_MIISTS_BUSY) == 0)
			break;
		msleep(1);
	}

	if (i == 10) {
		pr_info("mdio read timed out\n");
		data = 0xffff;
	} else {
		data = rdl(ep, REG_MIIDATA);
	}

	return data;
}

static void ep93xx_mdio_write(struct net_device *dev, int phy_id, int reg, int data)
{
	struct ep93xx_priv *ep = netdev_priv(dev);
	int i;

	wrl(ep, REG_MIIDATA, data);
	wrl(ep, REG_MIICMD, REG_MIICMD_WRITE | (phy_id << 5) | reg);

	for (i = 0; i < 10; i++) {
		if ((rdl(ep, REG_MIISTS) & REG_MIISTS_BUSY) == 0)
			break;
		msleep(1);
	}

	if (i == 10)
		pr_info("mdio write timed out\n");
}
226

Eric Dumazet's avatar
Eric Dumazet committed
227
static int ep93xx_rx(struct net_device *dev, int budget)
228
229
{
	struct ep93xx_priv *ep = netdev_priv(dev);
Eric Dumazet's avatar
Eric Dumazet committed
230
	int processed = 0;
231

232
	while (processed < budget) {
233
234
235
236
237
238
239
240
241
		int entry;
		struct ep93xx_rstat *rstat;
		u32 rstat0;
		u32 rstat1;
		int length;
		struct sk_buff *skb;

		entry = ep->rx_pointer;
		rstat = ep->descs->rstat + entry;
242
243
244

		rstat0 = rstat->rstat0;
		rstat1 = rstat->rstat1;
245
		if (!(rstat0 & RSTAT0_RFP) || !(rstat1 & RSTAT1_RFP))
246
247
248
249
250
251
			break;

		rstat->rstat0 = 0;
		rstat->rstat1 = 0;

		if (!(rstat0 & RSTAT0_EOF))
252
			pr_crit("not end-of-frame %.8x %.8x\n", rstat0, rstat1);
253
		if (!(rstat0 & RSTAT0_EOB))
254
			pr_crit("not end-of-buffer %.8x %.8x\n", rstat0, rstat1);
255
		if ((rstat1 & RSTAT1_BUFFER_INDEX) >> 16 != entry)
256
			pr_crit("entry mismatch %.8x %.8x\n", rstat0, rstat1);
257
258

		if (!(rstat0 & RSTAT0_RWE)) {
259
			dev->stats.rx_errors++;
260
			if (rstat0 & RSTAT0_OE)
261
				dev->stats.rx_fifo_errors++;
262
			if (rstat0 & RSTAT0_FE)
263
				dev->stats.rx_frame_errors++;
264
			if (rstat0 & (RSTAT0_RUNT | RSTAT0_EDATA))
265
				dev->stats.rx_length_errors++;
266
			if (rstat0 & RSTAT0_CRCE)
267
				dev->stats.rx_crc_errors++;
268
269
270
271
272
			goto err;
		}

		length = rstat1 & RSTAT1_FRAME_LENGTH;
		if (length > MAX_PKT_SIZE) {
273
			pr_notice("invalid length %.8x %.8x\n", rstat0, rstat1);
274
275
276
277
278
279
280
			goto err;
		}

		/* Strip FCS.  */
		if (rstat0 & RSTAT0_CRCI)
			length -= 4;

281
		skb = netdev_alloc_skb(dev, length + 2);
282
		if (likely(skb != NULL)) {
283
			struct ep93xx_rdesc *rxd = &ep->descs->rdesc[entry];
284
			skb_reserve(skb, 2);
285
			dma_sync_single_for_cpu(dev->dev.parent, rxd->buf_addr,
286
						length, DMA_FROM_DEVICE);
287
			skb_copy_to_linear_data(skb, ep->rx_buf[entry], length);
288
289
290
			dma_sync_single_for_device(dev->dev.parent,
						   rxd->buf_addr, length,
						   DMA_FROM_DEVICE);
291
292
293
			skb_put(skb, length);
			skb->protocol = eth_type_trans(skb, dev);

Eric Dumazet's avatar
Eric Dumazet committed
294
			napi_gro_receive(&ep->napi, skb);
295

296
297
			dev->stats.rx_packets++;
			dev->stats.rx_bytes += length;
298
		} else {
299
			dev->stats.rx_dropped++;
300
301
302
303
304
305
306
		}

err:
		ep->rx_pointer = (entry + 1) & (RX_QUEUE_ENTRIES - 1);
		processed++;
	}

307
	return processed;
308
309
}

310
static int ep93xx_poll(struct napi_struct *napi, int budget)
311
{
312
313
	struct ep93xx_priv *ep = container_of(napi, struct ep93xx_priv, napi);
	struct net_device *dev = ep->dev;
Eric Dumazet's avatar
Eric Dumazet committed
314
	int rx;
315

Eric Dumazet's avatar
Eric Dumazet committed
316
317
	rx = ep93xx_rx(dev, budget);
	if (rx < budget && napi_complete_done(napi, rx)) {
318
319
		spin_lock_irq(&ep->rx_lock);
		wrl(ep, REG_INTEN, REG_INTEN_TX | REG_INTEN_RX);
320
321
322
		spin_unlock_irq(&ep->rx_lock);
	}

323
324
325
326
327
	if (rx) {
		wrw(ep, REG_RXDENQ, rx);
		wrw(ep, REG_RXSTSENQ, rx);
	}

328
	return rx;
329
330
}

331
static netdev_tx_t ep93xx_xmit(struct sk_buff *skb, struct net_device *dev)
332
333
{
	struct ep93xx_priv *ep = netdev_priv(dev);
334
	struct ep93xx_tdesc *txd;
335
336
	int entry;

337
	if (unlikely(skb->len > MAX_PKT_SIZE)) {
338
		dev->stats.tx_dropped++;
339
340
341
342
343
344
345
		dev_kfree_skb(skb);
		return NETDEV_TX_OK;
	}

	entry = ep->tx_pointer;
	ep->tx_pointer = (ep->tx_pointer + 1) & (TX_QUEUE_ENTRIES - 1);

346
347
348
349
350
	txd = &ep->descs->tdesc[entry];

	txd->tdesc1 = TDESC1_EOF | (entry << 16) | (skb->len & 0xfff);
	dma_sync_single_for_cpu(dev->dev.parent, txd->buf_addr, skb->len,
				DMA_TO_DEVICE);
351
	skb_copy_and_csum_dev(skb, ep->tx_buf[entry]);
352
353
	dma_sync_single_for_device(dev->dev.parent, txd->buf_addr, skb->len,
				   DMA_TO_DEVICE);
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
	dev_kfree_skb(skb);

	spin_lock_irq(&ep->tx_pending_lock);
	ep->tx_pending++;
	if (ep->tx_pending == TX_QUEUE_ENTRIES)
		netif_stop_queue(dev);
	spin_unlock_irq(&ep->tx_pending_lock);

	wrl(ep, REG_TXDENQ, 1);

	return NETDEV_TX_OK;
}

static void ep93xx_tx_complete(struct net_device *dev)
{
	struct ep93xx_priv *ep = netdev_priv(dev);
	int wake;

	wake = 0;

	spin_lock(&ep->tx_pending_lock);
	while (1) {
		int entry;
		struct ep93xx_tstat *tstat;
		u32 tstat0;

		entry = ep->tx_clean_pointer;
		tstat = ep->descs->tstat + entry;

		tstat0 = tstat->tstat0;
384
385
386
		if (!(tstat0 & TSTAT0_TXFP))
			break;

387
388
389
		tstat->tstat0 = 0;

		if (tstat0 & TSTAT0_FA)
390
			pr_crit("frame aborted %.8x\n", tstat0);
391
		if ((tstat0 & TSTAT0_BUFFER_INDEX) != entry)
392
			pr_crit("entry mismatch %.8x\n", tstat0);
393
394
395
396

		if (tstat0 & TSTAT0_TXWE) {
			int length = ep->descs->tdesc[entry].tdesc1 & 0xfff;

397
398
			dev->stats.tx_packets++;
			dev->stats.tx_bytes += length;
399
		} else {
400
			dev->stats.tx_errors++;
401
402
403
		}

		if (tstat0 & TSTAT0_OW)
404
			dev->stats.tx_window_errors++;
405
		if (tstat0 & TSTAT0_TXU)
406
407
			dev->stats.tx_fifo_errors++;
		dev->stats.collisions += (tstat0 >> 16) & 0x1f;
408
409
410
411
412
413
414
415
416
417
418
419

		ep->tx_clean_pointer = (entry + 1) & (TX_QUEUE_ENTRIES - 1);
		if (ep->tx_pending == TX_QUEUE_ENTRIES)
			wake = 1;
		ep->tx_pending--;
	}
	spin_unlock(&ep->tx_pending_lock);

	if (wake)
		netif_wake_queue(dev);
}

420
static irqreturn_t ep93xx_irq(int irq, void *dev_id)
421
422
423
424
425
426
427
428
429
430
431
{
	struct net_device *dev = dev_id;
	struct ep93xx_priv *ep = netdev_priv(dev);
	u32 status;

	status = rdl(ep, REG_INTSTSC);
	if (status == 0)
		return IRQ_NONE;

	if (status & REG_INTSTS_RX) {
		spin_lock(&ep->rx_lock);
432
		if (likely(napi_schedule_prep(&ep->napi))) {
433
			wrl(ep, REG_INTEN, REG_INTEN_TX);
434
			__napi_schedule(&ep->napi);
435
436
437
438
439
440
441
442
443
444
445
446
		}
		spin_unlock(&ep->rx_lock);
	}

	if (status & REG_INTSTS_TX)
		ep93xx_tx_complete(dev);

	return IRQ_HANDLED;
}

static void ep93xx_free_buffers(struct ep93xx_priv *ep)
{
447
	struct device *dev = ep->dev->dev.parent;
448
449
	int i;

450
451
452
	if (!ep->descs)
		return;

453
	for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
454
455
456
457
		dma_addr_t d;

		d = ep->descs->rdesc[i].buf_addr;
		if (d)
458
			dma_unmap_single(dev, d, PKT_BUF_SIZE, DMA_FROM_DEVICE);
459

460
		kfree(ep->rx_buf[i]);
461
462
	}

463
	for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
464
465
466
467
		dma_addr_t d;

		d = ep->descs->tdesc[i].buf_addr;
		if (d)
468
			dma_unmap_single(dev, d, PKT_BUF_SIZE, DMA_TO_DEVICE);
469

470
		kfree(ep->tx_buf[i]);
471
472
	}

473
	dma_free_coherent(dev, sizeof(struct ep93xx_descs), ep->descs,
474
							ep->descs_dma_addr);
475
	ep->descs = NULL;
476
477
478
479
}

static int ep93xx_alloc_buffers(struct ep93xx_priv *ep)
{
480
	struct device *dev = ep->dev->dev.parent;
481
482
	int i;

483
	ep->descs = dma_alloc_coherent(dev, sizeof(struct ep93xx_descs),
484
				&ep->descs_dma_addr, GFP_KERNEL);
485
486
487
	if (ep->descs == NULL)
		return 1;

488
489
	for (i = 0; i < RX_QUEUE_ENTRIES; i++) {
		void *buf;
490
491
		dma_addr_t d;

492
493
		buf = kmalloc(PKT_BUF_SIZE, GFP_KERNEL);
		if (buf == NULL)
494
495
			goto err;

496
		d = dma_map_single(dev, buf, PKT_BUF_SIZE, DMA_FROM_DEVICE);
497
		if (dma_mapping_error(dev, d)) {
498
			kfree(buf);
499
500
501
			goto err;
		}

502
		ep->rx_buf[i] = buf;
503
504
505
506
		ep->descs->rdesc[i].buf_addr = d;
		ep->descs->rdesc[i].rdesc1 = (i << 16) | PKT_BUF_SIZE;
	}

507
508
	for (i = 0; i < TX_QUEUE_ENTRIES; i++) {
		void *buf;
509
510
		dma_addr_t d;

511
512
		buf = kmalloc(PKT_BUF_SIZE, GFP_KERNEL);
		if (buf == NULL)
513
514
			goto err;

515
		d = dma_map_single(dev, buf, PKT_BUF_SIZE, DMA_TO_DEVICE);
516
		if (dma_mapping_error(dev, d)) {
517
			kfree(buf);
518
519
520
			goto err;
		}

521
		ep->tx_buf[i] = buf;
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
		ep->descs->tdesc[i].buf_addr = d;
	}

	return 0;

err:
	ep93xx_free_buffers(ep);
	return 1;
}

static int ep93xx_start_hw(struct net_device *dev)
{
	struct ep93xx_priv *ep = netdev_priv(dev);
	unsigned long addr;
	int i;

	wrl(ep, REG_SELFCTL, REG_SELFCTL_RESET);
	for (i = 0; i < 10; i++) {
		if ((rdl(ep, REG_SELFCTL) & REG_SELFCTL_RESET) == 0)
			break;
		msleep(1);
	}

	if (i == 10) {
546
		pr_crit("hw failed to reset\n");
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
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
		return 1;
	}

	wrl(ep, REG_SELFCTL, ((ep->mdc_divisor - 1) << 9));

	/* Does the PHY support preamble suppress?  */
	if ((ep93xx_mdio_read(dev, ep->mii.phy_id, MII_BMSR) & 0x0040) != 0)
		wrl(ep, REG_SELFCTL, ((ep->mdc_divisor - 1) << 9) | (1 << 8));

	/* Receive descriptor ring.  */
	addr = ep->descs_dma_addr + offsetof(struct ep93xx_descs, rdesc);
	wrl(ep, REG_RXDQBADD, addr);
	wrl(ep, REG_RXDCURADD, addr);
	wrw(ep, REG_RXDQBLEN, RX_QUEUE_ENTRIES * sizeof(struct ep93xx_rdesc));

	/* Receive status ring.  */
	addr = ep->descs_dma_addr + offsetof(struct ep93xx_descs, rstat);
	wrl(ep, REG_RXSTSQBADD, addr);
	wrl(ep, REG_RXSTSQCURADD, addr);
	wrw(ep, REG_RXSTSQBLEN, RX_QUEUE_ENTRIES * sizeof(struct ep93xx_rstat));

	/* Transmit descriptor ring.  */
	addr = ep->descs_dma_addr + offsetof(struct ep93xx_descs, tdesc);
	wrl(ep, REG_TXDQBADD, addr);
	wrl(ep, REG_TXDQCURADD, addr);
	wrw(ep, REG_TXDQBLEN, TX_QUEUE_ENTRIES * sizeof(struct ep93xx_tdesc));

	/* Transmit status ring.  */
	addr = ep->descs_dma_addr + offsetof(struct ep93xx_descs, tstat);
	wrl(ep, REG_TXSTSQBADD, addr);
	wrl(ep, REG_TXSTSQCURADD, addr);
	wrw(ep, REG_TXSTSQBLEN, TX_QUEUE_ENTRIES * sizeof(struct ep93xx_tstat));

	wrl(ep, REG_BMCTL, REG_BMCTL_ENABLE_TX | REG_BMCTL_ENABLE_RX);
	wrl(ep, REG_INTEN, REG_INTEN_TX | REG_INTEN_RX);
	wrl(ep, REG_GIINTMSK, 0);

	for (i = 0; i < 10; i++) {
		if ((rdl(ep, REG_BMSTS) & REG_BMSTS_RX_ACTIVE) != 0)
			break;
		msleep(1);
	}

	if (i == 10) {
591
		pr_crit("hw failed to start\n");
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
		return 1;
	}

	wrl(ep, REG_RXDENQ, RX_QUEUE_ENTRIES);
	wrl(ep, REG_RXSTSENQ, RX_QUEUE_ENTRIES);

	wrb(ep, REG_INDAD0, dev->dev_addr[0]);
	wrb(ep, REG_INDAD1, dev->dev_addr[1]);
	wrb(ep, REG_INDAD2, dev->dev_addr[2]);
	wrb(ep, REG_INDAD3, dev->dev_addr[3]);
	wrb(ep, REG_INDAD4, dev->dev_addr[4]);
	wrb(ep, REG_INDAD5, dev->dev_addr[5]);
	wrl(ep, REG_AFP, 0);

	wrl(ep, REG_MAXFRMLEN, (MAX_PKT_SIZE << 16) | MAX_PKT_SIZE);

	wrl(ep, REG_RXCTL, REG_RXCTL_DEFAULT);
	wrl(ep, REG_TXCTL, REG_TXCTL_ENABLE);

	return 0;
}

static void ep93xx_stop_hw(struct net_device *dev)
{
	struct ep93xx_priv *ep = netdev_priv(dev);
	int i;

	wrl(ep, REG_SELFCTL, REG_SELFCTL_RESET);
	for (i = 0; i < 10; i++) {
		if ((rdl(ep, REG_SELFCTL) & REG_SELFCTL_RESET) == 0)
			break;
		msleep(1);
	}

	if (i == 10)
627
		pr_crit("hw failed to reset\n");
628
629
630
631
632
633
634
635
636
637
}

static int ep93xx_open(struct net_device *dev)
{
	struct ep93xx_priv *ep = netdev_priv(dev);
	int err;

	if (ep93xx_alloc_buffers(ep))
		return -ENOMEM;

638
639
	napi_enable(&ep->napi);

640
	if (ep93xx_start_hw(dev)) {
641
		napi_disable(&ep->napi);
642
643
644
645
646
647
648
649
650
651
652
653
654
		ep93xx_free_buffers(ep);
		return -EIO;
	}

	spin_lock_init(&ep->rx_lock);
	ep->rx_pointer = 0;
	ep->tx_clean_pointer = 0;
	ep->tx_pointer = 0;
	spin_lock_init(&ep->tx_pending_lock);
	ep->tx_pending = 0;

	err = request_irq(ep->irq, ep93xx_irq, IRQF_SHARED, dev->name, dev);
	if (err) {
655
		napi_disable(&ep->napi);
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
		ep93xx_stop_hw(dev);
		ep93xx_free_buffers(ep);
		return err;
	}

	wrl(ep, REG_GIINTMSK, REG_GIINTMSK_ENABLE);

	netif_start_queue(dev);

	return 0;
}

static int ep93xx_close(struct net_device *dev)
{
	struct ep93xx_priv *ep = netdev_priv(dev);

672
	napi_disable(&ep->napi);
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
	netif_stop_queue(dev);

	wrl(ep, REG_GIINTMSK, 0);
	free_irq(ep->irq, dev);
	ep93xx_stop_hw(dev);
	ep93xx_free_buffers(ep);

	return 0;
}

static int ep93xx_ioctl(struct net_device *dev, struct ifreq *ifr, int cmd)
{
	struct ep93xx_priv *ep = netdev_priv(dev);
	struct mii_ioctl_data *data = if_mii(ifr);

	return generic_mii_ioctl(&ep->mii, data, cmd, NULL);
}

static void ep93xx_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
{
693
694
	strlcpy(info->driver, DRV_MODULE_NAME, sizeof(info->driver));
	strlcpy(info->version, DRV_MODULE_VERSION, sizeof(info->version));
695
696
}

697
698
static int ep93xx_get_link_ksettings(struct net_device *dev,
				     struct ethtool_link_ksettings *cmd)
699
700
{
	struct ep93xx_priv *ep = netdev_priv(dev);
701
702
703
704

	mii_ethtool_get_link_ksettings(&ep->mii, cmd);

	return 0;
705
706
}

707
708
static int ep93xx_set_link_ksettings(struct net_device *dev,
				     const struct ethtool_link_ksettings *cmd)
709
710
{
	struct ep93xx_priv *ep = netdev_priv(dev);
711
	return mii_ethtool_set_link_ksettings(&ep->mii, cmd);
712
713
714
715
716
717
718
719
720
721
722
723
724
725
}

static int ep93xx_nway_reset(struct net_device *dev)
{
	struct ep93xx_priv *ep = netdev_priv(dev);
	return mii_nway_restart(&ep->mii);
}

static u32 ep93xx_get_link(struct net_device *dev)
{
	struct ep93xx_priv *ep = netdev_priv(dev);
	return mii_link_ok(&ep->mii);
}

726
static const struct ethtool_ops ep93xx_ethtool_ops = {
727
728
729
	.get_drvinfo		= ep93xx_get_drvinfo,
	.nway_reset		= ep93xx_nway_reset,
	.get_link		= ep93xx_get_link,
730
731
	.get_link_ksettings	= ep93xx_get_link_ksettings,
	.set_link_ksettings	= ep93xx_set_link_ksettings,
732
733
};

734
735
736
737
738
739
740
741
742
743
static const struct net_device_ops ep93xx_netdev_ops = {
	.ndo_open		= ep93xx_open,
	.ndo_stop		= ep93xx_close,
	.ndo_start_xmit		= ep93xx_xmit,
	.ndo_do_ioctl		= ep93xx_ioctl,
	.ndo_validate_addr	= eth_validate_addr,
	.ndo_set_mac_address	= eth_mac_addr,
};

static struct net_device *ep93xx_dev_alloc(struct ep93xx_eth_data *data)
744
745
746
747
748
749
750
751
752
753
{
	struct net_device *dev;

	dev = alloc_etherdev(sizeof(struct ep93xx_priv));
	if (dev == NULL)
		return NULL;

	memcpy(dev->dev_addr, data->dev_addr, ETH_ALEN);

	dev->ethtool_ops = &ep93xx_ethtool_ops;
754
	dev->netdev_ops = &ep93xx_netdev_ops;
755
756
757
758
759
760
761
762
763
764
765

	dev->features |= NETIF_F_SG | NETIF_F_HW_CSUM;

	return dev;
}


static int ep93xx_eth_remove(struct platform_device *pdev)
{
	struct net_device *dev;
	struct ep93xx_priv *ep;
766
	struct resource *mem;
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781

	dev = platform_get_drvdata(pdev);
	if (dev == NULL)
		return 0;

	ep = netdev_priv(dev);

	/* @@@ Force down.  */
	unregister_netdev(dev);
	ep93xx_free_buffers(ep);

	if (ep->base_addr != NULL)
		iounmap(ep->base_addr);

	if (ep->res != NULL) {
782
783
		mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
		release_mem_region(mem->start, resource_size(mem));
784
785
786
787
788
789
790
791
792
793
794
795
	}

	free_netdev(dev);

	return 0;
}

static int ep93xx_eth_probe(struct platform_device *pdev)
{
	struct ep93xx_eth_data *data;
	struct net_device *dev;
	struct ep93xx_priv *ep;
796
797
	struct resource *mem;
	int irq;
798
799
800
801
	int err;

	if (pdev == NULL)
		return -ENODEV;
802
	data = dev_get_platdata(&pdev->dev);
803

804
805
806
807
808
	mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
	irq = platform_get_irq(pdev, 0);
	if (!mem || irq < 0)
		return -ENXIO;

809
810
811
812
813
814
	dev = ep93xx_dev_alloc(data);
	if (dev == NULL) {
		err = -ENOMEM;
		goto err_out;
	}
	ep = netdev_priv(dev);
815
	ep->dev = dev;
816
	SET_NETDEV_DEV(dev, &pdev->dev);
817
	netif_napi_add(dev, &ep->napi, ep93xx_poll, 64);
818
819
820

	platform_set_drvdata(pdev, dev);

821
822
	ep->res = request_mem_region(mem->start, resource_size(mem),
				     dev_name(&pdev->dev));
823
824
825
826
827
828
	if (ep->res == NULL) {
		dev_err(&pdev->dev, "Could not reserve memory region\n");
		err = -ENOMEM;
		goto err_out;
	}

829
	ep->base_addr = ioremap(mem->start, resource_size(mem));
830
831
832
833
834
	if (ep->base_addr == NULL) {
		dev_err(&pdev->dev, "Failed to ioremap ethernet registers\n");
		err = -EIO;
		goto err_out;
	}
835
	ep->irq = irq;
836
837
838
839
840
841
842
843
844

	ep->mii.phy_id = data->phy_id;
	ep->mii.phy_id_mask = 0x1f;
	ep->mii.reg_num_mask = 0x1f;
	ep->mii.dev = dev;
	ep->mii.mdio_read = ep93xx_mdio_read;
	ep->mii.mdio_write = ep93xx_mdio_write;
	ep->mdc_divisor = 40;	/* Max HCLK 100 MHz, min MDIO clk 2.5 MHz.  */

845
	if (is_zero_ether_addr(dev->dev_addr))
846
		eth_hw_addr_random(dev);
847

848
849
850
851
852
853
	err = register_netdev(dev);
	if (err) {
		dev_err(&pdev->dev, "Failed to register netdev\n");
		goto err_out;
	}

854
855
	printk(KERN_INFO "%s: ep93xx on-chip ethernet, IRQ %d, %pM\n",
			dev->name, ep->irq, dev->dev_addr);
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872

	return 0;

err_out:
	ep93xx_eth_remove(pdev);
	return err;
}


static struct platform_driver ep93xx_eth_driver = {
	.probe		= ep93xx_eth_probe,
	.remove		= ep93xx_eth_remove,
	.driver		= {
		.name	= "ep93xx-eth",
	},
};

873
module_platform_driver(ep93xx_eth_driver);
874
875

MODULE_LICENSE("GPL");
876
MODULE_ALIAS("platform:ep93xx-eth");