r6040.c 32 KB
Newer Older
1
2
3
4
5
/*
 * RDC R6040 Fast Ethernet MAC support
 *
 * Copyright (C) 2004 Sten Wang <sten.wang@rdc.com.tw>
 * Copyright (C) 2007
Francois Romieu's avatar
Francois Romieu committed
6
 *	Daniel Gimpelevich <daniel@gimpelevich.san-francisco.ca.us>
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
 *	Florian Fainelli <florian@openwrt.org>
 *
 * 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., 51 Franklin Street, Fifth Floor,
 * Boston, MA  02110-1301, USA.
*/

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/moduleparam.h>
#include <linux/string.h>
#include <linux/timer.h>
#include <linux/errno.h>
#include <linux/ioport.h>
#include <linux/interrupt.h>
#include <linux/pci.h>
#include <linux/netdevice.h>
#include <linux/etherdevice.h>
#include <linux/skbuff.h>
#include <linux/init.h>
#include <linux/delay.h>
#include <linux/mii.h>
#include <linux/ethtool.h>
#include <linux/crc32.h>
#include <linux/spinlock.h>
43
44
45
46
#include <linux/bitops.h>
#include <linux/io.h>
#include <linux/irq.h>
#include <linux/uaccess.h>
Florian Fainelli's avatar
Florian Fainelli committed
47
#include <linux/phy.h>
48
49
50
51

#include <asm/processor.h>

#define DRV_NAME	"r6040"
52
53
#define DRV_VERSION	"0.26"
#define DRV_RELDATE	"30May2010"
54
55
56

/* PHY CHIP Address */
#define PHY1_ADDR	1	/* For MAC1 */
57
#define PHY2_ADDR	3	/* For MAC2 */
58
59
60
61
#define PHY_MODE	0x3100	/* PHY CHIP Register 0 */
#define PHY_CAP		0x01E1	/* PHY CHIP Register 4 */

/* Time in jiffies before concluding the transmitter is hung. */
Francois Romieu's avatar
Francois Romieu committed
62
#define TX_TIMEOUT	(6000 * HZ / 1000)
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

/* RDC MAC I/O Size */
#define R6040_IO_SIZE	256

/* MAX RDC MAC */
#define MAX_MAC		2

/* MAC registers */
#define MCR0		0x00	/* Control register 0 */
#define MCR1		0x04	/* Control register 1 */
#define  MAC_RST	0x0001	/* Reset the MAC */
#define MBCR		0x08	/* Bus control */
#define MT_ICR		0x0C	/* TX interrupt control */
#define MR_ICR		0x10	/* RX interrupt control */
#define MTPR		0x14	/* TX poll command register */
#define MR_BSR		0x18	/* RX buffer size */
#define MR_DCR		0x1A	/* RX descriptor control */
#define MLSR		0x1C	/* Last status */
#define MMDIO		0x20	/* MDIO control register */
#define  MDIO_WRITE	0x4000	/* MDIO write */
#define  MDIO_READ	0x2000	/* MDIO read */
#define MMRD		0x24	/* MDIO read data register */
#define MMWD		0x28	/* MDIO write data register */
#define MTD_SA0		0x2C	/* TX descriptor start address 0 */
#define MTD_SA1		0x30	/* TX descriptor start address 1 */
#define MRD_SA0		0x34	/* RX descriptor start address 0 */
#define MRD_SA1		0x38	/* RX descriptor start address 1 */
#define MISR		0x3C	/* Status register */
#define MIER		0x40	/* INT enable register */
#define  MSK_INT	0x0000	/* Mask off interrupts */
93
94
95
96
97
98
99
100
#define  RX_FINISH	0x0001  /* RX finished */
#define  RX_NO_DESC	0x0002  /* No RX descriptor available */
#define  RX_FIFO_FULL	0x0004  /* RX FIFO full */
#define  RX_EARLY	0x0008  /* RX early */
#define  TX_FINISH	0x0010  /* TX finished */
#define  TX_EARLY	0x0080  /* TX early */
#define  EVENT_OVRFL	0x0100  /* Event counter overflow */
#define  LINK_CHANGED	0x0200  /* PHY link changed */
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
#define ME_CISR		0x44	/* Event counter INT status */
#define ME_CIER		0x48	/* Event counter INT enable  */
#define MR_CNT		0x50	/* Successfully received packet counter */
#define ME_CNT0		0x52	/* Event counter 0 */
#define ME_CNT1		0x54	/* Event counter 1 */
#define ME_CNT2		0x56	/* Event counter 2 */
#define ME_CNT3		0x58	/* Event counter 3 */
#define MT_CNT		0x5A	/* Successfully transmit packet counter */
#define ME_CNT4		0x5C	/* Event counter 4 */
#define MP_CNT		0x5E	/* Pause frame counter register */
#define MAR0		0x60	/* Hash table 0 */
#define MAR1		0x62	/* Hash table 1 */
#define MAR2		0x64	/* Hash table 2 */
#define MAR3		0x66	/* Hash table 3 */
#define MID_0L		0x68	/* Multicast address MID0 Low */
#define MID_0M		0x6A	/* Multicast address MID0 Medium */
#define MID_0H		0x6C	/* Multicast address MID0 High */
#define MID_1L		0x70	/* MID1 Low */
#define MID_1M		0x72	/* MID1 Medium */
#define MID_1H		0x74	/* MID1 High */
#define MID_2L		0x78	/* MID2 Low */
#define MID_2M		0x7A	/* MID2 Medium */
#define MID_2H		0x7C	/* MID2 High */
#define MID_3L		0x80	/* MID3 Low */
#define MID_3M		0x82	/* MID3 Medium */
#define MID_3H		0x84	/* MID3 High */
#define PHY_CC		0x88	/* PHY status change configuration register */
#define PHY_ST		0x8A	/* PHY status register */
#define MAC_SM		0xAC	/* MAC status machine */
#define MAC_ID		0xBE	/* Identifier register */

#define TX_DCNT		0x80	/* TX descriptor count */
#define RX_DCNT		0x80	/* RX descriptor count */
#define MAX_BUF_SIZE	0x600
Francois Romieu's avatar
Francois Romieu committed
135
136
#define RX_DESC_SIZE	(RX_DCNT * sizeof(struct r6040_descriptor))
#define TX_DESC_SIZE	(TX_DCNT * sizeof(struct r6040_descriptor))
137
#define MBCR_DEFAULT	0x012A	/* MAC Bus Control Register */
138
#define MCAST_MAX	3	/* Max number multicast addresses to filter */
139

