r6040.c 31.8 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
204
};

static char version[] __devinitdata = KERN_INFO DRV_NAME
	": 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
static void r6040_phy_write(void __iomem *ioaddr, int phy_addr, int reg, u16 val)
228
229
230
231
232
233
234
235
236
237
{
	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
238
		if (!(cmd & MDIO_WRITE))
239
240
241
242
			break;
	}
}

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

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

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

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

	return 0;
}

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

269
270
271
272
273
274
275
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
276
277
			pci_unmap_single(lp->pdev,
				le32_to_cpu(lp->tx_insert_ptr->buf),
278
279
				MAX_BUF_SIZE, PCI_DMA_TODEVICE);
			dev_kfree_skb(lp->tx_insert_ptr->skb_ptr);
280
			lp->tx_insert_ptr->skb_ptr = NULL;
281
282
283
284
285
286
287
288
289
290
291
292
		}
		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
293
294
			pci_unmap_single(lp->pdev,
				le32_to_cpu(lp->rx_insert_ptr->buf),
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
				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) {
310
		mapping += sizeof(*desc);
311
312
313
314
315
316
317
318
319
		desc->ndesc = cpu_to_le32(mapping);
		desc->vndescp = desc + 1;
		desc++;
	}
	desc--;
	desc->ndesc = cpu_to_le32(desc_dma);
	desc->vndescp = desc_ring;
}

320
static void r6040_init_txbufs(struct net_device *dev)
321
322
323
324
325
326
327
328
329
{
	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);
}

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

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

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

	return 0;

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

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);
385
	mdelay(5);
386
387
388
389
390
391
392
393
394
395

	/* 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);
396

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

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

	/* 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);
415
}
416

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

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

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

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

433
434
435
436
437
438
439
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);
440
441
	dev->stats.rx_crc_errors += ioread8(ioaddr + ME_CNT1);
	dev->stats.multicast += ioread8(ioaddr + ME_CNT0);
442
443
	spin_unlock_irqrestore(&priv->lock, flags);

444
	return &dev->stats;
445
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
}

/* 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
472
static int r6040_close(struct net_device *dev)
473
474
{
	struct r6040_private *lp = netdev_priv(dev);
475
	struct pci_dev *pdev = lp->pdev;
476
477

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

	free_irq(dev->irq, dev);

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

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

490
491
	spin_unlock_irq(&lp->lock);

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

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

503
504
505
506
507
508
509
	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
510
	if (!lp->phydev)
511
		return -EINVAL;
Florian Fainelli's avatar
Florian Fainelli committed
512
513

	return phy_mii_ioctl(lp->phydev, if_mii(rq), cmd);
514
515
516
517
518
}

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

524
	/* Limit not reached and the descriptor belongs to the CPU */
525
	while (count < limit && !(descptr->status & DSC_OWNER_MAC)) {
526
527
528
		/* Read the descriptor status */
		err = descptr->status;
		/* Global error status set */
529
		if (err & DSC_RX_ERR) {
530
			/* RX dribble */
531
			if (err & DSC_RX_ERR_DRI)
532
533
				dev->stats.rx_frame_errors++;
			/* Buffer lenght exceeded */
534
			if (err & DSC_RX_ERR_BUF)
535
536
				dev->stats.rx_length_errors++;
			/* Packet too long */
537
			if (err & DSC_RX_ERR_LONG)
538
539
				dev->stats.rx_length_errors++;
			/* Packet < 64 bytes */
540
			if (err & DSC_RX_ERR_RUNT)
541
542
				dev->stats.rx_length_errors++;
			/* CRC error */
543
			if (err & DSC_RX_ERR_CRC) {
544
545
546
				spin_lock(&priv->lock);
				dev->stats.rx_crc_errors++;
				spin_unlock(&priv->lock);
547
			}
548
549
550
551
552
553
554
555
			goto next_descr;
		}
		
		/* Packet successfully received */
		new_skb = netdev_alloc_skb(dev, MAX_BUF_SIZE);
		if (!new_skb) {
			dev->stats.rx_dropped++;
			goto next_descr;
556
		}
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
		skb_ptr = descptr->skb_ptr;
		skb_ptr->dev = priv->dev;
		
		/* 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);
		
		/* 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 */
579
		descptr->status = DSC_OWNER_MAC;
580
581
		descptr = descptr->vndescp;
		count++;
582
	}
