2 * This program is free software; you can redistribute it and/or modify
3 * it under the terms of the GNU General Public License as published by
4 * the Free Software Foundation; version 2 of the License
6 * This program is distributed in the hope that it will be useful,
7 * but WITHOUT ANY WARRANTY; without even the implied warranty of
8 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
9 * GNU General Public License for more details.
11 * You should have received a copy of the GNU General Public License
12 * along with this program; if not, write to the Free Software
13 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307, USA.
15 * Copyright (C) 2009 John Crispin <blogic@openwrt.org>
18 #include <linux/module.h>
19 #include <linux/kernel.h>
20 #include <linux/types.h>
21 #include <linux/dma-mapping.h>
22 #include <linux/init.h>
23 #include <linux/skbuff.h>
24 #include <linux/etherdevice.h>
25 #include <linux/ethtool.h>
26 #include <linux/platform_device.h>
27 #include <linux/phy.h>
29 #include <ramips_eth_platform.h>
30 #include "ramips_eth.h"
32 #define TX_TIMEOUT (20 * HZ / 100)
33 #define MAX_RX_LENGTH 1600
35 #ifdef CONFIG_RALINK_RT305X
36 #include "ramips_esw.c"
38 static inline int rt305x_esw_init(void) { return 0; }
39 static inline void rt305x_esw_exit(void) { }
42 #define phys_to_bus(a) (a & 0x1FFFFFFF)
44 #ifdef CONFIG_RAMIPS_ETH_DEBUG
45 #define RADEBUG(fmt, args...) printk(KERN_DEBUG fmt, ## args)
47 #define RADEBUG(fmt, args...) do {} while (0)
50 static struct net_device
* ramips_dev
;
51 static void __iomem
*ramips_fe_base
= 0;
54 ramips_fe_wr(u32 val
, unsigned reg
)
56 __raw_writel(val
, ramips_fe_base
+ reg
);
60 ramips_fe_rr(unsigned reg
)
62 return __raw_readl(ramips_fe_base
+ reg
);
66 ramips_fe_int_disable(u32 mask
)
68 ramips_fe_wr(ramips_fe_rr(RAMIPS_FE_INT_ENABLE
) & ~mask
,
69 RAMIPS_FE_INT_ENABLE
);
71 ramips_fe_rr(RAMIPS_FE_INT_ENABLE
);
75 ramips_fe_int_enable(u32 mask
)
77 ramips_fe_wr(ramips_fe_rr(RAMIPS_FE_INT_ENABLE
) | mask
,
78 RAMIPS_FE_INT_ENABLE
);
80 ramips_fe_rr(RAMIPS_FE_INT_ENABLE
);
84 ramips_hw_set_macaddr(unsigned char *mac
)
86 ramips_fe_wr((mac
[0] << 8) | mac
[1], RAMIPS_GDMA1_MAC_ADRH
);
87 ramips_fe_wr((mac
[2] << 24) | (mac
[3] << 16) | (mac
[4] << 8) | mac
[5],
88 RAMIPS_GDMA1_MAC_ADRL
);
91 static struct sk_buff
*
92 ramips_alloc_skb(struct raeth_priv
*re
)
96 skb
= netdev_alloc_skb(re
->netdev
, MAX_RX_LENGTH
+ NET_IP_ALIGN
);
100 skb_reserve(skb
, NET_IP_ALIGN
);
106 ramips_ring_setup(struct raeth_priv
*re
)
111 memset(re
->tx_info
, 0, NUM_TX_DESC
* sizeof(struct raeth_tx_info
));
113 len
= NUM_TX_DESC
* sizeof(struct ramips_tx_dma
);
114 memset(re
->tx
, 0, len
);
116 for (i
= 0; i
< NUM_TX_DESC
; i
++) {
117 struct raeth_tx_info
*txi
;
118 struct ramips_tx_dma
*txd
;
121 txd
->txd4
= TX_DMA_QN(3) | TX_DMA_PN(1);
122 txd
->txd2
= TX_DMA_LSO
| TX_DMA_DONE
;
124 txi
= &re
->tx_info
[i
];
126 if (txi
->tx_skb
!= NULL
) {
127 netdev_warn(re
->netdev
,
128 "dirty skb for TX desc %d\n", i
);
133 len
= NUM_RX_DESC
* sizeof(struct ramips_rx_dma
);
134 memset(re
->rx
, 0, len
);
136 for (i
= 0; i
< NUM_RX_DESC
; i
++) {
137 struct raeth_rx_info
*rxi
;
138 struct ramips_rx_dma
*rxd
;
142 rxi
= &re
->rx_info
[i
];
143 BUG_ON(rxi
->rx_skb
== NULL
);
144 dma_addr
= dma_map_single(&re
->netdev
->dev
, rxi
->rx_skb
->data
,
145 MAX_RX_LENGTH
, DMA_FROM_DEVICE
);
146 rxi
->rx_dma
= dma_addr
;
149 rxd
->rxd1
= (unsigned int) dma_addr
;
150 rxd
->rxd2
= RX_DMA_LSO
;
153 /* flush descriptors */
158 ramips_ring_cleanup(struct raeth_priv
*re
)
162 for (i
= 0; i
< NUM_RX_DESC
; i
++) {
163 struct raeth_rx_info
*rxi
;
165 rxi
= &re
->rx_info
[i
];
167 dma_unmap_single(&re
->netdev
->dev
, rxi
->rx_dma
,
168 MAX_RX_LENGTH
, DMA_FROM_DEVICE
);
171 for (i
= 0; i
< NUM_TX_DESC
; i
++) {
172 struct raeth_tx_info
*txi
;
174 txi
= &re
->tx_info
[i
];
176 dev_kfree_skb_any(txi
->tx_skb
);
181 netdev_reset_queue(re
->netdev
);
184 #if defined(CONFIG_RALINK_RT288X) || defined(CONFIG_RALINK_RT3883)
186 #define RAMIPS_MDIO_RETRY 1000
188 static unsigned char *ramips_speed_str(struct raeth_priv
*re
)
202 static void ramips_link_adjust(struct raeth_priv
*re
)
204 struct ramips_eth_platform_data
*pdata
;
207 pdata
= re
->parent
->platform_data
;
209 netif_carrier_off(re
->netdev
);
210 netdev_info(re
->netdev
, "link down\n");
214 mdio_cfg
= RAMIPS_MDIO_CFG_TX_CLK_SKEW_200
|
215 RAMIPS_MDIO_CFG_TX_CLK_SKEW_200
|
216 RAMIPS_MDIO_CFG_GP1_FRC_EN
;
218 if (re
->duplex
== DUPLEX_FULL
)
219 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_DUPLEX
;
222 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_FC_TX
;
225 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_FC_RX
;
229 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_SPEED_10
;
232 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_SPEED_100
;
235 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_SPEED_1000
;
241 ramips_fe_wr(mdio_cfg
, RAMIPS_MDIO_CFG
);
243 netif_carrier_on(re
->netdev
);
244 netdev_info(re
->netdev
, "link up (%sMbps/%s duplex)\n",
245 ramips_speed_str(re
),
246 (DUPLEX_FULL
== re
->duplex
) ? "Full" : "Half");
250 ramips_mdio_wait_ready(struct raeth_priv
*re
)
254 retries
= RAMIPS_MDIO_RETRY
;
258 t
= ramips_fe_rr(RAMIPS_MDIO_ACCESS
);
259 if ((t
& (0x1 << 31)) == 0)
268 dev_err(re
->parent
, "MDIO operation timed out\n");
273 ramips_mdio_read(struct mii_bus
*bus
, int phy_addr
, int phy_reg
)
275 struct raeth_priv
*re
= bus
->priv
;
279 err
= ramips_mdio_wait_ready(re
);
283 t
= (phy_addr
<< 24) | (phy_reg
<< 16);
284 ramips_fe_wr(t
, RAMIPS_MDIO_ACCESS
);
286 ramips_fe_wr(t
, RAMIPS_MDIO_ACCESS
);
288 err
= ramips_mdio_wait_ready(re
);
292 RADEBUG("%s: addr=%04x, reg=%04x, value=%04x\n", __func__
,
293 phy_addr
, phy_reg
, ramips_fe_rr(RAMIPS_MDIO_ACCESS
) & 0xffff);
295 return ramips_fe_rr(RAMIPS_MDIO_ACCESS
) & 0xffff;
299 ramips_mdio_write(struct mii_bus
*bus
, int phy_addr
, int phy_reg
, u16 val
)
301 struct raeth_priv
*re
= bus
->priv
;
305 RADEBUG("%s: addr=%04x, reg=%04x, value=%04x\n", __func__
,
306 phy_addr
, phy_reg
, ramips_fe_rr(RAMIPS_MDIO_ACCESS
) & 0xffff);
308 err
= ramips_mdio_wait_ready(re
);
312 t
= (1 << 30) | (phy_addr
<< 24) | (phy_reg
<< 16) | val
;
313 ramips_fe_wr(t
, RAMIPS_MDIO_ACCESS
);
315 ramips_fe_wr(t
, RAMIPS_MDIO_ACCESS
);
317 return ramips_mdio_wait_ready(re
);
321 ramips_mdio_reset(struct mii_bus
*bus
)
328 ramips_mdio_init(struct raeth_priv
*re
)
333 re
->mii_bus
= mdiobus_alloc();
334 if (re
->mii_bus
== NULL
)
337 re
->mii_bus
->name
= "ramips_mdio";
338 re
->mii_bus
->read
= ramips_mdio_read
;
339 re
->mii_bus
->write
= ramips_mdio_write
;
340 re
->mii_bus
->reset
= ramips_mdio_reset
;
341 re
->mii_bus
->irq
= re
->mii_irq
;
342 re
->mii_bus
->priv
= re
;
343 re
->mii_bus
->parent
= re
->parent
;
345 snprintf(re
->mii_bus
->id
, MII_BUS_ID_SIZE
, "%s", "ramips_mdio");
346 re
->mii_bus
->phy_mask
= 0;
348 for (i
= 0; i
< PHY_MAX_ADDR
; i
++)
349 re
->mii_irq
[i
] = PHY_POLL
;
351 err
= mdiobus_register(re
->mii_bus
);
363 ramips_mdio_cleanup(struct raeth_priv
*re
)
365 mdiobus_unregister(re
->mii_bus
);
370 ramips_phy_link_adjust(struct net_device
*dev
)
372 struct raeth_priv
*re
= netdev_priv(dev
);
373 struct phy_device
*phydev
= re
->phy_dev
;
375 int status_change
= 0;
377 spin_lock_irqsave(&re
->phy_lock
, flags
);
380 if (re
->duplex
!= phydev
->duplex
||
381 re
->speed
!= phydev
->speed
)
384 if (phydev
->link
!= re
->link
)
387 re
->link
= phydev
->link
;
388 re
->duplex
= phydev
->duplex
;
389 re
->speed
= phydev
->speed
;
392 ramips_link_adjust(re
);
394 spin_unlock_irqrestore(&re
->phy_lock
, flags
);
398 ramips_phy_connect_multi(struct raeth_priv
*re
)
400 struct net_device
*netdev
= re
->netdev
;
401 struct ramips_eth_platform_data
*pdata
;
402 struct phy_device
*phydev
= NULL
;
406 pdata
= re
->parent
->platform_data
;
407 for (phy_addr
= 0; phy_addr
< PHY_MAX_ADDR
; phy_addr
++) {
408 if (!(pdata
->phy_mask
& (1 << phy_addr
)))
411 if (re
->mii_bus
->phy_map
[phy_addr
] == NULL
)
414 RADEBUG("%s: PHY found at %s, uid=%08x\n",
416 dev_name(&re
->mii_bus
->phy_map
[phy_addr
]->dev
),
417 re
->mii_bus
->phy_map
[phy_addr
]->phy_id
);
420 phydev
= re
->mii_bus
->phy_map
[phy_addr
];
424 netdev_err(netdev
, "no PHY found with phy_mask=%08x\n",
429 re
->phy_dev
= phy_connect(netdev
, dev_name(&phydev
->dev
),
430 ramips_phy_link_adjust
, 0,
433 if (IS_ERR(re
->phy_dev
)) {
434 netdev_err(netdev
, "could not connect to PHY at %s\n",
435 dev_name(&phydev
->dev
));
436 return PTR_ERR(re
->phy_dev
);
439 phydev
->supported
&= PHY_GBIT_FEATURES
;
440 phydev
->advertising
= phydev
->supported
;
442 RADEBUG("%s: connected to PHY at %s [uid=%08x, driver=%s]\n",
443 netdev
->name
, dev_name(&phydev
->dev
),
444 phydev
->phy_id
, phydev
->drv
->name
);
456 ramips_phy_connect_fixed(struct raeth_priv
*re
)
458 struct ramips_eth_platform_data
*pdata
;
460 pdata
= re
->parent
->platform_data
;
461 switch (pdata
->speed
) {
467 netdev_err(re
->netdev
, "invalid speed specified\n");
471 RADEBUG("%s: using fixed link parameters\n", re
->netdev
->name
);
473 re
->speed
= pdata
->speed
;
474 re
->duplex
= pdata
->duplex
;
475 re
->tx_fc
= pdata
->tx_fc
;
476 re
->rx_fc
= pdata
->tx_fc
;
482 ramips_phy_connect(struct raeth_priv
*re
)
484 struct ramips_eth_platform_data
*pdata
;
486 pdata
= re
->parent
->platform_data
;
488 return ramips_phy_connect_multi(re
);
490 return ramips_phy_connect_fixed(re
);
494 ramips_phy_disconnect(struct raeth_priv
*re
)
497 phy_disconnect(re
->phy_dev
);
501 ramips_phy_start(struct raeth_priv
*re
)
506 phy_start(re
->phy_dev
);
508 spin_lock_irqsave(&re
->phy_lock
, flags
);
510 ramips_link_adjust(re
);
511 spin_unlock_irqrestore(&re
->phy_lock
, flags
);
516 ramips_phy_stop(struct raeth_priv
*re
)
521 phy_stop(re
->phy_dev
);
523 spin_lock_irqsave(&re
->phy_lock
, flags
);
525 ramips_link_adjust(re
);
526 spin_unlock_irqrestore(&re
->phy_lock
, flags
);
530 ramips_mdio_init(struct raeth_priv
*re
)
536 ramips_mdio_cleanup(struct raeth_priv
*re
)
541 ramips_phy_connect(struct raeth_priv
*re
)
547 ramips_phy_disconnect(struct raeth_priv
*re
)
552 ramips_phy_start(struct raeth_priv
*re
)
557 ramips_phy_stop(struct raeth_priv
*re
)
560 #endif /* CONFIG_RALINK_RT288X || CONFIG_RALINK_RT3883 */
563 ramips_ring_free(struct raeth_priv
*re
)
569 for (i
= 0; i
< NUM_RX_DESC
; i
++) {
570 struct raeth_rx_info
*rxi
;
572 rxi
= &re
->rx_info
[i
];
574 dev_kfree_skb_any(rxi
->rx_skb
);
580 len
= NUM_RX_DESC
* sizeof(struct ramips_rx_dma
);
581 dma_free_coherent(&re
->netdev
->dev
, len
, re
->rx
,
586 len
= NUM_TX_DESC
* sizeof(struct ramips_tx_dma
);
587 dma_free_coherent(&re
->netdev
->dev
, len
, re
->tx
,
595 ramips_ring_alloc(struct raeth_priv
*re
)
601 re
->tx_info
= kzalloc(NUM_TX_DESC
* sizeof(struct raeth_tx_info
),
606 re
->rx_info
= kzalloc(NUM_RX_DESC
* sizeof(struct raeth_rx_info
),
611 /* allocate tx ring */
612 len
= NUM_TX_DESC
* sizeof(struct ramips_tx_dma
);
613 re
->tx
= dma_alloc_coherent(&re
->netdev
->dev
, len
,
614 &re
->tx_desc_dma
, GFP_ATOMIC
);
618 /* allocate rx ring */
619 len
= NUM_RX_DESC
* sizeof(struct ramips_rx_dma
);
620 re
->rx
= dma_alloc_coherent(&re
->netdev
->dev
, len
,
621 &re
->rx_desc_dma
, GFP_ATOMIC
);
625 for (i
= 0; i
< NUM_RX_DESC
; i
++) {
628 skb
= ramips_alloc_skb(re
);
632 re
->rx_info
[i
].rx_skb
= skb
;
638 ramips_ring_free(re
);
643 ramips_setup_dma(struct raeth_priv
*re
)
645 ramips_fe_wr(re
->tx_desc_dma
, RAMIPS_TX_BASE_PTR0
);
646 ramips_fe_wr(NUM_TX_DESC
, RAMIPS_TX_MAX_CNT0
);
647 ramips_fe_wr(0, RAMIPS_TX_CTX_IDX0
);
648 ramips_fe_wr(RAMIPS_PST_DTX_IDX0
, RAMIPS_PDMA_RST_CFG
);
650 ramips_fe_wr(re
->rx_desc_dma
, RAMIPS_RX_BASE_PTR0
);
651 ramips_fe_wr(NUM_RX_DESC
, RAMIPS_RX_MAX_CNT0
);
652 ramips_fe_wr((NUM_RX_DESC
- 1), RAMIPS_RX_CALC_IDX0
);
653 ramips_fe_wr(RAMIPS_PST_DRX_IDX0
, RAMIPS_PDMA_RST_CFG
);
657 ramips_eth_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
659 struct raeth_priv
*re
= netdev_priv(dev
);
660 struct raeth_tx_info
*txi
, *txi_next
;
661 struct ramips_tx_dma
*txd
, *txd_next
;
663 unsigned int tx_next
;
664 dma_addr_t mapped_addr
;
666 if (re
->plat
->min_pkt_len
) {
667 if (skb
->len
< re
->plat
->min_pkt_len
) {
668 if (skb_padto(skb
, re
->plat
->min_pkt_len
)) {
670 "ramips_eth: skb_padto failed\n");
674 skb_put(skb
, re
->plat
->min_pkt_len
- skb
->len
);
678 dev
->trans_start
= jiffies
;
679 mapped_addr
= dma_map_single(&re
->netdev
->dev
, skb
->data
, skb
->len
,
682 spin_lock(&re
->page_lock
);
683 tx
= ramips_fe_rr(RAMIPS_TX_CTX_IDX0
);
684 tx_next
= (tx
+ 1) % NUM_TX_DESC
;
686 txi
= &re
->tx_info
[tx
];
688 txi_next
= &re
->tx_info
[tx_next
];
689 txd_next
= txi_next
->tx_desc
;
691 if ((txi
->tx_skb
) || (txi_next
->tx_skb
) ||
692 !(txd
->txd2
& TX_DMA_DONE
) ||
693 !(txd_next
->txd2
& TX_DMA_DONE
))
698 txd
->txd1
= (unsigned int) mapped_addr
;
700 txd
->txd2
= TX_DMA_LSO
| TX_DMA_PLEN0(skb
->len
);
701 dev
->stats
.tx_packets
++;
702 dev
->stats
.tx_bytes
+= skb
->len
;
703 ramips_fe_wr(tx_next
, RAMIPS_TX_CTX_IDX0
);
704 netdev_sent_queue(dev
, skb
->len
);
705 spin_unlock(&re
->page_lock
);
709 spin_unlock(&re
->page_lock
);
710 dev
->stats
.tx_dropped
++;
716 ramips_eth_rx_hw(unsigned long ptr
)
718 struct net_device
*dev
= (struct net_device
*) ptr
;
719 struct raeth_priv
*re
= netdev_priv(dev
);
723 rx
= ramips_fe_rr(RAMIPS_RX_CALC_IDX0
);
726 struct raeth_rx_info
*rxi
;
727 struct ramips_rx_dma
*rxd
;
728 struct sk_buff
*rx_skb
, *new_skb
;
731 rx
= (rx
+ 1) % NUM_RX_DESC
;
733 rxi
= &re
->rx_info
[rx
];
735 if (!(rxd
->rxd2
& RX_DMA_DONE
))
738 rx_skb
= rxi
->rx_skb
;
739 pktlen
= RX_DMA_PLEN0(rxd
->rxd2
);
741 new_skb
= ramips_alloc_skb(re
);
742 /* Reuse the buffer on allocation failures */
746 dma_unmap_single(&re
->netdev
->dev
, rxi
->rx_dma
,
747 MAX_RX_LENGTH
, DMA_FROM_DEVICE
);
749 skb_put(rx_skb
, pktlen
);
751 rx_skb
->protocol
= eth_type_trans(rx_skb
, dev
);
752 rx_skb
->ip_summed
= CHECKSUM_NONE
;
753 dev
->stats
.rx_packets
++;
754 dev
->stats
.rx_bytes
+= pktlen
;
757 rxi
->rx_skb
= new_skb
;
759 dma_addr
= dma_map_single(&re
->netdev
->dev
,
763 rxi
->rx_dma
= dma_addr
;
764 rxd
->rxd1
= (unsigned int) dma_addr
;
767 dev
->stats
.rx_dropped
++;
770 rxd
->rxd2
= RX_DMA_LSO
;
771 ramips_fe_wr(rx
, RAMIPS_RX_CALC_IDX0
);
776 tasklet_schedule(&re
->rx_tasklet
);
778 ramips_fe_int_enable(RAMIPS_RX_DLY_INT
);
782 ramips_eth_tx_housekeeping(unsigned long ptr
)
784 struct net_device
*dev
= (struct net_device
*)ptr
;
785 struct raeth_priv
*re
= netdev_priv(dev
);
786 unsigned int bytes_compl
= 0, pkts_compl
= 0;
788 spin_lock(&re
->page_lock
);
790 struct raeth_tx_info
*txi
;
791 struct ramips_tx_dma
*txd
;
793 txi
= &re
->tx_info
[re
->skb_free_idx
];
796 if (!(txd
->txd2
& TX_DMA_DONE
) || !(txi
->tx_skb
))
800 bytes_compl
+= txi
->tx_skb
->len
;
802 dev_kfree_skb_irq(txi
->tx_skb
);
805 if (re
->skb_free_idx
>= NUM_TX_DESC
)
806 re
->skb_free_idx
= 0;
808 netdev_completed_queue(dev
, pkts_compl
, bytes_compl
);
809 spin_unlock(&re
->page_lock
);
811 ramips_fe_int_enable(RAMIPS_TX_DLY_INT
);
815 ramips_eth_timeout(struct net_device
*dev
)
817 struct raeth_priv
*re
= netdev_priv(dev
);
819 tasklet_schedule(&re
->tx_housekeeping_tasklet
);
823 ramips_eth_irq(int irq
, void *dev
)
825 struct raeth_priv
*re
= netdev_priv(dev
);
828 status
= ramips_fe_rr(RAMIPS_FE_INT_STATUS
);
829 status
&= ramips_fe_rr(RAMIPS_FE_INT_ENABLE
);
834 ramips_fe_wr(status
, RAMIPS_FE_INT_STATUS
);
836 if (status
& RAMIPS_RX_DLY_INT
) {
837 ramips_fe_int_disable(RAMIPS_RX_DLY_INT
);
838 tasklet_schedule(&re
->rx_tasklet
);
841 if (status
& RAMIPS_TX_DLY_INT
) {
842 ramips_fe_int_disable(RAMIPS_TX_DLY_INT
);
843 tasklet_schedule(&re
->tx_housekeeping_tasklet
);
846 raeth_debugfs_update_int_stats(re
, status
);
852 ramips_eth_open(struct net_device
*dev
)
854 struct raeth_priv
*re
= netdev_priv(dev
);
857 err
= request_irq(dev
->irq
, ramips_eth_irq
, IRQF_DISABLED
,
862 err
= ramips_ring_alloc(re
);
866 ramips_ring_setup(re
);
867 ramips_hw_set_macaddr(dev
->dev_addr
);
869 ramips_setup_dma(re
);
870 ramips_fe_wr((ramips_fe_rr(RAMIPS_PDMA_GLO_CFG
) & 0xff) |
871 (RAMIPS_TX_WB_DDONE
| RAMIPS_RX_DMA_EN
|
872 RAMIPS_TX_DMA_EN
| RAMIPS_PDMA_SIZE_4DWORDS
),
873 RAMIPS_PDMA_GLO_CFG
);
874 ramips_fe_wr((ramips_fe_rr(RAMIPS_FE_GLO_CFG
) &
875 ~(RAMIPS_US_CYC_CNT_MASK
<< RAMIPS_US_CYC_CNT_SHIFT
)) |
876 ((re
->plat
->sys_freq
/ RAMIPS_US_CYC_CNT_DIVISOR
) << RAMIPS_US_CYC_CNT_SHIFT
),
879 tasklet_init(&re
->tx_housekeeping_tasklet
, ramips_eth_tx_housekeeping
,
881 tasklet_init(&re
->rx_tasklet
, ramips_eth_rx_hw
, (unsigned long)dev
);
883 ramips_phy_start(re
);
885 ramips_fe_wr(RAMIPS_DELAY_INIT
, RAMIPS_DLY_INT_CFG
);
886 ramips_fe_wr(RAMIPS_TX_DLY_INT
| RAMIPS_RX_DLY_INT
, RAMIPS_FE_INT_ENABLE
);
887 ramips_fe_wr(ramips_fe_rr(RAMIPS_GDMA1_FWD_CFG
) &
888 ~(RAMIPS_GDM1_ICS_EN
| RAMIPS_GDM1_TCS_EN
| RAMIPS_GDM1_UCS_EN
| 0xffff),
889 RAMIPS_GDMA1_FWD_CFG
);
890 ramips_fe_wr(ramips_fe_rr(RAMIPS_CDMA_CSG_CFG
) &
891 ~(RAMIPS_ICS_GEN_EN
| RAMIPS_TCS_GEN_EN
| RAMIPS_UCS_GEN_EN
),
892 RAMIPS_CDMA_CSG_CFG
);
893 ramips_fe_wr(RAMIPS_PSE_FQFC_CFG_INIT
, RAMIPS_PSE_FQ_CFG
);
894 ramips_fe_wr(1, RAMIPS_FE_RST_GL
);
895 ramips_fe_wr(0, RAMIPS_FE_RST_GL
);
897 netif_start_queue(dev
);
901 free_irq(dev
->irq
, dev
);
906 ramips_eth_stop(struct net_device
*dev
)
908 struct raeth_priv
*re
= netdev_priv(dev
);
910 ramips_fe_wr(ramips_fe_rr(RAMIPS_PDMA_GLO_CFG
) &
911 ~(RAMIPS_TX_WB_DDONE
| RAMIPS_RX_DMA_EN
| RAMIPS_TX_DMA_EN
),
912 RAMIPS_PDMA_GLO_CFG
);
914 /* disable all interrupts in the hw */
915 ramips_fe_wr(0, RAMIPS_FE_INT_ENABLE
);
918 free_irq(dev
->irq
, dev
);
919 netif_stop_queue(dev
);
920 tasklet_kill(&re
->tx_housekeeping_tasklet
);
921 tasklet_kill(&re
->rx_tasklet
);
922 ramips_ring_cleanup(re
);
923 ramips_ring_free(re
);
924 RADEBUG("ramips_eth: stopped\n");
929 ramips_eth_probe(struct net_device
*dev
)
931 struct raeth_priv
*re
= netdev_priv(dev
);
934 BUG_ON(!re
->plat
->reset_fe
);
935 re
->plat
->reset_fe();
936 net_srandom(jiffies
);
937 memcpy(dev
->dev_addr
, re
->plat
->mac
, ETH_ALEN
);
941 dev
->watchdog_timeo
= TX_TIMEOUT
;
942 spin_lock_init(&re
->page_lock
);
943 spin_lock_init(&re
->phy_lock
);
945 err
= ramips_mdio_init(re
);
949 err
= ramips_phy_connect(re
);
951 goto err_mdio_cleanup
;
953 err
= raeth_debugfs_init(re
);
955 goto err_phy_disconnect
;
960 ramips_phy_disconnect(re
);
962 ramips_mdio_cleanup(re
);
967 ramips_eth_uninit(struct net_device
*dev
)
969 struct raeth_priv
*re
= netdev_priv(dev
);
971 raeth_debugfs_exit(re
);
972 ramips_phy_disconnect(re
);
973 ramips_mdio_cleanup(re
);
976 static const struct net_device_ops ramips_eth_netdev_ops
= {
977 .ndo_init
= ramips_eth_probe
,
978 .ndo_uninit
= ramips_eth_uninit
,
979 .ndo_open
= ramips_eth_open
,
980 .ndo_stop
= ramips_eth_stop
,
981 .ndo_start_xmit
= ramips_eth_hard_start_xmit
,
982 .ndo_tx_timeout
= ramips_eth_timeout
,
983 .ndo_change_mtu
= eth_change_mtu
,
984 .ndo_set_mac_address
= eth_mac_addr
,
985 .ndo_validate_addr
= eth_validate_addr
,
989 ramips_eth_plat_probe(struct platform_device
*plat
)
991 struct raeth_priv
*re
;
992 struct ramips_eth_platform_data
*data
= plat
->dev
.platform_data
;
993 struct resource
*res
;
997 dev_err(&plat
->dev
, "no platform data specified\n");
1001 res
= platform_get_resource(plat
, IORESOURCE_MEM
, 0);
1003 dev_err(&plat
->dev
, "no memory resource found\n");
1007 ramips_fe_base
= ioremap_nocache(res
->start
, res
->end
- res
->start
+ 1);
1008 if (!ramips_fe_base
)
1011 ramips_dev
= alloc_etherdev(sizeof(struct raeth_priv
));
1013 dev_err(&plat
->dev
, "alloc_etherdev failed\n");
1018 strcpy(ramips_dev
->name
, "eth%d");
1019 ramips_dev
->irq
= platform_get_irq(plat
, 0);
1020 if (ramips_dev
->irq
< 0) {
1021 dev_err(&plat
->dev
, "no IRQ resource found\n");
1025 ramips_dev
->addr_len
= ETH_ALEN
;
1026 ramips_dev
->base_addr
= (unsigned long)ramips_fe_base
;
1027 ramips_dev
->netdev_ops
= &ramips_eth_netdev_ops
;
1029 re
= netdev_priv(ramips_dev
);
1031 re
->netdev
= ramips_dev
;
1032 re
->parent
= &plat
->dev
;
1033 re
->speed
= data
->speed
;
1034 re
->duplex
= data
->duplex
;
1035 re
->rx_fc
= data
->rx_fc
;
1036 re
->tx_fc
= data
->tx_fc
;
1039 err
= register_netdev(ramips_dev
);
1041 dev_err(&plat
->dev
, "error bringing up device\n");
1045 RADEBUG("ramips_eth: loaded\n");
1051 iounmap(ramips_fe_base
);
1056 ramips_eth_plat_remove(struct platform_device
*plat
)
1058 unregister_netdev(ramips_dev
);
1059 free_netdev(ramips_dev
);
1060 RADEBUG("ramips_eth: unloaded\n");
1064 static struct platform_driver ramips_eth_driver
= {
1065 .probe
= ramips_eth_plat_probe
,
1066 .remove
= ramips_eth_plat_remove
,
1068 .name
= "ramips_eth",
1069 .owner
= THIS_MODULE
,
1074 ramips_eth_init(void)
1078 ret
= raeth_debugfs_root_init();
1082 ret
= rt305x_esw_init();
1084 goto err_debugfs_exit
;
1086 ret
= platform_driver_register(&ramips_eth_driver
);
1089 "ramips_eth: Error registering platfom driver!\n");
1098 raeth_debugfs_root_exit();
1104 ramips_eth_cleanup(void)
1106 platform_driver_unregister(&ramips_eth_driver
);
1108 raeth_debugfs_root_exit();
1111 module_init(ramips_eth_init
);
1112 module_exit(ramips_eth_cleanup
);
1114 MODULE_LICENSE("GPL");
1115 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
1116 MODULE_DESCRIPTION("ethernet driver for ramips boards");