140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
/* Descriptor status */
#define DSC_OWNER_MAC	0x8000	/* MAC is the owner of this descriptor */
#define DSC_RX_OK	0x4000	/* RX was successful */
#define DSC_RX_ERR	0x0800	/* RX PHY error */
#define DSC_RX_ERR_DRI	0x0400	/* RX dribble packet */
#define DSC_RX_ERR_BUF	0x0200	/* RX length exceeds buffer size */
#define DSC_RX_ERR_LONG	0x0100	/* RX length > maximum packet length */
#define DSC_RX_ERR_RUNT	0x0080	/* RX packet length < 64 byte */
#define DSC_RX_ERR_CRC	0x0040	/* RX CRC error */
#define DSC_RX_BCAST	0x0020	/* RX broadcast (no error) */
#define DSC_RX_MCAST	0x0010	/* RX multicast (no error) */
#define DSC_RX_MCH_HIT	0x0008	/* RX multicast hit in hash table (no error) */
#define DSC_RX_MIDH_HIT	0x0004	/* RX MID table hit (no error) */
#define DSC_RX_IDX_MID_MASK 3	/* RX mask for the index of matched MIDx */

155
156
157
158
159
160
161
162
/* PHY settings */
#define ICPLUS_PHY_ID	0x0243

MODULE_AUTHOR("Sten Wang <sten.wang@rdc.com.tw>,"
	"Daniel Gimpelevich <daniel@gimpelevich.san-francisco.ca.us>,"
	"Florian Fainelli <florian@openwrt.org>");
MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("RDC R6040 NAPI PCI FastEthernet driver");
Florian Fainelli's avatar
Florian Fainelli committed
163
MODULE_VERSION(DRV_VERSION " " DRV_RELDATE);
164

165
/* RX and TX interrupts that we handle */
166
167
168
#define RX_INTS			(RX_FIFO_FULL | RX_NO_DESC | RX_FINISH)
#define TX_INTS			(TX_FINISH)
#define INT_MASK		(RX_INTS | TX_INTS)
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187

struct r6040_descriptor {
	u16	status, len;		/* 0-3 */
	__le32	buf;			/* 4-7 */
	__le32	ndesc;			/* 8-B */
	u32	rev1;			/* C-F */
	char	*vbufp;			/* 10-13 */
	struct r6040_descriptor *vndescp;	/* 14-17 */
	struct sk_buff *skb_ptr;	/* 18-1B */
	u32	rev2;			/* 1C-1F */
} __attribute__((aligned(32)));

struct r6040_private {
	spinlock_t lock;		/* driver lock */
	struct pci_dev *pdev;
	struct r6040_descriptor *rx_insert_ptr;
	struct r6040_descriptor *rx_remove_ptr;
	struct r6040_descriptor *tx_insert_ptr;
	struct r6040_descriptor *tx_remove_ptr;
Francois Romieu's avatar
Francois Romieu committed
188
189
190
191
	struct r6040_descriptor *rx_ring;
	struct r6040_descriptor *tx_ring;
	dma_addr_t rx_ring_dma;
	dma_addr_t tx_ring_dma;
Florian Fainelli's avatar
Florian Fainelli committed
192
	u16	tx_free_desc, phy_addr;
193
194
	u16	mcr0, mcr1;
	struct net_device *dev;
Florian Fainelli's avatar
Florian Fainelli committed
195
	struct mii_bus *mii_bus;
196
197
	struct napi_struct napi;
	void __iomem *base;
Florian Fainelli's avatar
Florian Fainelli committed
198
199
200
	struct phy_device *phydev;
	int old_link;
	int old_duplex;
201
202
};

203
static char version[] __devinitdata = DRV_NAME
204
	": RDC R6040 NAPI net driver,"
205
	"version "DRV_VERSION " (" DRV_RELDATE ")";
206

207
static int phy_table[] = { PHY1_ADDR, PHY2_ADDR };
208
209

/* Read a word data from PHY Chip */
210
static int r6040_phy_read(void __iomem *ioaddr, int phy_addr, int reg)
211
212
213
214
215
216
217
218
{
	int limit = 2048;
	u16 cmd;

	iowrite16(MDIO_READ + reg + (phy_addr << 8), ioaddr + MMDIO);
	/* Wait for the read bit to be cleared */
	while (limit--) {
		cmd = ioread16(ioaddr + MMDIO);
Joe Chou's avatar
Joe Chou committed
219
		if (!(cmd & MDIO_READ))
220
221
222
223
224
225
226
			break;
	}

	return ioread16(ioaddr + MMRD);
}

/* Write a word data from PHY Chip */
227
228
static void r6040_phy_write(void __iomem *ioaddr,
					int phy_addr, int reg, u16 val)
229
230
231
232
233
234
235
236
237
238
{
	int limit = 2048;
	u16 cmd;

	iowrite16(val, ioaddr + MMWD);
	/* Write the command to the MDIO bus */
	iowrite16(MDIO_WRITE + reg + (phy_addr << 8), ioaddr + MMDIO);
	/* Wait for the write bit to be cleared */
	while (limit--) {
		cmd = ioread16(ioaddr + MMDIO);
Joe Chou's avatar
Joe Chou committed
239
		if (!(cmd & MDIO_WRITE))
240
241
242
243
			break;
	}
}

Florian Fainelli's avatar
Florian Fainelli committed
244
static int r6040_mdiobus_read(struct mii_bus *bus, int phy_addr, int reg)
245
{
Florian Fainelli's avatar
Florian Fainelli committed
246
	struct net_device *dev = bus->priv;
247
248
249
	struct r6040_private *lp = netdev_priv(dev);
	void __iomem *ioaddr = lp->base;

Florian Fainelli's avatar
Florian Fainelli committed
250
	return r6040_phy_read(ioaddr, phy_addr, reg);
251
252
}

Florian Fainelli's avatar
Florian Fainelli committed
253
254
static int r6040_mdiobus_write(struct mii_bus *bus, int phy_addr,
						int reg, u16 value)
255
{
Florian Fainelli's avatar
Florian Fainelli committed
256
	struct net_device *dev = bus->priv;
257
258
259
	struct r6040_private *lp = netdev_priv(dev);
	void __iomem *ioaddr = lp->base;

Florian Fainelli's avatar
Florian Fainelli committed
260
261
262
263
264
265
266
267
	r6040_phy_write(ioaddr, phy_addr, reg, value);

	return 0;
}

static int r6040_mdiobus_reset(struct mii_bus *bus)
{
	return 0;
268
269
}