583
	priv->rx_remove_ptr = descptr;
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601

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

602
603
604
605
		if (err & 0x0200)
			dev->stats.rx_fifo_errors++;
		if (err & (0x2000 | 0x4000))
			dev->stats.tx_carrier_errors++;
606

607
		if (descptr->status & DSC_OWNER_MAC)
Florian Fainelli's avatar
Florian Fainelli committed
608
			break; /* Not complete */
609
		skb_ptr = descptr->skb_ptr;
Al Viro's avatar
Al Viro committed
610
		pci_unmap_single(priv->pdev, le32_to_cpu(descptr->buf),
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
			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) {
637
		napi_complete(napi);
638
		/* Enable RX interrupt */
639
		iowrite16(ioread16(ioaddr + MIER) | RX_INTS, ioaddr + MIER);
640
641
642
643
644
645
646
647
648
649
	}
	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;
650
	u16 misr, status;
651

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

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

	/* RX interrupt request */
666
667
668
669
670
671
672
673
674
	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++;

675
		/* Mask off RX interrupt */
676
		misr &= ~RX_INTS;
677
		napi_schedule(&lp->napi);
678
679
680
	}

	/* TX interrupt request */
681
	if (status & TX_INTS)
682
683
		r6040_tx(dev);

684
685
686
	/* Restore RDC MAC interrupt */
	iowrite16(misr, ioaddr + MIER);

Florian Fainelli's avatar
Florian Fainelli committed
687
	return IRQ_HANDLED;
688
689
690
691
692
693
}

#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
694
	r6040_interrupt(dev->irq, dev);
695
696
697
698
699
	enable_irq(dev->irq);
}
#endif

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

706
	/* Initialise and alloc RX/TX buffers */
707
708
709
710
	r6040_init_txbufs(dev);
	ret = r6040_alloc_rxbufs(dev);
	if (ret)
		return ret;
711
712

	/* improve performance (by RDC guys) */
713
714
715
716
	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));
	r6040_phy_write(ioaddr, 0, 19, 0x0000);
	r6040_phy_write(ioaddr, 0, 30, 0x01F0);
717

718
719
	/* Initialize all MAC registers */
	r6040_init_mac_regs(dev);
720
721

	return 0;
722
723
724
725
726
727
728
729
730
731
732
733
734
735
}


/* 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);
736
	mdelay(5);
737
738
739
740
741
742
743
744

	/* 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);
}

Francois Romieu's avatar
Francois Romieu committed
745
static int r6040_open(struct net_device *dev)
746
{
Francois Romieu's avatar
Francois Romieu committed
747
	struct r6040_private *lp = netdev_priv(dev);
748
749
750
	int ret;

	/* Request IRQ and Register interrupt handler */
751
	ret = request_irq(dev->irq, r6040_interrupt,
752
753
754
755
756
757
758
759
		IRQF_SHARED, dev->name, dev);
	if (ret)
		return ret;

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

	/* Allocate Descriptor memory */
Francois Romieu's avatar
Francois Romieu committed
760
761
762
	lp->rx_ring =
		pci_alloc_consistent(lp->pdev, RX_DESC_SIZE, &lp->rx_ring_dma);
	if (!lp->rx_ring)
763
764
		return -ENOMEM;

Francois Romieu's avatar
Francois Romieu committed
765
766
767
768
769
770
771
772
	lp->tx_ring =
		pci_alloc_consistent(lp->pdev, TX_DESC_SIZE, &lp->tx_ring_dma);
	if (!lp->tx_ring) {
		pci_free_consistent(lp->pdev, RX_DESC_SIZE, lp->rx_ring,
				     lp->rx_ring_dma);
		return -ENOMEM;
	}

