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
);
105 #if defined(CONFIG_RALINK_RT288X) || defined(CONFIG_RALINK_RT3883)
107 #define RAMIPS_MDIO_RETRY 1000
109 static unsigned char *ramips_speed_str(struct raeth_priv
*re
)
123 static void ramips_link_adjust(struct raeth_priv
*re
)
125 struct ramips_eth_platform_data
*pdata
;
128 pdata
= re
->parent
->platform_data
;
130 netif_carrier_off(re
->netdev
);
131 netdev_info(re
->netdev
, "link down\n");
135 mdio_cfg
= RAMIPS_MDIO_CFG_TX_CLK_SKEW_200
|
136 RAMIPS_MDIO_CFG_TX_CLK_SKEW_200
|
137 RAMIPS_MDIO_CFG_GP1_FRC_EN
;
139 if (re
->duplex
== DUPLEX_FULL
)
140 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_DUPLEX
;
143 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_FC_TX
;
146 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_FC_RX
;
150 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_SPEED_10
;
153 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_SPEED_100
;
156 mdio_cfg
|= RAMIPS_MDIO_CFG_GP1_SPEED_1000
;
162 ramips_fe_wr(mdio_cfg
, RAMIPS_MDIO_CFG
);
164 netif_carrier_on(re
->netdev
);
165 netdev_info(re
->netdev
, "link up (%sMbps/%s duplex)\n",
166 ramips_speed_str(re
),
167 (DUPLEX_FULL
== re
->duplex
) ? "Full" : "Half");
171 ramips_mdio_wait_ready(struct raeth_priv
*re
)
175 retries
= RAMIPS_MDIO_RETRY
;
179 t
= ramips_fe_rr(RAMIPS_MDIO_ACCESS
);
180 if ((t
& (0x1 << 31)) == 0)
189 dev_err(re
->parent
, "MDIO operation timed out\n");
194 ramips_mdio_read(struct mii_bus
*bus
, int phy_addr
, int phy_reg
)
196 struct raeth_priv
*re
= bus
->priv
;
200 err
= ramips_mdio_wait_ready(re
);
204 t
= (phy_addr
<< 24) | (phy_reg
<< 16);
205 ramips_fe_wr(t
, RAMIPS_MDIO_ACCESS
);
207 ramips_fe_wr(t
, RAMIPS_MDIO_ACCESS
);
209 err
= ramips_mdio_wait_ready(re
);
213 RADEBUG("%s: addr=%04x, reg=%04x, value=%04x\n", __func__
,
214 phy_addr
, phy_reg
, ramips_fe_rr(RAMIPS_MDIO_ACCESS
) & 0xffff);
216 return ramips_fe_rr(RAMIPS_MDIO_ACCESS
) & 0xffff;
220 ramips_mdio_write(struct mii_bus
*bus
, int phy_addr
, int phy_reg
, u16 val
)
222 struct raeth_priv
*re
= bus
->priv
;
226 RADEBUG("%s: addr=%04x, reg=%04x, value=%04x\n", __func__
,
227 phy_addr
, phy_reg
, ramips_fe_rr(RAMIPS_MDIO_ACCESS
) & 0xffff);
229 err
= ramips_mdio_wait_ready(re
);
233 t
= (1 << 30) | (phy_addr
<< 24) | (phy_reg
<< 16) | val
;
234 ramips_fe_wr(t
, RAMIPS_MDIO_ACCESS
);
236 ramips_fe_wr(t
, RAMIPS_MDIO_ACCESS
);
238 return ramips_mdio_wait_ready(re
);
242 ramips_mdio_reset(struct mii_bus
*bus
)
249 ramips_mdio_init(struct raeth_priv
*re
)
254 re
->mii_bus
= mdiobus_alloc();
255 if (re
->mii_bus
== NULL
)
258 re
->mii_bus
->name
= "ramips_mdio";
259 re
->mii_bus
->read
= ramips_mdio_read
;
260 re
->mii_bus
->write
= ramips_mdio_write
;
261 re
->mii_bus
->reset
= ramips_mdio_reset
;
262 re
->mii_bus
->irq
= re
->mii_irq
;
263 re
->mii_bus
->priv
= re
;
264 re
->mii_bus
->parent
= re
->parent
;
266 snprintf(re
->mii_bus
->id
, MII_BUS_ID_SIZE
, "%s", "ramips_mdio");
267 re
->mii_bus
->phy_mask
= 0;
269 for (i
= 0; i
< PHY_MAX_ADDR
; i
++)
270 re
->mii_irq
[i
] = PHY_POLL
;
272 err
= mdiobus_register(re
->mii_bus
);
284 ramips_mdio_cleanup(struct raeth_priv
*re
)
286 mdiobus_unregister(re
->mii_bus
);
291 ramips_phy_link_adjust(struct net_device
*dev
)
293 struct raeth_priv
*re
= netdev_priv(dev
);
294 struct phy_device
*phydev
= re
->phy_dev
;
296 int status_change
= 0;
298 spin_lock_irqsave(&re
->phy_lock
, flags
);
301 if (re
->duplex
!= phydev
->duplex
||
302 re
->speed
!= phydev
->speed
)
305 if (phydev
->link
!= re
->link
)
308 re
->link
= phydev
->link
;
309 re
->duplex
= phydev
->duplex
;
310 re
->speed
= phydev
->speed
;
313 ramips_link_adjust(re
);
315 spin_unlock_irqrestore(&re
->phy_lock
, flags
);
319 ramips_phy_connect_multi(struct raeth_priv
*re
)
321 struct net_device
*netdev
= re
->netdev
;
322 struct ramips_eth_platform_data
*pdata
;
323 struct phy_device
*phydev
= NULL
;
327 pdata
= re
->parent
->platform_data
;
328 for (phy_addr
= 0; phy_addr
< PHY_MAX_ADDR
; phy_addr
++) {
329 if (!(pdata
->phy_mask
& (1 << phy_addr
)))
332 if (re
->mii_bus
->phy_map
[phy_addr
] == NULL
)
335 RADEBUG("%s: PHY found at %s, uid=%08x\n",
337 dev_name(&re
->mii_bus
->phy_map
[phy_addr
]->dev
),
338 re
->mii_bus
->phy_map
[phy_addr
]->phy_id
);
341 phydev
= re
->mii_bus
->phy_map
[phy_addr
];
345 netdev_err(netdev
, "no PHY found with phy_mask=%08x\n",
350 re
->phy_dev
= phy_connect(netdev
, dev_name(&phydev
->dev
),
351 ramips_phy_link_adjust
, 0,
354 if (IS_ERR(re
->phy_dev
)) {
355 netdev_err(netdev
, "could not connect to PHY at %s\n",
356 dev_name(&phydev
->dev
));
357 return PTR_ERR(re
->phy_dev
);
360 phydev
->supported
&= PHY_GBIT_FEATURES
;
361 phydev
->advertising
= phydev
->supported
;
363 RADEBUG("%s: connected to PHY at %s [uid=%08x, driver=%s]\n",
364 netdev
->name
, dev_name(&phydev
->dev
),
365 phydev
->phy_id
, phydev
->drv
->name
);
377 ramips_phy_connect_fixed(struct raeth_priv
*re
)
379 struct ramips_eth_platform_data
*pdata
;
381 pdata
= re
->parent
->platform_data
;
382 switch (pdata
->speed
) {
388 netdev_err(re
->netdev
, "invalid speed specified\n");
392 RADEBUG("%s: using fixed link parameters\n", re
->netdev
->name
);
394 re
->speed
= pdata
->speed
;
395 re
->duplex
= pdata
->duplex
;
396 re
->tx_fc
= pdata
->tx_fc
;
397 re
->rx_fc
= pdata
->tx_fc
;
403 ramips_phy_connect(struct raeth_priv
*re
)
405 struct ramips_eth_platform_data
*pdata
;
407 pdata
= re
->parent
->platform_data
;
409 return ramips_phy_connect_multi(re
);
411 return ramips_phy_connect_fixed(re
);
415 ramips_phy_disconnect(struct raeth_priv
*re
)
418 phy_disconnect(re
->phy_dev
);
422 ramips_phy_start(struct raeth_priv
*re
)
427 phy_start(re
->phy_dev
);
429 spin_lock_irqsave(&re
->phy_lock
, flags
);
431 ramips_link_adjust(re
);
432 spin_unlock_irqrestore(&re
->phy_lock
, flags
);
437 ramips_phy_stop(struct raeth_priv
*re
)
442 phy_stop(re
->phy_dev
);
444 spin_lock_irqsave(&re
->phy_lock
, flags
);
446 ramips_link_adjust(re
);
447 spin_unlock_irqrestore(&re
->phy_lock
, flags
);
451 ramips_mdio_init(struct raeth_priv
*re
)
457 ramips_mdio_cleanup(struct raeth_priv
*re
)
462 ramips_phy_connect(struct raeth_priv
*re
)
468 ramips_phy_disconnect(struct raeth_priv
*re
)
473 ramips_phy_start(struct raeth_priv
*re
)
478 ramips_phy_stop(struct raeth_priv
*re
)
481 #endif /* CONFIG_RALINK_RT288X || CONFIG_RALINK_RT3883 */
484 ramips_cleanup_dma(struct raeth_priv
*re
)
488 for (i
= 0; i
< NUM_RX_DESC
; i
++)
490 dma_unmap_single(&re
->netdev
->dev
, re
->rx_dma
[i
],
491 MAX_RX_LENGTH
, DMA_FROM_DEVICE
);
492 dev_kfree_skb_any(re
->rx_skb
[i
]);
496 dma_free_coherent(&re
->netdev
->dev
,
497 NUM_RX_DESC
* sizeof(struct ramips_rx_dma
),
498 re
->rx
, re
->rx_desc_dma
);
501 dma_free_coherent(&re
->netdev
->dev
,
502 NUM_TX_DESC
* sizeof(struct ramips_tx_dma
),
503 re
->tx
, re
->tx_desc_dma
);
507 ramips_alloc_dma(struct raeth_priv
*re
)
512 re
->skb_free_idx
= 0;
515 re
->tx
= dma_alloc_coherent(&re
->netdev
->dev
,
516 NUM_TX_DESC
* sizeof(struct ramips_tx_dma
),
517 &re
->tx_desc_dma
, GFP_ATOMIC
);
521 memset(re
->tx
, 0, NUM_TX_DESC
* sizeof(struct ramips_tx_dma
));
522 for (i
= 0; i
< NUM_TX_DESC
; i
++) {
523 re
->tx
[i
].txd2
= TX_DMA_LSO
| TX_DMA_DONE
;
524 re
->tx
[i
].txd4
= TX_DMA_QN(3) | TX_DMA_PN(1);
528 re
->rx
= dma_alloc_coherent(&re
->netdev
->dev
,
529 NUM_RX_DESC
* sizeof(struct ramips_rx_dma
),
530 &re
->rx_desc_dma
, GFP_ATOMIC
);
534 memset(re
->rx
, 0, sizeof(struct ramips_rx_dma
) * NUM_RX_DESC
);
535 for (i
= 0; i
< NUM_RX_DESC
; i
++) {
537 struct sk_buff
*new_skb
;
539 new_skb
= ramips_alloc_skb(re
);
543 dma_addr
= dma_map_single(&re
->netdev
->dev
, new_skb
->data
,
544 MAX_RX_LENGTH
, DMA_FROM_DEVICE
);
545 re
->rx_dma
[i
] = dma_addr
;
546 re
->rx
[i
].rxd1
= (unsigned int) re
->rx_dma
[i
];
547 re
->rx
[i
].rxd2
|= RX_DMA_LSO
;
548 re
->rx_skb
[i
] = new_skb
;
554 ramips_cleanup_dma(re
);
559 ramips_setup_dma(struct raeth_priv
*re
)
561 ramips_fe_wr(re
->tx_desc_dma
, RAMIPS_TX_BASE_PTR0
);
562 ramips_fe_wr(NUM_TX_DESC
, RAMIPS_TX_MAX_CNT0
);
563 ramips_fe_wr(0, RAMIPS_TX_CTX_IDX0
);
564 ramips_fe_wr(RAMIPS_PST_DTX_IDX0
, RAMIPS_PDMA_RST_CFG
);
566 ramips_fe_wr(re
->rx_desc_dma
, RAMIPS_RX_BASE_PTR0
);
567 ramips_fe_wr(NUM_RX_DESC
, RAMIPS_RX_MAX_CNT0
);
568 ramips_fe_wr((NUM_RX_DESC
- 1), RAMIPS_RX_CALC_IDX0
);
569 ramips_fe_wr(RAMIPS_PST_DRX_IDX0
, RAMIPS_PDMA_RST_CFG
);
573 ramips_eth_hard_start_xmit(struct sk_buff
*skb
, struct net_device
*dev
)
575 struct raeth_priv
*re
= netdev_priv(dev
);
577 unsigned int tx_next
;
578 dma_addr_t mapped_addr
;
580 if (re
->plat
->min_pkt_len
) {
581 if (skb
->len
< re
->plat
->min_pkt_len
) {
582 if (skb_padto(skb
, re
->plat
->min_pkt_len
)) {
584 "ramips_eth: skb_padto failed\n");
588 skb_put(skb
, re
->plat
->min_pkt_len
- skb
->len
);
592 dev
->trans_start
= jiffies
;
593 mapped_addr
= dma_map_single(&re
->netdev
->dev
, skb
->data
, skb
->len
,
596 spin_lock(&re
->page_lock
);
597 tx
= ramips_fe_rr(RAMIPS_TX_CTX_IDX0
);
598 tx_next
= (tx
+ 1) % NUM_TX_DESC
;
600 if ((re
->tx_skb
[tx
]) || (re
->tx_skb
[tx_next
]) ||
601 !(re
->tx
[tx
].txd2
& TX_DMA_DONE
) ||
602 !(re
->tx
[tx_next
].txd2
& TX_DMA_DONE
))
605 re
->tx
[tx
].txd1
= (unsigned int) mapped_addr
;
606 re
->tx
[tx
].txd2
&= ~(TX_DMA_PLEN0_MASK
| TX_DMA_DONE
);
607 re
->tx
[tx
].txd2
|= TX_DMA_PLEN0(skb
->len
);
608 dev
->stats
.tx_packets
++;
609 dev
->stats
.tx_bytes
+= skb
->len
;
610 re
->tx_skb
[tx
] = skb
;
612 ramips_fe_wr(tx_next
, RAMIPS_TX_CTX_IDX0
);
613 spin_unlock(&re
->page_lock
);
617 spin_unlock(&re
->page_lock
);
618 dev
->stats
.tx_dropped
++;
624 ramips_eth_rx_hw(unsigned long ptr
)
626 struct net_device
*dev
= (struct net_device
*) ptr
;
627 struct raeth_priv
*re
= netdev_priv(dev
);
632 struct sk_buff
*rx_skb
, *new_skb
;
635 rx
= (ramips_fe_rr(RAMIPS_RX_CALC_IDX0
) + 1) % NUM_RX_DESC
;
636 if (!(re
->rx
[rx
].rxd2
& RX_DMA_DONE
))
640 rx_skb
= re
->rx_skb
[rx
];
641 pktlen
= RX_DMA_PLEN0(re
->rx
[rx
].rxd2
);
643 new_skb
= ramips_alloc_skb(re
);
644 /* Reuse the buffer on allocation failures */
648 dma_unmap_single(&re
->netdev
->dev
, re
->rx_dma
[rx
],
649 MAX_RX_LENGTH
, DMA_FROM_DEVICE
);
651 skb_put(rx_skb
, pktlen
);
653 rx_skb
->protocol
= eth_type_trans(rx_skb
, dev
);
654 rx_skb
->ip_summed
= CHECKSUM_NONE
;
655 dev
->stats
.rx_packets
++;
656 dev
->stats
.rx_bytes
+= pktlen
;
659 re
->rx_skb
[rx
] = new_skb
;
661 dma_addr
= dma_map_single(&re
->netdev
->dev
,
665 re
->rx_dma
[rx
] = dma_addr
;
666 re
->rx
[rx
].rxd1
= (unsigned int) dma_addr
;
668 dev
->stats
.rx_dropped
++;
671 re
->rx
[rx
].rxd2
&= ~RX_DMA_DONE
;
673 ramips_fe_wr(rx
, RAMIPS_RX_CALC_IDX0
);
677 tasklet_schedule(&re
->rx_tasklet
);
679 ramips_fe_int_enable(RAMIPS_RX_DLY_INT
);
683 ramips_eth_tx_housekeeping(unsigned long ptr
)
685 struct net_device
*dev
= (struct net_device
*)ptr
;
686 struct raeth_priv
*re
= netdev_priv(dev
);
688 spin_lock(&re
->page_lock
);
689 while ((re
->tx
[re
->skb_free_idx
].txd2
& TX_DMA_DONE
) &&
690 (re
->tx_skb
[re
->skb_free_idx
])) {
691 dev_kfree_skb_irq(re
->tx_skb
[re
->skb_free_idx
]);
692 re
->tx_skb
[re
->skb_free_idx
] = 0;
694 if (re
->skb_free_idx
>= NUM_TX_DESC
)
695 re
->skb_free_idx
= 0;
697 spin_unlock(&re
->page_lock
);
699 ramips_fe_int_enable(RAMIPS_TX_DLY_INT
);
703 ramips_eth_timeout(struct net_device
*dev
)
705 struct raeth_priv
*re
= netdev_priv(dev
);
707 tasklet_schedule(&re
->tx_housekeeping_tasklet
);
711 ramips_eth_irq(int irq
, void *dev
)
713 struct raeth_priv
*re
= netdev_priv(dev
);
714 unsigned long fe_int
= ramips_fe_rr(RAMIPS_FE_INT_STATUS
);
716 ramips_fe_wr(0xFFFFFFFF, RAMIPS_FE_INT_STATUS
);
718 if (fe_int
& RAMIPS_RX_DLY_INT
) {
719 ramips_fe_int_disable(RAMIPS_RX_DLY_INT
);
720 tasklet_schedule(&re
->rx_tasklet
);
723 if (fe_int
& RAMIPS_TX_DLY_INT
) {
724 ramips_fe_int_disable(RAMIPS_TX_DLY_INT
);
725 tasklet_schedule(&re
->tx_housekeeping_tasklet
);
732 ramips_eth_open(struct net_device
*dev
)
734 struct raeth_priv
*re
= netdev_priv(dev
);
737 err
= request_irq(dev
->irq
, ramips_eth_irq
, IRQF_DISABLED
,
742 err
= ramips_alloc_dma(re
);
746 ramips_hw_set_macaddr(dev
->dev_addr
);
748 ramips_setup_dma(re
);
749 ramips_fe_wr((ramips_fe_rr(RAMIPS_PDMA_GLO_CFG
) & 0xff) |
750 (RAMIPS_TX_WB_DDONE
| RAMIPS_RX_DMA_EN
|
751 RAMIPS_TX_DMA_EN
| RAMIPS_PDMA_SIZE_4DWORDS
),
752 RAMIPS_PDMA_GLO_CFG
);
753 ramips_fe_wr((ramips_fe_rr(RAMIPS_FE_GLO_CFG
) &
754 ~(RAMIPS_US_CYC_CNT_MASK
<< RAMIPS_US_CYC_CNT_SHIFT
)) |
755 ((re
->plat
->sys_freq
/ RAMIPS_US_CYC_CNT_DIVISOR
) << RAMIPS_US_CYC_CNT_SHIFT
),
758 tasklet_init(&re
->tx_housekeeping_tasklet
, ramips_eth_tx_housekeeping
,
760 tasklet_init(&re
->rx_tasklet
, ramips_eth_rx_hw
, (unsigned long)dev
);
762 ramips_phy_start(re
);
764 ramips_fe_wr(RAMIPS_DELAY_INIT
, RAMIPS_DLY_INT_CFG
);
765 ramips_fe_wr(RAMIPS_TX_DLY_INT
| RAMIPS_RX_DLY_INT
, RAMIPS_FE_INT_ENABLE
);
766 ramips_fe_wr(ramips_fe_rr(RAMIPS_GDMA1_FWD_CFG
) &
767 ~(RAMIPS_GDM1_ICS_EN
| RAMIPS_GDM1_TCS_EN
| RAMIPS_GDM1_UCS_EN
| 0xffff),
768 RAMIPS_GDMA1_FWD_CFG
);
769 ramips_fe_wr(ramips_fe_rr(RAMIPS_CDMA_CSG_CFG
) &
770 ~(RAMIPS_ICS_GEN_EN
| RAMIPS_TCS_GEN_EN
| RAMIPS_UCS_GEN_EN
),
771 RAMIPS_CDMA_CSG_CFG
);
772 ramips_fe_wr(RAMIPS_PSE_FQFC_CFG_INIT
, RAMIPS_PSE_FQ_CFG
);
773 ramips_fe_wr(1, RAMIPS_FE_RST_GL
);
774 ramips_fe_wr(0, RAMIPS_FE_RST_GL
);
776 netif_start_queue(dev
);
780 free_irq(dev
->irq
, dev
);
785 ramips_eth_stop(struct net_device
*dev
)
787 struct raeth_priv
*re
= netdev_priv(dev
);
789 ramips_fe_wr(ramips_fe_rr(RAMIPS_PDMA_GLO_CFG
) &
790 ~(RAMIPS_TX_WB_DDONE
| RAMIPS_RX_DMA_EN
| RAMIPS_TX_DMA_EN
),
791 RAMIPS_PDMA_GLO_CFG
);
793 /* disable all interrupts in the hw */
794 ramips_fe_wr(0, RAMIPS_FE_INT_ENABLE
);
797 free_irq(dev
->irq
, dev
);
798 netif_stop_queue(dev
);
799 tasklet_kill(&re
->tx_housekeeping_tasklet
);
800 tasklet_kill(&re
->rx_tasklet
);
801 ramips_cleanup_dma(re
);
802 RADEBUG("ramips_eth: stopped\n");
807 ramips_eth_probe(struct net_device
*dev
)
809 struct raeth_priv
*re
= netdev_priv(dev
);
812 BUG_ON(!re
->plat
->reset_fe
);
813 re
->plat
->reset_fe();
814 net_srandom(jiffies
);
815 memcpy(dev
->dev_addr
, re
->plat
->mac
, ETH_ALEN
);
819 dev
->watchdog_timeo
= TX_TIMEOUT
;
820 spin_lock_init(&re
->page_lock
);
821 spin_lock_init(&re
->phy_lock
);
823 err
= ramips_mdio_init(re
);
827 err
= ramips_phy_connect(re
);
829 goto err_mdio_cleanup
;
834 ramips_mdio_cleanup(re
);
839 ramips_eth_uninit(struct net_device
*dev
)
841 struct raeth_priv
*re
= netdev_priv(dev
);
843 ramips_phy_disconnect(re
);
844 ramips_mdio_cleanup(re
);
847 static const struct net_device_ops ramips_eth_netdev_ops
= {
848 .ndo_init
= ramips_eth_probe
,
849 .ndo_uninit
= ramips_eth_uninit
,
850 .ndo_open
= ramips_eth_open
,
851 .ndo_stop
= ramips_eth_stop
,
852 .ndo_start_xmit
= ramips_eth_hard_start_xmit
,
853 .ndo_tx_timeout
= ramips_eth_timeout
,
854 .ndo_change_mtu
= eth_change_mtu
,
855 .ndo_set_mac_address
= eth_mac_addr
,
856 .ndo_validate_addr
= eth_validate_addr
,
860 ramips_eth_plat_probe(struct platform_device
*plat
)
862 struct raeth_priv
*re
;
863 struct ramips_eth_platform_data
*data
= plat
->dev
.platform_data
;
864 struct resource
*res
;
868 dev_err(&plat
->dev
, "no platform data specified\n");
872 res
= platform_get_resource(plat
, IORESOURCE_MEM
, 0);
874 dev_err(&plat
->dev
, "no memory resource found\n");
878 ramips_fe_base
= ioremap_nocache(res
->start
, res
->end
- res
->start
+ 1);
882 ramips_dev
= alloc_etherdev(sizeof(struct raeth_priv
));
884 dev_err(&plat
->dev
, "alloc_etherdev failed\n");
889 strcpy(ramips_dev
->name
, "eth%d");
890 ramips_dev
->irq
= platform_get_irq(plat
, 0);
891 if (ramips_dev
->irq
< 0) {
892 dev_err(&plat
->dev
, "no IRQ resource found\n");
896 ramips_dev
->addr_len
= ETH_ALEN
;
897 ramips_dev
->base_addr
= (unsigned long)ramips_fe_base
;
898 ramips_dev
->netdev_ops
= &ramips_eth_netdev_ops
;
900 re
= netdev_priv(ramips_dev
);
902 re
->netdev
= ramips_dev
;
903 re
->parent
= &plat
->dev
;
904 re
->speed
= data
->speed
;
905 re
->duplex
= data
->duplex
;
906 re
->rx_fc
= data
->rx_fc
;
907 re
->tx_fc
= data
->tx_fc
;
910 err
= register_netdev(ramips_dev
);
912 dev_err(&plat
->dev
, "error bringing up device\n");
916 RADEBUG("ramips_eth: loaded\n");
922 iounmap(ramips_fe_base
);
927 ramips_eth_plat_remove(struct platform_device
*plat
)
929 unregister_netdev(ramips_dev
);
930 free_netdev(ramips_dev
);
931 RADEBUG("ramips_eth: unloaded\n");
935 static struct platform_driver ramips_eth_driver
= {
936 .probe
= ramips_eth_plat_probe
,
937 .remove
= ramips_eth_plat_remove
,
939 .name
= "ramips_eth",
940 .owner
= THIS_MODULE
,
945 ramips_eth_init(void)
949 ret
= rt305x_esw_init();
953 ret
= platform_driver_register(&ramips_eth_driver
);
956 "ramips_eth: Error registering platfom driver!\n");
968 ramips_eth_cleanup(void)
970 platform_driver_unregister(&ramips_eth_driver
);
974 module_init(ramips_eth_init
);
975 module_exit(ramips_eth_cleanup
);
977 MODULE_LICENSE("GPL");
978 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
979 MODULE_DESCRIPTION("ethernet driver for ramips boards");