270
271
272
273
274
275
276
static void r6040_free_txbufs(struct net_device *dev)
{
	struct r6040_private *lp = netdev_priv(dev);
	int i;

	for (i = 0; i < TX_DCNT; i++) {
		if (lp->tx_insert_ptr->skb_ptr) {
Al Viro's avatar
Al Viro committed
277
278
			pci_unmap_single(lp->pdev,
				le32_to_cpu(lp->tx_insert_ptr->buf),
279
280
				MAX_BUF_SIZE, PCI_DMA_TODEVICE);
			dev_kfree_skb(lp->tx_insert_ptr->skb_ptr);
281
			lp->tx_insert_ptr->skb_ptr = NULL;
282
283
284
285
286
287
288
289
290
291
292
293
		}
		lp->tx_insert_ptr = lp->tx_insert_ptr->vndescp;
	}
}

static void r6040_free_rxbufs(struct net_device *dev)
{
	struct r6040_private *lp = netdev_priv(dev);
	int i;

	for (i = 0; i < RX_DCNT; i++) {
		if (lp->rx_insert_ptr->skb_ptr) {
Al Viro's avatar
Al Viro committed
294
295
			pci_unmap_single(lp->pdev,
				le32_to_cpu(lp->rx_insert_ptr->buf),
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
				MAX_BUF_SIZE, PCI_DMA_FROMDEVICE);
			dev_kfree_skb(lp->rx_insert_ptr->skb_ptr);
			lp->rx_insert_ptr->skb_ptr = NULL;
		}
		lp->rx_insert_ptr = lp->rx_insert_ptr->vndescp;
	}
}

static void r6040_init_ring_desc(struct r6040_descriptor *desc_ring,
				 dma_addr_t desc_dma, int size)
{
	struct r6040_descriptor *desc = desc_ring;
	dma_addr_t mapping = desc_dma;

	while (size-- > 0) {
311
		mapping += sizeof(*desc);
312
313
314
315
316
317
318
319
320
		desc->ndesc = cpu_to_le32(mapping);
		desc->vndescp = desc + 1;
		desc++;
	}
	desc--;
	desc->ndesc = cpu_to_le32(desc_dma);
	desc->vndescp = desc_ring;
}

321
static void r6040_init_txbufs(struct net_device *dev)
322
323
324
325
326
327
328
329
330
{
	struct r6040_private *lp = netdev_priv(dev);

	lp->tx_free_desc = TX_DCNT;

	lp->tx_remove_ptr = lp->tx_insert_ptr = lp->tx_ring;
	r6040_init_ring_desc(lp->tx_ring, lp->tx_ring_dma, TX_DCNT);
}

331
static int r6040_alloc_rxbufs(struct net_device *dev)
332
333
{
	struct r6040_private *lp = netdev_priv(dev);
334
335
336
	struct r6040_descriptor *desc;
	struct sk_buff *skb;
	int rc;
337
338
339
340

	lp->rx_remove_ptr = lp->rx_insert_ptr = lp->rx_ring;
	r6040_init_ring_desc(lp->rx_ring, lp->rx_ring_dma, RX_DCNT);

341
342
343
344
345
	/* Allocate skbs for the rx descriptors */
	desc = lp->rx_ring;
	do {
		skb = netdev_alloc_skb(dev, MAX_BUF_SIZE);
		if (!skb) {
346
			netdev_err(dev, "failed to alloc skb for rx\n");
347
348
349
350
351
			rc = -ENOMEM;
			goto err_exit;
		}
		desc->skb_ptr = skb;
		desc->buf = cpu_to_le32(pci_map_single(lp->pdev,
352
353
					desc->skb_ptr->data,
					MAX_BUF_SIZE, PCI_DMA_FROMDEVICE));
354
		desc->status = DSC_OWNER_MAC;
355
356
357
358
359
360
361
362
363
		desc = desc->vndescp;
	} while (desc != lp->rx_ring);

	return 0;

err_exit:
	/* Deallocate all previously allocated skbs */
	r6040_free_rxbufs(dev);
	return rc;
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
}

static void r6040_init_mac_regs(struct net_device *dev)
{
	struct r6040_private *lp = netdev_priv(dev);
	void __iomem *ioaddr = lp->base;
	int limit = 2048;
	u16 cmd;

	/* Mask Off Interrupt */
	iowrite16(MSK_INT, ioaddr + MIER);

	/* Reset RDC MAC */
	iowrite16(MAC_RST, ioaddr + MCR1);
	while (limit--) {
		cmd = ioread16(ioaddr + MCR1);
		if (cmd & 0x1)
			break;
	}
	/* Reset internal state machine */
	iowrite16(2, ioaddr + MAC_SM);
	iowrite16(0, ioaddr + MAC_SM);
386
	mdelay(5);
387
388
389
390
391
392
393
394
395
396

	/* MAC Bus Control Register */
	iowrite16(MBCR_DEFAULT, ioaddr + MBCR);

	/* Buffer Size Register */
	iowrite16(MAX_BUF_SIZE, ioaddr + MR_BSR);

	/* Write TX ring start address */
	iowrite16(lp->tx_ring_dma, ioaddr + MTD_SA0);
	iowrite16(lp->tx_ring_dma >> 16, ioaddr + MTD_SA1);
397

398
	/* Write RX ring start address */
399
400
	iowrite16(lp->rx_ring_dma, ioaddr + MRD_SA0);
	iowrite16(lp->rx_ring_dma >> 16, ioaddr + MRD_SA1);
401
402

	/* Set interrupt waiting time and packet numbers */
403
404
	iowrite16(0, ioaddr + MT_ICR);
	iowrite16(0, ioaddr + MR_ICR);
405
406
407
408
409
410
411
412
413
414
415

	/* Enable interrupts */
	iowrite16(INT_MASK, ioaddr + MIER);

	/* Enable TX and RX */
	iowrite16(lp->mcr0 | 0x0002, ioaddr);

	/* Let TX poll the descriptors
	 * we may got called by r6040_tx_timeout which has left
	 * some unsent tx buffers */
	iowrite16(0x01, ioaddr + MTPR);
416
}
417

418
419
420
421
422
static void r6040_tx_timeout(struct net_device *dev)
{
	struct r6040_private *priv = netdev_priv(dev);
	void __iomem *ioaddr = priv->base;

423
	netdev_warn(dev, "transmit timed out, int enable %4.4x "
Florian Fainelli's avatar
Florian Fainelli committed
424
		"status %4.4x\n",
425
		ioread16(ioaddr + MIER),
Florian Fainelli's avatar
Florian Fainelli committed
426
		ioread16(ioaddr + MISR));
427
428

	dev->stats.tx_errors++;
429
430
431

	/* Reset MAC and re-init all registers */
	r6040_init_mac_regs(dev);
432
433
}