773
774
775
776
777
778
779
780
	ret = r6040_up(dev);
	if (ret) {
		pci_free_consistent(lp->pdev, TX_DESC_SIZE, lp->tx_ring,
							lp->tx_ring_dma);
		pci_free_consistent(lp->pdev, RX_DESC_SIZE, lp->rx_ring,
							lp->rx_ring_dma);
		return ret;
	}
781
782
783
784
785
786
787

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

	return 0;
}

788
789
static netdev_tx_t r6040_start_xmit(struct sk_buff *skb,
				    struct net_device *dev)
790
791
792
793
794
795
796
797
798
799
800
801
{
	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);
802
		netif_stop_queue(dev);
803
		netdev_err(dev, ": no tx descriptor\n");
804
		return NETDEV_TX_BUSY;
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
	}

	/* 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));
821
	descptr->status = DSC_OWNER_MAC;
822
823
824
825
826
827
828
829
830
	/* 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);
831
832

	return NETDEV_TX_OK;
833
834
}

Francois Romieu's avatar
Francois Romieu committed
835
static void r6040_multicast_list(struct net_device *dev)
836
837
838
839
840
841
{
	struct r6040_private *lp = netdev_priv(dev);
	void __iomem *ioaddr = lp->base;
	u16 *adrp;
	u16 reg;
	unsigned long flags;
842
	struct netdev_hw_addr *ha;
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
	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 */
862
863
	else if ((netdev_mc_count(dev) > MCAST_MAX) ||
		 (dev->flags & IFF_ALLMULTI))
864
865
866
867
868
869
		reg |= 0x0020;

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

	/* Build the hash table */
870
	if (netdev_mc_count(dev) > MCAST_MAX) {
871
872
873
874
875
876
		u16 hash_table[4];
		u32 crc;

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

877
878
		netdev_for_each_mc_addr(ha, dev) {
			char *addrs = ha->addr;
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893

			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 */
894
	i = 0;
895
	netdev_for_each_mc_addr(ha, dev) {
896
		if (i < MCAST_MAX) {
897
			adrp = (u16 *) ha->addr;
898
899
900
901
			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 {
902
903
904
			iowrite16(0xffff, ioaddr + MID_1L + 8 * i);
			iowrite16(0xffff, ioaddr + MID_1M + 8 * i);
			iowrite16(0xffff, ioaddr + MID_1H + 8 * i);
905
906
		}
		i++;
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
	}
}

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
924
	return  phy_ethtool_gset(rp->phydev, cmd);
925
926
927
928
929
930
}

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
931
	return phy_ethtool_sset(rp->phydev, cmd);
932
933
}

934
static const struct ethtool_ops netdev_ethtool_ops = {
935
936
937
	.get_drvinfo		= netdev_get_drvinfo,
	.get_settings		= netdev_get_settings,
	.set_settings		= netdev_set_settings,
Florian Fainelli's avatar
Florian Fainelli committed
938
	.get_link		= ethtool_op_get_link,
939
940
};

941
942
943
944
945
946
947
948
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,
949
	.ndo_set_mac_address 	= eth_mac_addr,
950
951
952
953
954
955
956
	.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
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
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
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;
}

1030
1031
1032
1033
1034
1035
1036
1037
1038
1039
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
1040
	int i;
1041

Florian Fainelli's avatar
Florian Fainelli committed
1042
	printk("%s\n", version);
1043
1044
1045

	err = pci_enable_device(pdev);
	if (err)
1046
		goto err_out;
1047
1048

	/* this should always be supported */
1049
	err = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
1050
	if (err) {
1051
		dev_err(&pdev->dev, "32-bit PCI DMA addresses"
1052
				"not supported by the card\n");
1053
		goto err_out;
1054
	}
1055
	err = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
1056
	if (err) {
1057
		dev_err(&pdev->dev, "32-bit PCI DMA addresses"
1058
				"not supported by the card\n");
1059
		goto err_out;
1060
	}
1061
1062

	/* IO Size check */
