2 * Copyright (c) 2008-2009 Nuvoton technology corporation.
4 * Wan ZongShun <mcuos.com@gmail.com>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation;version 2 of the License.
12 #include <linux/module.h>
13 #include <linux/init.h>
14 #include <linux/mii.h>
15 #include <linux/netdevice.h>
16 #include <linux/etherdevice.h>
17 #include <linux/skbuff.h>
18 #include <linux/ethtool.h>
19 #include <linux/platform_device.h>
20 #include <linux/clk.h>
22 #define DRV_MODULE_NAME "w90p910-emc"
23 #define DRV_MODULE_VERSION "0.1"
25 /* Ethernet MAC Registers */
26 #define REG_CAMCMR 0x00
27 #define REG_CAMEN 0x04
28 #define REG_CAMM_BASE 0x08
29 #define REG_CAML_BASE 0x0c
30 #define REG_TXDLSA 0x88
31 #define REG_RXDLSA 0x8C
32 #define REG_MCMDR 0x90
34 #define REG_MIIDA 0x98
35 #define REG_FFTCR 0x9C
38 #define REG_DMARFC 0xa8
40 #define REG_MISTA 0xb0
41 #define REG_CTXDSA 0xcc
42 #define REG_CTXBSA 0xd0
43 #define REG_CRXDSA 0xd4
44 #define REG_CRXBSA 0xd8
46 /* mac controller bit */
47 #define MCMDR_RXON 0x01
48 #define MCMDR_ACP (0x01 << 3)
49 #define MCMDR_SPCRC (0x01 << 5)
50 #define MCMDR_TXON (0x01 << 8)
51 #define MCMDR_FDUP (0x01 << 18)
52 #define MCMDR_ENMDC (0x01 << 19)
53 #define MCMDR_OPMOD (0x01 << 20)
54 #define SWR (0x01 << 24)
56 /* cam command regiser */
57 #define CAMCMR_AUP 0x01
58 #define CAMCMR_AMP (0x01 << 1)
59 #define CAMCMR_ABP (0x01 << 2)
60 #define CAMCMR_CCAM (0x01 << 3)
61 #define CAMCMR_ECMP (0x01 << 4)
64 /* mac mii controller bit */
65 #define MDCCR (0x0a << 20)
66 #define PHYAD (0x01 << 8)
67 #define PHYWR (0x01 << 16)
68 #define PHYBUSY (0x01 << 17)
69 #define PHYPRESP (0x01 << 18)
70 #define CAM_ENTRY_SIZE 0x08
72 /* rx and tx status */
73 #define TXDS_TXCP (0x01 << 19)
74 #define RXDS_CRCE (0x01 << 17)
75 #define RXDS_PTLE (0x01 << 19)
76 #define RXDS_RXGD (0x01 << 20)
77 #define RXDS_ALIE (0x01 << 21)
78 #define RXDS_RP (0x01 << 22)
80 /* mac interrupt status*/
81 #define MISTA_EXDEF (0x01 << 19)
82 #define MISTA_TXBERR (0x01 << 24)
83 #define MISTA_TDU (0x01 << 23)
84 #define MISTA_RDU (0x01 << 10)
85 #define MISTA_RXBERR (0x01 << 11)
89 #define ENRXGD (0x01 << 4)
90 #define ENRXBERR (0x01 << 11)
91 #define ENTXINTR (0x01 << 16)
92 #define ENTXCP (0x01 << 18)
93 #define ENTXABT (0x01 << 21)
94 #define ENTXBERR (0x01 << 24)
95 #define ENMDC (0x01 << 19)
96 #define PHYBUSY (0x01 << 17)
97 #define MDCCR_VAL 0xa00000
99 /* rx and tx owner bit */
100 #define RX_OWEN_DMA (0x01 << 31)
101 #define RX_OWEN_CPU (~(0x03 << 30))
102 #define TX_OWEN_DMA (0x01 << 31)
103 #define TX_OWEN_CPU (~(0x01 << 31))
105 /* tx frame desc controller bit */
106 #define MACTXINTEN 0x04
108 #define PADDINGMODE 0x01
110 /* fftcr controller bit */
111 #define TXTHD (0x03 << 8)
112 #define BLENGTH (0x01 << 20)
114 /* global setting for driver */
115 #define RX_DESC_SIZE 50
116 #define TX_DESC_SIZE 10
117 #define MAX_RBUFF_SZ 0x600
118 #define MAX_TBUFF_SZ 0x600
119 #define TX_TIMEOUT 50
123 static int w90p910_mdio_read(struct net_device
*dev
, int phy_id
, int reg
);
125 struct w90p910_rxbd
{
128 unsigned int reserved
;
132 struct w90p910_txbd
{
140 struct w90p910_rxbd desclist
[RX_DESC_SIZE
];
141 char recv_buf
[RX_DESC_SIZE
][MAX_RBUFF_SZ
];
145 struct w90p910_txbd desclist
[TX_DESC_SIZE
];
146 char tran_buf
[RX_DESC_SIZE
][MAX_TBUFF_SZ
];
149 struct w90p910_ether
{
150 struct recv_pdesc
*rdesc
;
151 struct recv_pdesc
*rdesc_phys
;
152 struct tran_pdesc
*tdesc
;
153 struct tran_pdesc
*tdesc_phys
;
154 struct net_device_stats stats
;
155 struct platform_device
*pdev
;
159 struct mii_if_info mii
;
160 struct timer_list check_timer
;
166 unsigned int finish_tx
;
167 unsigned int rx_packets
;
168 unsigned int rx_bytes
;
169 unsigned int start_tx_ptr
;
170 unsigned int start_rx_ptr
;
171 unsigned int linkflag
;
175 static void update_linkspeed_register(struct net_device
*dev
,
176 unsigned int speed
, unsigned int duplex
)
178 struct w90p910_ether
*ether
= netdev_priv(dev
);
181 val
= __raw_readl(ether
->reg
+ REG_MCMDR
);
183 if (speed
== SPEED_100
) {
184 /* 100 full/half duplex */
185 if (duplex
== DUPLEX_FULL
) {
186 val
|= (MCMDR_OPMOD
| MCMDR_FDUP
);
192 /* 10 full/half duplex */
193 if (duplex
== DUPLEX_FULL
) {
197 val
&= ~(MCMDR_FDUP
| MCMDR_OPMOD
);
201 __raw_writel(val
, ether
->reg
+ REG_MCMDR
);
204 static void update_linkspeed(struct net_device
*dev
)
206 struct w90p910_ether
*ether
= netdev_priv(dev
);
207 struct platform_device
*pdev
;
208 unsigned int bmsr
, bmcr
, lpa
, speed
, duplex
;
212 if (!mii_link_ok(ðer
->mii
)) {
213 ether
->linkflag
= 0x0;
214 netif_carrier_off(dev
);
215 dev_warn(&pdev
->dev
, "%s: Link down.\n", dev
->name
);
219 if (ether
->linkflag
== 1)
222 bmsr
= w90p910_mdio_read(dev
, ether
->mii
.phy_id
, MII_BMSR
);
223 bmcr
= w90p910_mdio_read(dev
, ether
->mii
.phy_id
, MII_BMCR
);
225 if (bmcr
& BMCR_ANENABLE
) {
226 if (!(bmsr
& BMSR_ANEGCOMPLETE
))
229 lpa
= w90p910_mdio_read(dev
, ether
->mii
.phy_id
, MII_LPA
);
231 if ((lpa
& LPA_100FULL
) || (lpa
& LPA_100HALF
))
236 if ((lpa
& LPA_100FULL
) || (lpa
& LPA_10FULL
))
237 duplex
= DUPLEX_FULL
;
239 duplex
= DUPLEX_HALF
;
242 speed
= (bmcr
& BMCR_SPEED100
) ? SPEED_100
: SPEED_10
;
243 duplex
= (bmcr
& BMCR_FULLDPLX
) ? DUPLEX_FULL
: DUPLEX_HALF
;
246 update_linkspeed_register(dev
, speed
, duplex
);
248 dev_info(&pdev
->dev
, "%s: Link now %i-%s\n", dev
->name
, speed
,
249 (duplex
== DUPLEX_FULL
) ? "FullDuplex" : "HalfDuplex");
250 ether
->linkflag
= 0x01;
252 netif_carrier_on(dev
);
255 static void w90p910_check_link(unsigned long dev_id
)
257 struct net_device
*dev
= (struct net_device
*) dev_id
;
258 struct w90p910_ether
*ether
= netdev_priv(dev
);
260 update_linkspeed(dev
);
261 mod_timer(ðer
->check_timer
, jiffies
+ msecs_to_jiffies(1000));
264 static void w90p910_write_cam(struct net_device
*dev
,
265 unsigned int x
, unsigned char *pval
)
267 struct w90p910_ether
*ether
= netdev_priv(dev
);
268 unsigned int msw
, lsw
;
270 msw
= (pval
[0] << 24) | (pval
[1] << 16) | (pval
[2] << 8) | pval
[3];
272 lsw
= (pval
[4] << 24) | (pval
[5] << 16);
274 __raw_writel(lsw
, ether
->reg
+ REG_CAML_BASE
+ x
* CAM_ENTRY_SIZE
);
275 __raw_writel(msw
, ether
->reg
+ REG_CAMM_BASE
+ x
* CAM_ENTRY_SIZE
);
278 static void w90p910_init_desc(struct net_device
*dev
)
280 struct w90p910_ether
*ether
;
281 struct w90p910_txbd
*tdesc
, *tdesc_phys
;
282 struct w90p910_rxbd
*rdesc
, *rdesc_phys
;
285 ether
= netdev_priv(dev
);
287 ether
->tdesc
= (struct tran_pdesc
*)
288 dma_alloc_coherent(NULL
, sizeof(struct tran_pdesc
),
289 (dma_addr_t
*) ðer
->tdesc_phys
, GFP_KERNEL
);
291 ether
->rdesc
= (struct recv_pdesc
*)
292 dma_alloc_coherent(NULL
, sizeof(struct recv_pdesc
),
293 (dma_addr_t
*) ðer
->rdesc_phys
, GFP_KERNEL
);
295 for (i
= 0; i
< TX_DESC_SIZE
; i
++) {
296 tdesc
= &(ether
->tdesc
->desclist
[i
]);
298 j
= ((i
+ 1) / TX_DESC_SIZE
);
301 tdesc_phys
= &(ether
->tdesc_phys
->desclist
[0]);
302 ether
->start_tx_ptr
= (unsigned int)tdesc_phys
;
303 tdesc
->next
= (unsigned int)ether
->start_tx_ptr
;
305 tdesc_phys
= &(ether
->tdesc_phys
->desclist
[i
+1]);
306 tdesc
->next
= (unsigned int)tdesc_phys
;
309 tdesc
->buffer
= (unsigned int)ether
->tdesc_phys
->tran_buf
[i
];
314 for (i
= 0; i
< RX_DESC_SIZE
; i
++) {
315 rdesc
= &(ether
->rdesc
->desclist
[i
]);
317 j
= ((i
+ 1) / RX_DESC_SIZE
);
320 rdesc_phys
= &(ether
->rdesc_phys
->desclist
[0]);
321 ether
->start_rx_ptr
= (unsigned int)rdesc_phys
;
322 rdesc
->next
= (unsigned int)ether
->start_rx_ptr
;
324 rdesc_phys
= &(ether
->rdesc_phys
->desclist
[i
+1]);
325 rdesc
->next
= (unsigned int)rdesc_phys
;
328 rdesc
->sl
= RX_OWEN_DMA
;
329 rdesc
->buffer
= (unsigned int)ether
->rdesc_phys
->recv_buf
[i
];
333 static void w90p910_set_fifo_threshold(struct net_device
*dev
)
335 struct w90p910_ether
*ether
= netdev_priv(dev
);
338 val
= TXTHD
| BLENGTH
;
339 __raw_writel(val
, ether
->reg
+ REG_FFTCR
);
342 static void w90p910_return_default_idle(struct net_device
*dev
)
344 struct w90p910_ether
*ether
= netdev_priv(dev
);
347 val
= __raw_readl(ether
->reg
+ REG_MCMDR
);
349 __raw_writel(val
, ether
->reg
+ REG_MCMDR
);
352 static void w90p910_trigger_rx(struct net_device
*dev
)
354 struct w90p910_ether
*ether
= netdev_priv(dev
);
356 __raw_writel(ENSTART
, ether
->reg
+ REG_RSDR
);
359 static void w90p910_trigger_tx(struct net_device
*dev
)
361 struct w90p910_ether
*ether
= netdev_priv(dev
);
363 __raw_writel(ENSTART
, ether
->reg
+ REG_TSDR
);
366 static void w90p910_enable_mac_interrupt(struct net_device
*dev
)
368 struct w90p910_ether
*ether
= netdev_priv(dev
);
371 val
= ENTXINTR
| ENRXINTR
| ENRXGD
| ENTXCP
;
372 val
|= ENTXBERR
| ENRXBERR
| ENTXABT
;
374 __raw_writel(val
, ether
->reg
+ REG_MIEN
);
377 static void w90p910_get_and_clear_int(struct net_device
*dev
,
380 struct w90p910_ether
*ether
= netdev_priv(dev
);
382 *val
= __raw_readl(ether
->reg
+ REG_MISTA
);
383 __raw_writel(*val
, ether
->reg
+ REG_MISTA
);
386 static void w90p910_set_global_maccmd(struct net_device
*dev
)
388 struct w90p910_ether
*ether
= netdev_priv(dev
);
391 val
= __raw_readl(ether
->reg
+ REG_MCMDR
);
392 val
|= MCMDR_SPCRC
| MCMDR_ENMDC
| MCMDR_ACP
| ENMDC
;
393 __raw_writel(val
, ether
->reg
+ REG_MCMDR
);
396 static void w90p910_enable_cam(struct net_device
*dev
)
398 struct w90p910_ether
*ether
= netdev_priv(dev
);
401 w90p910_write_cam(dev
, CAM0
, dev
->dev_addr
);
403 val
= __raw_readl(ether
->reg
+ REG_CAMEN
);
405 __raw_writel(val
, ether
->reg
+ REG_CAMEN
);
408 static void w90p910_enable_cam_command(struct net_device
*dev
)
410 struct w90p910_ether
*ether
= netdev_priv(dev
);
413 val
= CAMCMR_ECMP
| CAMCMR_ABP
| CAMCMR_AMP
;
414 __raw_writel(val
, ether
->reg
+ REG_CAMCMR
);
417 static void w90p910_enable_tx(struct net_device
*dev
, unsigned int enable
)
419 struct w90p910_ether
*ether
= netdev_priv(dev
);
422 val
= __raw_readl(ether
->reg
+ REG_MCMDR
);
429 __raw_writel(val
, ether
->reg
+ REG_MCMDR
);
432 static void w90p910_enable_rx(struct net_device
*dev
, unsigned int enable
)
434 struct w90p910_ether
*ether
= netdev_priv(dev
);
437 val
= __raw_readl(ether
->reg
+ REG_MCMDR
);
444 __raw_writel(val
, ether
->reg
+ REG_MCMDR
);
447 static void w90p910_set_curdest(struct net_device
*dev
)
449 struct w90p910_ether
*ether
= netdev_priv(dev
);
451 __raw_writel(ether
->start_rx_ptr
, ether
->reg
+ REG_RXDLSA
);
452 __raw_writel(ether
->start_tx_ptr
, ether
->reg
+ REG_TXDLSA
);
455 static void w90p910_reset_mac(struct net_device
*dev
)
457 struct w90p910_ether
*ether
= netdev_priv(dev
);
459 spin_lock(ðer
->lock
);
461 w90p910_enable_tx(dev
, 0);
462 w90p910_enable_rx(dev
, 0);
463 w90p910_set_fifo_threshold(dev
);
464 w90p910_return_default_idle(dev
);
466 if (!netif_queue_stopped(dev
))
467 netif_stop_queue(dev
);
469 w90p910_init_desc(dev
);
471 dev
->trans_start
= jiffies
;
473 ether
->finish_tx
= 0x0;
476 w90p910_set_curdest(dev
);
477 w90p910_enable_cam(dev
);
478 w90p910_enable_cam_command(dev
);
479 w90p910_enable_mac_interrupt(dev
);
480 w90p910_enable_tx(dev
, 1);
481 w90p910_enable_rx(dev
, 1);
482 w90p910_trigger_tx(dev
);
483 w90p910_trigger_rx(dev
);
485 dev
->trans_start
= jiffies
;
487 if (netif_queue_stopped(dev
))
488 netif_wake_queue(dev
);
490 spin_unlock(ðer
->lock
);
493 static void w90p910_mdio_write(struct net_device
*dev
,
494 int phy_id
, int reg
, int data
)
496 struct w90p910_ether
*ether
= netdev_priv(dev
);
497 struct platform_device
*pdev
;
502 __raw_writel(data
, ether
->reg
+ REG_MIID
);
504 val
= (phy_id
<< 0x08) | reg
;
505 val
|= PHYBUSY
| PHYWR
| MDCCR_VAL
;
506 __raw_writel(val
, ether
->reg
+ REG_MIIDA
);
508 for (i
= 0; i
< DELAY
; i
++) {
509 if ((__raw_readl(ether
->reg
+ REG_MIIDA
) & PHYBUSY
) == 0)
514 dev_warn(&pdev
->dev
, "mdio write timed out\n");
517 static int w90p910_mdio_read(struct net_device
*dev
, int phy_id
, int reg
)
519 struct w90p910_ether
*ether
= netdev_priv(dev
);
520 struct platform_device
*pdev
;
521 unsigned int val
, i
, data
;
525 val
= (phy_id
<< 0x08) | reg
;
526 val
|= PHYBUSY
| MDCCR_VAL
;
527 __raw_writel(val
, ether
->reg
+ REG_MIIDA
);
529 for (i
= 0; i
< DELAY
; i
++) {
530 if ((__raw_readl(ether
->reg
+ REG_MIIDA
) & PHYBUSY
) == 0)
535 dev_warn(&pdev
->dev
, "mdio read timed out\n");
538 data
= __raw_readl(ether
->reg
+ REG_MIID
);
544 static int set_mac_address(struct net_device
*dev
, void *addr
)
546 struct sockaddr
*address
= addr
;
548 if (!is_valid_ether_addr(address
->sa_data
))
549 return -EADDRNOTAVAIL
;
551 memcpy(dev
->dev_addr
, address
->sa_data
, dev
->addr_len
);
552 w90p910_write_cam(dev
, CAM0
, dev
->dev_addr
);
557 static int w90p910_ether_close(struct net_device
*dev
)
559 struct w90p910_ether
*ether
= netdev_priv(dev
);
561 dma_free_writecombine(NULL
, sizeof(struct w90p910_rxbd
),
562 ether
->rdesc
, (dma_addr_t
)ether
->rdesc_phys
);
563 dma_free_writecombine(NULL
, sizeof(struct w90p910_txbd
),
564 ether
->tdesc
, (dma_addr_t
)ether
->tdesc_phys
);
566 netif_stop_queue(dev
);
568 del_timer_sync(ðer
->check_timer
);
569 clk_disable(ether
->rmiiclk
);
570 clk_disable(ether
->clk
);
572 free_irq(ether
->txirq
, dev
);
573 free_irq(ether
->rxirq
, dev
);
578 static struct net_device_stats
*w90p910_ether_stats(struct net_device
*dev
)
580 struct w90p910_ether
*ether
;
582 ether
= netdev_priv(dev
);
584 return ðer
->stats
;
587 static int w90p910_send_frame(struct net_device
*dev
,
588 unsigned char *data
, int length
)
590 struct w90p910_ether
*ether
;
591 struct w90p910_txbd
*txbd
;
592 struct platform_device
*pdev
;
593 unsigned char *buffer
;
595 ether
= netdev_priv(dev
);
598 txbd
= ðer
->tdesc
->desclist
[ether
->cur_tx
];
599 buffer
= ether
->tdesc
->tran_buf
[ether
->cur_tx
];
601 dev_err(&pdev
->dev
, "send data %d bytes, check it\n", length
);
605 txbd
->sl
= length
& 0xFFFF;
607 memcpy(buffer
, data
, length
);
609 txbd
->mode
= TX_OWEN_DMA
| PADDINGMODE
| CRCMODE
| MACTXINTEN
;
611 w90p910_enable_tx(dev
, 1);
613 w90p910_trigger_tx(dev
);
615 ether
->cur_tx
= (ether
->cur_tx
+1) % TX_DESC_SIZE
;
616 txbd
= ðer
->tdesc
->desclist
[ether
->cur_tx
];
618 dev
->trans_start
= jiffies
;
620 if (txbd
->mode
& TX_OWEN_DMA
)
621 netif_stop_queue(dev
);
626 static int w90p910_ether_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
628 struct w90p910_ether
*ether
= netdev_priv(dev
);
630 if (!(w90p910_send_frame(dev
, skb
->data
, skb
->len
))) {
632 dev_kfree_skb_irq(skb
);
638 static irqreturn_t
w90p910_tx_interrupt(int irq
, void *dev_id
)
640 struct w90p910_ether
*ether
;
641 struct w90p910_txbd
*txbd
;
642 struct platform_device
*pdev
;
643 struct tran_pdesc
*tran_pdesc
;
644 struct net_device
*dev
;
645 unsigned int cur_entry
, entry
, status
;
647 dev
= (struct net_device
*)dev_id
;
648 ether
= netdev_priv(dev
);
651 spin_lock(ðer
->lock
);
653 w90p910_get_and_clear_int(dev
, &status
);
655 cur_entry
= __raw_readl(ether
->reg
+ REG_CTXDSA
);
657 tran_pdesc
= ether
->tdesc_phys
;
658 entry
= (unsigned int)(&tran_pdesc
->desclist
[ether
->finish_tx
]);
660 while (entry
!= cur_entry
) {
661 txbd
= ðer
->tdesc
->desclist
[ether
->finish_tx
];
663 ether
->finish_tx
= (ether
->finish_tx
+ 1) % TX_DESC_SIZE
;
665 if (txbd
->sl
& TXDS_TXCP
) {
666 ether
->stats
.tx_packets
++;
667 ether
->stats
.tx_bytes
+= txbd
->sl
& 0xFFFF;
669 ether
->stats
.tx_errors
++;
675 if (netif_queue_stopped(dev
))
676 netif_wake_queue(dev
);
678 entry
= (unsigned int)(&tran_pdesc
->desclist
[ether
->finish_tx
]);
681 if (status
& MISTA_EXDEF
) {
682 dev_err(&pdev
->dev
, "emc defer exceed interrupt\n");
683 } else if (status
& MISTA_TXBERR
) {
684 dev_err(&pdev
->dev
, "emc bus error interrupt\n");
685 w90p910_reset_mac(dev
);
686 } else if (status
& MISTA_TDU
) {
687 if (netif_queue_stopped(dev
))
688 netif_wake_queue(dev
);
691 spin_unlock(ðer
->lock
);
696 static void netdev_rx(struct net_device
*dev
)
698 struct w90p910_ether
*ether
;
699 struct w90p910_rxbd
*rxbd
;
700 struct platform_device
*pdev
;
701 struct recv_pdesc
*rdesc_phys
;
704 unsigned int length
, status
, val
, entry
;
706 ether
= netdev_priv(dev
);
708 rdesc_phys
= ether
->rdesc_phys
;
710 rxbd
= ðer
->rdesc
->desclist
[ether
->cur_rx
];
713 val
= __raw_readl(ether
->reg
+ REG_CRXDSA
);
714 entry
= (unsigned int)&rdesc_phys
->desclist
[ether
->cur_rx
];
720 length
= status
& 0xFFFF;
722 if (status
& RXDS_RXGD
) {
723 data
= ether
->rdesc
->recv_buf
[ether
->cur_rx
];
724 skb
= dev_alloc_skb(length
+2);
726 dev_err(&pdev
->dev
, "get skb buffer error\n");
727 ether
->stats
.rx_dropped
++;
733 skb_put(skb
, length
);
734 skb_copy_to_linear_data(skb
, data
, length
);
735 skb
->protocol
= eth_type_trans(skb
, dev
);
736 ether
->stats
.rx_packets
++;
737 ether
->stats
.rx_bytes
+= length
;
740 ether
->stats
.rx_errors
++;
742 if (status
& RXDS_RP
) {
743 dev_err(&pdev
->dev
, "rx runt err\n");
744 ether
->stats
.rx_length_errors
++;
745 } else if (status
& RXDS_CRCE
) {
746 dev_err(&pdev
->dev
, "rx crc err\n");
747 ether
->stats
.rx_crc_errors
++;
750 if (status
& RXDS_ALIE
) {
751 dev_err(&pdev
->dev
, "rx aligment err\n");
752 ether
->stats
.rx_frame_errors
++;
753 } else if (status
& RXDS_PTLE
) {
754 dev_err(&pdev
->dev
, "rx longer err\n");
755 ether
->stats
.rx_over_errors
++;
759 rxbd
->sl
= RX_OWEN_DMA
;
760 rxbd
->reserved
= 0x0;
761 ether
->cur_rx
= (ether
->cur_rx
+1) % RX_DESC_SIZE
;
762 rxbd
= ðer
->rdesc
->desclist
[ether
->cur_rx
];
764 dev
->last_rx
= jiffies
;
768 static irqreturn_t
w90p910_rx_interrupt(int irq
, void *dev_id
)
770 struct net_device
*dev
;
771 struct w90p910_ether
*ether
;
772 struct platform_device
*pdev
;
775 dev
= (struct net_device
*)dev_id
;
776 ether
= netdev_priv(dev
);
779 spin_lock(ðer
->lock
);
781 w90p910_get_and_clear_int(dev
, &status
);
783 if (status
& MISTA_RDU
) {
786 w90p910_trigger_rx(dev
);
788 spin_unlock(ðer
->lock
);
790 } else if (status
& MISTA_RXBERR
) {
791 dev_err(&pdev
->dev
, "emc rx bus error\n");
792 w90p910_reset_mac(dev
);
796 spin_unlock(ðer
->lock
);
800 static int w90p910_ether_open(struct net_device
*dev
)
802 struct w90p910_ether
*ether
;
803 struct platform_device
*pdev
;
805 ether
= netdev_priv(dev
);
808 w90p910_reset_mac(dev
);
809 w90p910_set_fifo_threshold(dev
);
810 w90p910_set_curdest(dev
);
811 w90p910_enable_cam(dev
);
812 w90p910_enable_cam_command(dev
);
813 w90p910_enable_mac_interrupt(dev
);
814 w90p910_set_global_maccmd(dev
);
815 w90p910_enable_rx(dev
, 1);
817 ether
->rx_packets
= 0x0;
818 ether
->rx_bytes
= 0x0;
820 if (request_irq(ether
->txirq
, w90p910_tx_interrupt
,
821 0x0, pdev
->name
, dev
)) {
822 dev_err(&pdev
->dev
, "register irq tx failed\n");
826 if (request_irq(ether
->rxirq
, w90p910_rx_interrupt
,
827 0x0, pdev
->name
, dev
)) {
828 dev_err(&pdev
->dev
, "register irq rx failed\n");
832 mod_timer(ðer
->check_timer
, jiffies
+ msecs_to_jiffies(1000));
833 netif_start_queue(dev
);
834 w90p910_trigger_rx(dev
);
836 dev_info(&pdev
->dev
, "%s is OPENED\n", dev
->name
);
841 static void w90p910_ether_set_multicast_list(struct net_device
*dev
)
843 struct w90p910_ether
*ether
;
844 unsigned int rx_mode
;
846 ether
= netdev_priv(dev
);
848 if (dev
->flags
& IFF_PROMISC
)
849 rx_mode
= CAMCMR_AUP
| CAMCMR_AMP
| CAMCMR_ABP
| CAMCMR_ECMP
;
850 else if ((dev
->flags
& IFF_ALLMULTI
) || dev
->mc_list
)
851 rx_mode
= CAMCMR_AMP
| CAMCMR_ABP
| CAMCMR_ECMP
;
853 rx_mode
= CAMCMR_ECMP
| CAMCMR_ABP
;
854 __raw_writel(rx_mode
, ether
->reg
+ REG_CAMCMR
);
857 static int w90p910_ether_ioctl(struct net_device
*dev
,
858 struct ifreq
*ifr
, int cmd
)
860 struct w90p910_ether
*ether
= netdev_priv(dev
);
861 struct mii_ioctl_data
*data
= if_mii(ifr
);
863 return generic_mii_ioctl(ðer
->mii
, data
, cmd
, NULL
);
866 static void w90p910_get_drvinfo(struct net_device
*dev
,
867 struct ethtool_drvinfo
*info
)
869 strcpy(info
->driver
, DRV_MODULE_NAME
);
870 strcpy(info
->version
, DRV_MODULE_VERSION
);
873 static int w90p910_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
875 struct w90p910_ether
*ether
= netdev_priv(dev
);
876 return mii_ethtool_gset(ðer
->mii
, cmd
);
879 static int w90p910_set_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
881 struct w90p910_ether
*ether
= netdev_priv(dev
);
882 return mii_ethtool_sset(ðer
->mii
, cmd
);
885 static int w90p910_nway_reset(struct net_device
*dev
)
887 struct w90p910_ether
*ether
= netdev_priv(dev
);
888 return mii_nway_restart(ðer
->mii
);
891 static u32
w90p910_get_link(struct net_device
*dev
)
893 struct w90p910_ether
*ether
= netdev_priv(dev
);
894 return mii_link_ok(ðer
->mii
);
897 static const struct ethtool_ops w90p910_ether_ethtool_ops
= {
898 .get_settings
= w90p910_get_settings
,
899 .set_settings
= w90p910_set_settings
,
900 .get_drvinfo
= w90p910_get_drvinfo
,
901 .nway_reset
= w90p910_nway_reset
,
902 .get_link
= w90p910_get_link
,
905 static const struct net_device_ops w90p910_ether_netdev_ops
= {
906 .ndo_open
= w90p910_ether_open
,
907 .ndo_stop
= w90p910_ether_close
,
908 .ndo_start_xmit
= w90p910_ether_start_xmit
,
909 .ndo_get_stats
= w90p910_ether_stats
,
910 .ndo_set_multicast_list
= w90p910_ether_set_multicast_list
,
911 .ndo_set_mac_address
= set_mac_address
,
912 .ndo_do_ioctl
= w90p910_ether_ioctl
,
913 .ndo_validate_addr
= eth_validate_addr
,
914 .ndo_change_mtu
= eth_change_mtu
,
917 static void __init
get_mac_address(struct net_device
*dev
)
919 struct w90p910_ether
*ether
= netdev_priv(dev
);
920 struct platform_device
*pdev
;
932 if (is_valid_ether_addr(addr
))
933 memcpy(dev
->dev_addr
, &addr
, 0x06);
935 dev_err(&pdev
->dev
, "invalid mac address\n");
938 static int w90p910_ether_setup(struct net_device
*dev
)
940 struct w90p910_ether
*ether
= netdev_priv(dev
);
943 dev
->netdev_ops
= &w90p910_ether_netdev_ops
;
944 dev
->ethtool_ops
= &w90p910_ether_ethtool_ops
;
946 dev
->tx_queue_len
= 16;
948 dev
->watchdog_timeo
= TX_TIMEOUT
;
950 get_mac_address(dev
);
952 spin_lock_init(ðer
->lock
);
956 ether
->finish_tx
= 0x0;
957 ether
->linkflag
= 0x0;
958 ether
->mii
.phy_id
= 0x01;
959 ether
->mii
.phy_id_mask
= 0x1f;
960 ether
->mii
.reg_num_mask
= 0x1f;
961 ether
->mii
.dev
= dev
;
962 ether
->mii
.mdio_read
= w90p910_mdio_read
;
963 ether
->mii
.mdio_write
= w90p910_mdio_write
;
965 setup_timer(ðer
->check_timer
, w90p910_check_link
,
971 static int __devinit
w90p910_ether_probe(struct platform_device
*pdev
)
973 struct w90p910_ether
*ether
;
974 struct net_device
*dev
;
975 struct resource
*res
;
978 dev
= alloc_etherdev(sizeof(struct w90p910_ether
));
982 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
984 dev_err(&pdev
->dev
, "failed to get I/O memory\n");
989 res
= request_mem_region(res
->start
, resource_size(res
), pdev
->name
);
991 dev_err(&pdev
->dev
, "failed to request I/O memory\n");
996 ether
= netdev_priv(dev
);
998 ether
->reg
= ioremap(res
->start
, resource_size(res
));
999 if (ether
->reg
== NULL
) {
1000 dev_err(&pdev
->dev
, "failed to remap I/O memory\n");
1002 goto failed_free_mem
;
1005 ether
->txirq
= platform_get_irq(pdev
, 0);
1006 if (ether
->txirq
< 0) {
1007 dev_err(&pdev
->dev
, "failed to get ether tx irq\n");
1009 goto failed_free_io
;
1012 ether
->rxirq
= platform_get_irq(pdev
, 1);
1013 if (ether
->rxirq
< 0) {
1014 dev_err(&pdev
->dev
, "failed to get ether rx irq\n");
1016 goto failed_free_txirq
;
1019 platform_set_drvdata(pdev
, dev
);
1021 ether
->clk
= clk_get(&pdev
->dev
, NULL
);
1022 if (IS_ERR(ether
->clk
)) {
1023 dev_err(&pdev
->dev
, "failed to get ether clock\n");
1024 error
= PTR_ERR(ether
->clk
);
1025 goto failed_free_rxirq
;
1028 ether
->rmiiclk
= clk_get(&pdev
->dev
, "RMII");
1029 if (IS_ERR(ether
->rmiiclk
)) {
1030 dev_err(&pdev
->dev
, "failed to get ether clock\n");
1031 error
= PTR_ERR(ether
->rmiiclk
);
1032 goto failed_put_clk
;
1037 w90p910_ether_setup(dev
);
1039 error
= register_netdev(dev
);
1041 dev_err(&pdev
->dev
, "Regiter EMC w90p910 FAILED\n");
1043 goto failed_put_rmiiclk
;
1048 clk_put(ether
->rmiiclk
);
1050 clk_put(ether
->clk
);
1052 free_irq(ether
->rxirq
, pdev
);
1053 platform_set_drvdata(pdev
, NULL
);
1055 free_irq(ether
->txirq
, pdev
);
1057 iounmap(ether
->reg
);
1059 release_mem_region(res
->start
, resource_size(res
));
1065 static int __devexit
w90p910_ether_remove(struct platform_device
*pdev
)
1067 struct net_device
*dev
= platform_get_drvdata(pdev
);
1068 struct w90p910_ether
*ether
= netdev_priv(dev
);
1070 unregister_netdev(dev
);
1071 clk_put(ether
->rmiiclk
);
1072 clk_put(ether
->clk
);
1073 del_timer_sync(ðer
->check_timer
);
1074 platform_set_drvdata(pdev
, NULL
);
1079 static struct platform_driver w90p910_ether_driver
= {
1080 .probe
= w90p910_ether_probe
,
1081 .remove
= __devexit_p(w90p910_ether_remove
),
1083 .name
= "nuc900-emc",
1084 .owner
= THIS_MODULE
,
1088 static int __init
w90p910_ether_init(void)
1090 return platform_driver_register(&w90p910_ether_driver
);
1093 static void __exit
w90p910_ether_exit(void)
1095 platform_driver_unregister(&w90p910_ether_driver
);
1098 module_init(w90p910_ether_init
);
1099 module_exit(w90p910_ether_exit
);
1101 MODULE_AUTHOR("Wan ZongShun <mcuos.com@gmail.com>");
1102 MODULE_DESCRIPTION("w90p910 MAC driver!");
1103 MODULE_LICENSE("GPL");
1104 MODULE_ALIAS("platform:nuc900-emc");