434
435
436
437
438
439
440
static struct net_device_stats *r6040_get_stats(struct net_device *dev)
{
	struct r6040_private *priv = netdev_priv(dev);
	void __iomem *ioaddr = priv->base;
	unsigned long flags;

	spin_lock_irqsave(&priv->lock, flags);
441
442
	dev->stats.rx_crc_errors += ioread8(ioaddr + ME_CNT1);
	dev->stats.multicast += ioread8(ioaddr + ME_CNT0);
443
444
	spin_unlock_irqrestore(&priv->lock, flags);

445
	return &dev->stats;
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
}

/* Stop RDC MAC and Free the allocated resource */
static void r6040_down(struct net_device *dev)
{
	struct r6040_private *lp = netdev_priv(dev);
	void __iomem *ioaddr = lp->base;
	int limit = 2048;
	u16 *adrp;
	u16 cmd;

	/* Stop MAC */
	iowrite16(MSK_INT, ioaddr + MIER);	/* Mask Off Interrupt */
	iowrite16(MAC_RST, ioaddr + MCR1);	/* Reset RDC MAC */
	while (limit--) {
		cmd = ioread16(ioaddr + MCR1);
		if (cmd & 0x1)
			break;
	}

	/* Restore MAC Address to MIDx */
	adrp = (u16 *) dev->dev_addr;
	iowrite16(adrp[0], ioaddr + MID_0L);
	iowrite16(adrp[1], ioaddr + MID_0M);
	iowrite16(adrp[2], ioaddr + MID_0H);
}

Francois Romieu's avatar
Francois Romieu committed
473
static int r6040_close(struct net_device *dev)
474
475
{
	struct r6040_private *lp = netdev_priv(dev);
476
	struct pci_dev *pdev = lp->pdev;
477
478

	spin_lock_irq(&lp->lock);
479
	napi_disable(&lp->napi);
480
481
	netif_stop_queue(dev);
	r6040_down(dev);
482
483
484
485
486
487
488
489
490

	free_irq(dev->irq, dev);

	/* Free RX buffer */
	r6040_free_rxbufs(dev);

	/* Free TX buffer */
	r6040_free_txbufs(dev);

491
492
	spin_unlock_irq(&lp->lock);

493
494
	/* Free Descriptor memory */
	if (lp->rx_ring) {
495
496
		pci_free_consistent(pdev,
				RX_DESC_SIZE, lp->rx_ring, lp->rx_ring_dma);
497
		lp->rx_ring = NULL;
498
499
500
	}

	if (lp->tx_ring) {
501
502
		pci_free_consistent(pdev,
				TX_DESC_SIZE, lp->tx_ring, lp->tx_ring_dma);
503
		lp->tx_ring = NULL;
504
505
	}

506
507
508
509
510
511
512
	return 0;
}

static int r6040_ioctl(struct net_device *dev, struct ifreq *rq, int cmd)
{
	struct r6040_private *lp = netdev_priv(dev);

Florian Fainelli's avatar
Florian Fainelli committed
513
	if (!lp->phydev)
514
		return -EINVAL;
Florian Fainelli's avatar
Florian Fainelli committed
515

516
	return phy_mii_ioctl(lp->phydev, rq, cmd);
517
518
519
520
521
}

static int r6040_rx(struct net_device *dev, int limit)
{
	struct r6040_private *priv = netdev_priv(dev);
522
523
524
	struct r6040_descriptor *descptr = priv->rx_remove_ptr;
	struct sk_buff *skb_ptr, *new_skb;
	int count = 0;
525
526
	u16 err;

527
	/* Limit not reached and the descriptor belongs to the CPU */
528
	while (count < limit && !(descptr->status & DSC_OWNER_MAC)) {
529
530
531
		/* Read the descriptor status */
		err = descptr->status;
		/* Global error status set */
532
		if (err & DSC_RX_ERR) {
533
			/* RX dribble */
534
			if (err & DSC_RX_ERR_DRI)
535
536
				dev->stats.rx_frame_errors++;
			/* Buffer lenght exceeded */
537
			if (err & DSC_RX_ERR_BUF)
538
539
				dev->stats.rx_length_errors++;
			/* Packet too long */
540
			if (err & DSC_RX_ERR_LONG)
541
542
				dev->stats.rx_length_errors++;
			/* Packet < 64 bytes */
543
			if (err & DSC_RX_ERR_RUNT)
544
545
				dev->stats.rx_length_errors++;
			/* CRC error */
546
			if (err & DSC_RX_ERR_CRC) {
547
548
549
				spin_lock(&priv->lock);
				dev->stats.rx_crc_errors++;
				spin_unlock(&priv->lock);
550
			}
551
552
			goto next_descr;
		}
553

554
555
556
557
558
		/* Packet successfully received */
		new_skb = netdev_alloc_skb(dev, MAX_BUF_SIZE);
		if (!new_skb) {
			dev->stats.rx_dropped++;
			goto next_descr;
559
		}
560
561
		skb_ptr = descptr->skb_ptr;
		skb_ptr->dev = priv->dev;
562

563
564
565
566
567
		/* Do not count the CRC */
		skb_put(skb_ptr, descptr->len - 4);
		pci_unmap_single(priv->pdev, le32_to_cpu(descptr->buf),
					MAX_BUF_SIZE, PCI_DMA_FROMDEVICE);
		skb_ptr->protocol = eth_type_trans(skb_ptr, priv->dev);
568

569
570
571
572
573
574
575
576
577
578
579
580
581
		/* Send to upper layer */
		netif_receive_skb(skb_ptr);
		dev->stats.rx_packets++;
		dev->stats.rx_bytes += descptr->len - 4;

		/* put new skb into descriptor */
		descptr->skb_ptr = new_skb;
		descptr->buf = cpu_to_le32(pci_map_single(priv->pdev,
						descptr->skb_ptr->data,
					MAX_BUF_SIZE, PCI_DMA_FROMDEVICE));

next_descr:
		/* put the descriptor back to the MAC */
582
		descptr->status = DSC_OWNER_MAC;
583
584
		descptr = descptr->vndescp;
		count++;
585
	}
586
	priv->rx_remove_ptr = descptr;
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604

	return count;
}