1063
	if (pci_resource_len(pdev, bar) < io_size) {
1064
		dev_err(&pdev->dev, "Insufficient PCI resources, aborting\n");
1065
1066
		err = -EIO;
		goto err_out;
1067
1068
1069
1070
1071
1072
	}

	pci_set_master(pdev);

	dev = alloc_etherdev(sizeof(struct r6040_private));
	if (!dev) {
1073
		dev_err(&pdev->dev, "Failed to allocate etherdev\n");
1074
1075
		err = -ENOMEM;
		goto err_out;
1076
1077
1078
1079
	}
	SET_NETDEV_DEV(dev, &pdev->dev);
	lp = netdev_priv(dev);

1080
1081
1082
	err = pci_request_regions(pdev, DRV_NAME);

	if (err) {
1083
		dev_err(&pdev->dev, "Failed to request PCI regions\n");
1084
		goto err_out_free_dev;
1085
1086
1087
1088
	}

	ioaddr = pci_iomap(pdev, bar, io_size);
	if (!ioaddr) {
1089
		dev_err(&pdev->dev, "ioremap failed for device\n");
1090
1091
		err = -EIO;
		goto err_out_free_res;
1092
	}
1093
1094
1095
1096
	/* 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);
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112

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

1113
1114
	/* Some bootloader/BIOSes do not initialize
	 * MAC address, warn about that */
1115
	if (!(adrp[0] || adrp[1] || adrp[2])) {
1116
		netdev_warn(dev, "MAC address not initialized, generating random\n");
1117
1118
		random_ether_addr(dev->dev_addr);
	}
1119

1120
1121
	/* Link new device into r6040_root_dev */
	lp->pdev = pdev;
1122
	lp->dev = dev;
1123
1124
1125
1126
1127
1128

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

	/* The RDC-specific entries in the device structure. */
1129
	dev->netdev_ops = &r6040_netdev_ops;
1130
1131
	dev->ethtool_ops = &netdev_ethtool_ops;
	dev->watchdog_timeo = TX_TIMEOUT;
1132

1133
	netif_napi_add(dev, &lp->napi, r6040_poll, 64);
Florian Fainelli's avatar
Florian Fainelli committed
1134
1135
1136
1137

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

Florian Fainelli's avatar
Florian Fainelli committed
1141
1142
1143
1144
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
	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;
	}

1168
1169
1170
	/* Register net device. After this dev->name assign */
	err = register_netdev(dev);
	if (err) {
1171
		dev_err(&pdev->dev, "Failed to register net device\n");
Florian Fainelli's avatar
Florian Fainelli committed
1172
		goto err_out_mdio_unregister;
1173
1174
1175
	}
	return 0;

Florian Fainelli's avatar
Florian Fainelli committed
1176
1177
1178
1179
1180
1181
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);
1182
1183
1184
err_out_unmap:
	pci_iounmap(pdev, ioaddr);
err_out_free_res:
1185
	pci_release_regions(pdev);
1186
err_out_free_dev:
1187
	free_netdev(dev);
1188
err_out:
1189
1190
1191
1192
1193
1194
	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
1195
	struct r6040_private *lp = netdev_priv(dev);
1196
1197

	unregister_netdev(dev);
Florian Fainelli's avatar
Florian Fainelli committed
1198
1199
1200
	mdiobus_unregister(lp->mii_bus);
	kfree(lp->mii_bus->irq);
	mdiobus_free(lp->mii_bus);
1201
1202
1203
1204
1205
1206
1207
	pci_release_regions(pdev);
	free_netdev(dev);
	pci_disable_device(pdev);
	pci_set_drvdata(pdev, NULL);
}


1208
static DEFINE_PCI_DEVICE_TABLE(r6040_pci_tbl) = {
Francois Romieu's avatar
Francois Romieu committed
1209
1210
	{ PCI_DEVICE(PCI_VENDOR_ID_RDC, 0x6040) },
	{ 0 }
1211
1212
1213
1214
};
MODULE_DEVICE_TABLE(pci, r6040_pci_tbl);

static struct pci_driver r6040_driver = {
Francois Romieu's avatar
Francois Romieu committed
1215
	.name		= DRV_NAME,
1216
1217
1218
1219
1220
1221
1222
1223
1224
1225
1226
1227
1228
1229
1230
1231
1232
1233
1234
	.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);