static void r6040_tx(struct net_device *dev)
{
	struct r6040_private *priv = netdev_priv(dev);
	struct r6040_descriptor *descptr;
	void __iomem *ioaddr = priv->base;
	struct sk_buff *skb_ptr;
	u16 err;

	spin_lock(&priv->lock);
	descptr = priv->tx_remove_ptr;
	while (priv->tx_free_desc < TX_DCNT) {
		/* Check for errors */
		err = ioread16(ioaddr + MLSR);

605
606
607
608
		if (err & 0x0200)
			dev->stats.rx_fifo_errors++;
		if (err & (0x2000 | 0x4000))
			dev->stats.tx_carrier_errors++;
609

610
		if (descptr->status & DSC_OWNER_MAC)
Florian Fainelli's avatar
Florian Fainelli committed
611
			break; /* Not complete */
612
		skb_ptr = descptr->skb_ptr;
Al Viro's avatar
Al Viro committed
613
		pci_unmap_single(priv->pdev, le32_to_cpu(descptr->buf),
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
			skb_ptr->len, PCI_DMA_TODEVICE);
		/* Free buffer */
		dev_kfree_skb_irq(skb_ptr);
		descptr->skb_ptr = NULL;
		/* To next descriptor */
		descptr = descptr->vndescp;
		priv->tx_free_desc++;
	}
	priv->tx_remove_ptr = descptr;

	if (priv->tx_free_desc)
		netif_wake_queue(dev);
	spin_unlock(&priv->lock);
}

static int r6040_poll(struct napi_struct *napi, int budget)
{
	struct r6040_private *priv =
		container_of(napi, struct r6040_private, napi);
	struct net_device *dev = priv->dev;
	void __iomem *ioaddr = priv->base;
	int work_done;

	work_done = r6040_rx(dev, budget);

	if (work_done < budget) {
640
		napi_complete(napi);
641
		/* Enable RX interrupt */
642
		iowrite16(ioread16(ioaddr + MIER) | RX_INTS, ioaddr + MIER);
643
644
645
646
647
648
649
650
651
652
	}
	return work_done;
}

/* The RDC interrupt handler. */
static irqreturn_t r6040_interrupt(int irq, void *dev_id)
{
	struct net_device *dev = dev_id;
	struct r6040_private *lp = netdev_priv(dev);
	void __iomem *ioaddr = lp->base;
653
	u16 misr, status;
654

655
656
	/* Save MIER */
	misr = ioread16(ioaddr + MIER);
657
658
659
660
661
	/* Mask off RDC MAC interrupt */
	iowrite16(MSK_INT, ioaddr + MIER);
	/* Read MISR status and clear */
	status = ioread16(ioaddr + MISR);

662
663
664
	if (status == 0x0000 || status == 0xffff) {
		/* Restore RDC MAC interrupt */
		iowrite16(misr, ioaddr + MIER);
665
		return IRQ_NONE;
666
	}
667
668

	/* RX interrupt request */
669
670
671
672
673
674
675
676
677
	if (status & RX_INTS) {
		if (status & RX_NO_DESC) {
			/* RX descriptor unavailable */
			dev->stats.rx_dropped++;
			dev->stats.rx_missed_errors++;
		}
		if (status & RX_FIFO_FULL)
			dev->stats.rx_fifo_errors++;

678
		/* Mask off RX interrupt */
679
		misr &= ~RX_INTS;
680
		napi_schedule(&lp->napi);
681
682
683
	}

	/* TX interrupt request */
684
	if (status & TX_INTS)
685
686
		r6040_tx(dev);

687
688
689
	/* Restore RDC MAC interrupt */
	iowrite16(misr, ioaddr + MIER);

Florian Fainelli's avatar
Florian Fainelli committed
690
	return IRQ_HANDLED;
691
692
693
694
695
696
}

#ifdef CONFIG_NET_POLL_CONTROLLER
static void r6040_poll_controller(struct net_device *dev)
{
	disable_irq(dev->irq);
Francois Romieu's avatar
Francois Romieu committed
697
	r6040_interrupt(dev->irq, dev);
698
699
700
701
702
	enable_irq(dev->irq);
}
#endif

/* Init RDC MAC */
703
static int r6040_up(struct net_device *dev)
704
705
706
{
	struct r6040_private *lp = netdev_priv(dev);
	void __iomem *ioaddr = lp->base;
707
	int ret;
708

709
	/* Initialise and alloc RX/TX buffers */
710
711
712
713
	r6040_init_txbufs(dev);
	ret = r6040_alloc_rxbufs(dev);
	if (ret)
		return ret;
714
715

	/* improve performance (by RDC guys) */
716
717
718
719
	r6040_phy_write(ioaddr, 30, 17,
			(r6040_phy_read(ioaddr, 30, 17) | 0x4000));
	r6040_phy_write(ioaddr, 30, 17,
			~((~r6040_phy_read(ioaddr, 30, 17)) | 0x2000));
720
721
	r6040_phy_write(ioaddr, 0, 19, 0x0000);
	r6040_phy_write(ioaddr, 0, 30, 0x01F0);
722

723
724
	/* Initialize all MAC registers */
	r6040_init_mac_regs(dev);
725
726

	return 0;
727
728
729
730
731
732
733
734
735
736
737
738
739
740
}


/* Read/set MAC address routines */
static void r6040_mac_address(struct net_device *dev)
{
	struct r6040_private *lp = netdev_priv(dev);
	void __iomem *ioaddr = lp->base;
	u16 *adrp;

	/* MAC operation register */
	iowrite16(0x01, ioaddr + MCR1); /* Reset MAC */
	iowrite16(2, ioaddr + MAC_SM); /* Reset internal state machine */
	iowrite16(0, ioaddr + MAC_SM);
741
	mdelay(5);
742
743
744
745
746
747

	/* Restore MAC Address */
	adrp = (u16 *) dev->dev_addr;
	iowrite16(adrp[0], ioaddr + MID_0L);
	iowrite16(adrp[1], ioaddr + MID_0M);
	iowrite16(adrp[2], ioaddr + MID_0H);
748
749
750

	/* Store MAC Address in perm_addr */
	memcpy(dev->perm_addr, dev->dev_addr, ETH_ALEN);
751
752
}

Francois Romieu's avatar
Francois Romieu committed
753
static int r6040_open(struct net_device *dev)
754
{
Francois Romieu's avatar
Francois Romieu committed
755
	struct r6040_private *lp = netdev_priv(dev);
756
757
758
	int ret;

	/* Request IRQ and Register interrupt handler */
759
	ret = request_irq(dev->irq, r6040_interrupt,
760
761
		IRQF_SHARED, dev->name, dev);
	if (ret)
762
		goto out;
763
764
765
766
767

	/* Set MAC address */
	r6040_mac_address(dev);

	/* Allocate Descriptor memory */
Francois Romieu's avatar
Francois Romieu committed
768
769
	lp->rx_ring =
		pci_alloc_consistent(lp->pdev, RX_DESC_SIZE, &lp->rx_ring_dma);
770
771
772
773
	if (!lp->rx_ring) {
		ret = -ENOMEM;
		goto err_free_irq;
	}
774

Francois Romieu's avatar
Francois Romieu committed
775
776
777
	lp->tx_ring =
		pci_alloc_consistent(lp->pdev, TX_DESC_SIZE, &lp->tx_ring_dma);
	if (!lp->tx_ring) {
778
779
		ret = -ENOMEM;
		goto err_free_rx_ring;
Francois Romieu's avatar
Francois Romieu committed
780
781
	}

782
	ret = r6040_up(dev);
783
784
	if (ret)
		goto err_free_tx_ring;
785
786
787
788
789

	napi_enable(&lp->napi);
	netif_start_queue(dev);

	return 0;
790
791
792
793
794
795
796
797
798
799
800

err_free_tx_ring:
	pci_free_consistent(lp->pdev, TX_DESC_SIZE, lp->tx_ring,
			lp->tx_ring_dma);
err_free_rx_ring:
	pci_free_consistent(lp->pdev, RX_DESC_SIZE, lp->rx_ring,
			lp->rx_ring_dma);
err_free_irq:
	free_irq(dev->irq, dev);
out:
	return ret;
801
802
}

803
804
static netdev_tx_t r6040_start_xmit(struct sk_buff *skb,
				    struct net_device *dev)
805
806
807
808
809
810
811
812
813
814
815
816
{
	struct r6040_private *lp = netdev_priv(dev);
	struct r6040_descriptor *descptr;
	void __iomem *ioaddr = lp->base;
	unsigned long flags;

	/* Critical Section */
	spin_lock_irqsave(&lp->lock, flags);

	/* TX resource check */
	if (!lp->tx_free_desc) {
		spin_unlock_irqrestore(&lp->lock, flags);
817
		netif_stop_queue(dev);
818
		netdev_err(dev, ": no tx descriptor\n");
819
		return NETDEV_TX_BUSY;
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
	}

	/* Statistic Counter */
	dev->stats.tx_packets++;
	dev->stats.tx_bytes += skb->len;
	/* Set TX descriptor & Transmit it */
	lp->tx_free_desc--;
	descptr = lp->tx_insert_ptr;
	if (skb->len < MISR)
		descptr->len = MISR;
	else
		descptr->len = skb->len;

	descptr->skb_ptr = skb;
	descptr->buf = cpu_to_le32(pci_map_single(lp->pdev,
		skb->data, skb->len, PCI_DMA_TODEVICE));
836
	descptr->status = DSC_OWNER_MAC;
837
838
839
840
841
842
843
844
845
	/* Trigger the MAC to check the TX descriptor */
	iowrite16(0x01, ioaddr + MTPR);
	lp->tx_insert_ptr = descptr->vndescp;

	/* If no tx resource, stop */
	if (!lp->tx_free_desc)
		netif_stop_queue(dev);

	spin_unlock_irqrestore(&lp->lock, flags);
846
847

	return NETDEV_TX_OK;
848
849
}

Francois Romieu's avatar
Francois Romieu committed
850
static void r6040_multicast_list(struct net_device *dev)
851
852
853
854
855
856
{
	struct r6040_private *lp = netdev_priv(dev);
	void __iomem *ioaddr = lp->base;
	u16 *adrp;
	u16 reg;
	unsigned long flags;
857
	struct netdev_hw_addr *ha;
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
	int i;

	/* MAC Address */
	adrp = (u16 *)dev->dev_addr;
	iowrite16(adrp[0], ioaddr + MID_0L);
	iowrite16(adrp[1], ioaddr + MID_0M);
	iowrite16(adrp[2], ioaddr + MID_0H);

	/* Promiscous Mode */
	spin_lock_irqsave(&lp->lock, flags);

	/* Clear AMCP & PROM bits */
	reg = ioread16(ioaddr) & ~0x0120;
	if (dev->flags & IFF_PROMISC) {
		reg |= 0x0020;
		lp->mcr0 |= 0x0020;
	}
	/* Too many multicast addresses
	 * accept all traffic */
877
878
	else if ((netdev_mc_count(dev) > MCAST_MAX) ||
		 (dev->flags & IFF_ALLMULTI))
879
880
881
882
883
884
		reg |= 0x0020;

	iowrite16(reg, ioaddr);
	spin_unlock_irqrestore(&lp->lock, flags);

	/* Build the hash table */
885
	if (netdev_mc_count(dev) > MCAST_MAX) {
886
887
888
889
890
891
		u16 hash_table[4];
		u32 crc;

		for (i = 0; i < 4; i++)
			hash_table[i] = 0;

892
893
		netdev_for_each_mc_addr(ha, dev) {
			char *addrs = ha->addr;
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908

			if (!(*addrs & 1))
				continue;

			crc = ether_crc_le(6, addrs);
			crc >>= 26;
			hash_table[crc >> 4] |= 1 << (15 - (crc & 0xf));
		}
		/* Fill the MAC hash tables with their values */
		iowrite16(hash_table[0], ioaddr + MAR0);
		iowrite16(hash_table[1], ioaddr + MAR1);
		iowrite16(hash_table[2], ioaddr + MAR2);
		iowrite16(hash_table[3], ioaddr + MAR3);
	}
	/* Multicast Address 1~4 case */
909
	i = 0;
910
	netdev_for_each_mc_addr(ha, dev) {
911
		if (i < MCAST_MAX) {
912
			adrp = (u16 *) ha->addr;
913
914
915
916
			iowrite16(adrp[0], ioaddr + MID_1L + 8 * i);
			iowrite16(adrp[1], ioaddr + MID_1M + 8 * i);
			iowrite16(adrp[2], ioaddr + MID_1H + 8 * i);
		} else {
917
918
919
			iowrite16(0xffff, ioaddr + MID_1L + 8 * i);
			iowrite16(0xffff, ioaddr + MID_1M + 8 * i);
			iowrite16(0xffff, ioaddr + MID_1H + 8 * i);
920
921
		}
		i++;
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
	}
}

static void netdev_get_drvinfo(struct net_device *dev,
			struct ethtool_drvinfo *info)
{
	struct r6040_private *rp = netdev_priv(dev);

	strcpy(info->driver, DRV_NAME);
	strcpy(info->version, DRV_VERSION);
	strcpy(info->bus_info, pci_name(rp->pdev));
}

static int netdev_get_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
	struct r6040_private *rp = netdev_priv(dev);

Florian Fainelli's avatar
Florian Fainelli committed
939
	return  phy_ethtool_gset(rp->phydev, cmd);
940
941
942
943
944
945
}

static int netdev_set_settings(struct net_device *dev, struct ethtool_cmd *cmd)
{
	struct r6040_private *rp = netdev_priv(dev);

Florian Fainelli's avatar
Florian Fainelli committed
946
	return phy_ethtool_sset(rp->phydev, cmd);
947
948
}

949
static const struct ethtool_ops netdev_ethtool_ops = {
950
951
952
	.get_drvinfo		= netdev_get_drvinfo,
	.get_settings		= netdev_get_settings,
	.set_settings		= netdev_set_settings,
Florian Fainelli's avatar
Florian Fainelli committed
953
	.get_link		= ethtool_op_get_link,
954
955
};

956
957
958
959
960
961
962
963
static const struct net_device_ops r6040_netdev_ops = {
	.ndo_open		= r6040_open,
	.ndo_stop		= r6040_close,
	.ndo_start_xmit		= r6040_start_xmit,
	.ndo_get_stats		= r6040_get_stats,
	.ndo_set_multicast_list = r6040_multicast_list,
	.ndo_change_mtu		= eth_change_mtu,
	.ndo_validate_addr	= eth_validate_addr,
964
	.ndo_set_mac_address	= eth_mac_addr,
965
966
967
968
969
970
971
	.ndo_do_ioctl		= r6040_ioctl,
	.ndo_tx_timeout		= r6040_tx_timeout,
#ifdef CONFIG_NET_POLL_CONTROLLER
	.ndo_poll_controller	= r6040_poll_controller,
#endif
};

Florian Fainelli's avatar
Florian Fainelli committed
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
1001
1002
1003
1004
1005
1006
1007
1008
1009
1010
1011
1012
1013
1014
1015
1016
1017
1018
1019
1020
1021
1022
1023
1024
1025
1026
1027
1028
1029
1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
static void r6040_adjust_link(struct net_device *dev)
{
	struct r6040_private *lp = netdev_priv(dev);
	struct phy_device *phydev = lp->phydev;
	int status_changed = 0;
	void __iomem *ioaddr = lp->base;

	BUG_ON(!phydev);

	if (lp->old_link != phydev->link) {
		status_changed = 1;
		lp->old_link = phydev->link;
	}

	/* reflect duplex change */
	if (phydev->link && (lp->old_duplex != phydev->duplex)) {
		lp->mcr0 |= (phydev->duplex == DUPLEX_FULL ? 0x8000 : 0);
		iowrite16(lp->mcr0, ioaddr);

		status_changed = 1;
		lp->old_duplex = phydev->duplex;
	}

	if (status_changed) {
		pr_info("%s: link %s", dev->name, phydev->link ?
			"UP" : "DOWN");
		if (phydev->link)
			pr_cont(" - %d/%s", phydev->speed,
			DUPLEX_FULL == phydev->duplex ? "full" : "half");
		pr_cont("\n");
	}
}

static int r6040_mii_probe(struct net_device *dev)
{
	struct r6040_private *lp = netdev_priv(dev);
	struct phy_device *phydev = NULL;

	phydev = phy_find_first(lp->mii_bus);
	if (!phydev) {
		dev_err(&lp->pdev->dev, "no PHY found\n");
		return -ENODEV;
	}

	phydev = phy_connect(dev, dev_name(&phydev->dev), &r6040_adjust_link,
				0, PHY_INTERFACE_MODE_MII);

	if (IS_ERR(phydev)) {
		dev_err(&lp->pdev->dev, "could not attach to PHY\n");
		return PTR_ERR(phydev);
	}

	/* mask with MAC supported features */
	phydev->supported &= (SUPPORTED_10baseT_Half
				| SUPPORTED_10baseT_Full
				| SUPPORTED_100baseT_Half
				| SUPPORTED_100baseT_Full
				| SUPPORTED_Autoneg
				| SUPPORTED_MII
				| SUPPORTED_TP);

	phydev->advertising = phydev->supported;
	lp->phydev = phydev;
	lp->old_link = 0;
	lp->old_duplex = -1;

	dev_info(&lp->pdev->dev, "attached PHY driver [%s] "
		"(mii_bus:phy_addr=%s)\n",
		phydev->drv->name, dev_name(&phydev->dev));

	return 0;
}

1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
static int __devinit r6040_init_one(struct pci_dev *pdev,
					 const struct pci_device_id *ent)
{
	struct net_device *dev;
	struct r6040_private *lp;
	void __iomem *ioaddr;
	int err, io_size = R6040_IO_SIZE;
	static int card_idx = -1;
	int bar = 0;
	u16 *adrp;
Florian Fainelli's avatar
Florian Fainelli committed
1055
	int i;
1056

1057
	pr_info("%s\n", version);
1058
1059
1060

	err = pci_enable_device(pdev);
	if (err)
1061
		goto err_out;
1062
1063

	/* this should always be supported */
1064
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
1065
	if (err) {
1066
		dev_err(&pdev->dev, "32-bit PCI DMA addresses"
1067
				"not supported by the card\n");
1068
		goto err_out;
1069
	}
1070
	err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
1071
	if (err) {
1072
		dev_err(&pdev->dev, "32-bit PCI DMA addresses"
1073
				"not supported by the card\n");
1074
		goto err_out;
1075
	}
1076
1077

	/* IO Size check */
1078
	if (pci_resource_len(pdev, bar) < io_size) {
1079
		dev_err(&pdev->dev, "Insufficient PCI resources, aborting\n");
1080
1081
		err = -EIO;
		goto err_out;
1082
1083
1084
1085
1086
1087
	}

	pci_set_master(pdev);

	dev = alloc_etherdev(sizeof(struct r6040_private));
	if (!dev) {
1088
		dev_err(&pdev->dev, "Failed to allocate etherdev\n");
1089
1090
		err = -ENOMEM;
		goto err_out;
1091
1092
1093
1094
	}
	SET_NETDEV_DEV(dev, &pdev->dev);
	lp = netdev_priv(dev);

1095
1096
1097
	err = pci_request_regions(pdev, DRV_NAME);

	if (err) {
1098
		dev_err(&pdev->dev, "Failed to request PCI regions\n");
1099
		goto err_out_free_dev;
1100
1101
1102
1103
	}

	ioaddr = pci_iomap(pdev, bar, io_size);
	if (!ioaddr) {
1104
		dev_err(&pdev->dev, "ioremap failed for device\n");
1105
1106
		err = -EIO;
		goto err_out_free_res;
1107
	}
1108
1109
1110
1111
	/* If PHY status change register is still set to zero it means the
	 * bootloader didn't initialize it */
	if (ioread16(ioaddr + PHY_CC) == 0)
		iowrite16(0x9f07, ioaddr + PHY_CC);
1112
1113
1114
1115
1116
1117
1118
1119
1120
1121
1122
1123
1124
1125
1126
1127

	/* Init system & device */
	lp->base = ioaddr;
	dev->irq = pdev->irq;

	spin_lock_init(&lp->lock);
	pci_set_drvdata(pdev, dev);

	/* Set MAC address */
	card_idx++;

	adrp = (u16 *)dev->dev_addr;
	adrp[0] = ioread16(ioaddr + MID_0L);
	adrp[1] = ioread16(ioaddr + MID_0M);
	adrp[2] = ioread16(ioaddr + MID_0H);

1128
1129
	/* Some bootloader/BIOSes do not initialize
	 * MAC address, warn about that */
1130
	if (!(adrp[0] || adrp[1] || adrp[2])) {
1131
1132
		netdev_warn(dev, "MAC address not initialized, "
					"generating random\n");
1133
1134
		random_ether_addr(dev->dev_addr);
	}
1135

1136
1137
	/* Link new device into r6040_root_dev */
	lp->pdev = pdev;
1138
	lp->dev = dev;
1139
1140
1141
1142
1143
1144

	/* Init RDC private data */
	lp->mcr0 = 0x1002;
	lp->phy_addr = phy_table[card_idx];

	/* The RDC-specific entries in the device structure. */
1145
	dev->netdev_ops = &r6040_netdev_ops;
1146
1147
	dev->ethtool_ops = &netdev_ethtool_ops;
	dev->watchdog_timeo = TX_TIMEOUT;
1148

1149
	netif_napi_add(dev, &lp->napi, r6040_poll, 64);
Florian Fainelli's avatar
Florian Fainelli committed
1150
1151
1152
1153

	lp->mii_bus = mdiobus_alloc();
	if (!lp->mii_bus) {
		dev_err(&pdev->dev, "mdiobus_alloc() failed\n");
1154
1155
1156
		goto err_out_unmap;
	}

Florian Fainelli's avatar
Florian Fainelli committed
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176
1177
1178
1179
1180
1181
1182
1183
	lp->mii_bus->priv = dev;
	lp->mii_bus->read = r6040_mdiobus_read;
	lp->mii_bus->write = r6040_mdiobus_write;
	lp->mii_bus->reset = r6040_mdiobus_reset;
	lp->mii_bus->name = "r6040_eth_mii";
	snprintf(lp->mii_bus->id, MII_BUS_ID_SIZE, "%x", card_idx);
	lp->mii_bus->irq = kmalloc(sizeof(int)*PHY_MAX_ADDR, GFP_KERNEL);
	if (!lp->mii_bus->irq) {
		dev_err(&pdev->dev, "mii_bus irq allocation failed\n");
		goto err_out_mdio;
	}

	for (i = 0; i < PHY_MAX_ADDR; i++)
		lp->mii_bus->irq[i] = PHY_POLL;

	err = mdiobus_register(lp->mii_bus);
	if (err) {
		dev_err(&pdev->dev, "failed to register MII bus\n");
		goto err_out_mdio_irq;
	}

	err = r6040_mii_probe(dev);
	if (err) {
		dev_err(&pdev->dev, "failed to probe MII bus\n");
		goto err_out_mdio_unregister;
	}

1184
1185
1186
	/* Register net device. After this dev->name assign */
	err = register_netdev(dev);
	if (err) {
1187
		dev_err(&pdev->dev, "Failed to register net device\n");
Florian Fainelli's avatar
Florian Fainelli committed
1188
		goto err_out_mdio_unregister;
1189
1190
1191
	}
	return 0;

Florian Fainelli's avatar
Florian Fainelli committed
1192
1193
1194
1195
1196
1197
err_out_mdio_unregister:
	mdiobus_unregister(lp->mii_bus);
err_out_mdio_irq:
	kfree(lp->mii_bus->irq);
err_out_mdio:
	mdiobus_free(lp->mii_bus);
1198
1199
1200
err_out_unmap:
	pci_iounmap(pdev, ioaddr);
err_out_free_res:
1201
	pci_release_regions(pdev);
1202
err_out_free_dev:
1203
	free_netdev(dev);
1204
err_out:
1205
1206
1207
1208
1209
1210
	return err;
}

static void __devexit r6040_remove_one(struct pci_dev *pdev)
{
	struct net_device *dev = pci_get_drvdata(pdev);
Florian Fainelli's avatar
Florian Fainelli committed
1211
	struct r6040_private *lp = netdev_priv(dev);
1212
1213

	unregister_netdev(dev);
Florian Fainelli's avatar
Florian Fainelli committed
1214
1215
1216
	mdiobus_unregister(lp->mii_bus);
	kfree(lp->mii_bus->irq);
	mdiobus_free(lp->mii_bus);
1217
1218
1219
1220
1221
1222
1223
	pci_release_regions(pdev);
	free_netdev(dev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);
}


1224
static DEFINE_PCI_DEVICE_TABLE(r6040_pci_tbl) = {
Francois Romieu's avatar
Francois Romieu committed
1225
1226
	{ PCI_DEVICE(PCI_VENDOR_ID_RDC, 0x6040) },
	{ 0 }
1227
1228
1229
1230
};
MODULE_DEVICE_TABLE(pci, r6040_pci_tbl);

static struct pci_driver r6040_driver = {
Francois Romieu's avatar
Francois Romieu committed
1231
	.name		= DRV_NAME,
1232
1233
1234
1235
1236
1237
1238
1239
1240
1241
1242
1243
1244
1245
1246
1247
1248
1249
1250
	.id_table	= r6040_pci_tbl,
	.probe		= r6040_init_one,
	.remove		= __devexit_p(r6040_remove_one),
};


static int __init r6040_init(void)
{
	return pci_register_driver(&r6040_driver);
}


static void __exit r6040_cleanup(void)
{
	pci_unregister_driver(&r6040_driver);
}

module_init(r6040_init);
module_exit(r6040_cleanup);