2 * This program is free software; you can redistribute it and/or modify it
3 * under the terms of the GNU General Public License version 2 as published
4 * by the Free Software Foundation.
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) 2011 John Crispin <blogic@openwrt.org>
18 #include <linux/kernel.h>
19 #include <linux/slab.h>
20 #include <linux/errno.h>
21 #include <linux/types.h>
22 #include <linux/interrupt.h>
23 #include <linux/uaccess.h>
25 #include <linux/netdevice.h>
26 #include <linux/etherdevice.h>
27 #include <linux/phy.h>
29 #include <linux/tcp.h>
30 #include <linux/skbuff.h>
32 #include <linux/platform_device.h>
33 #include <linux/ethtool.h>
34 #include <linux/init.h>
35 #include <linux/delay.h>
37 #include <linux/dma-mapping.h>
38 #include <linux/module.h>
40 #include <asm/checksum.h>
42 #include <lantiq_soc.h>
44 #include <lantiq_platform.h>
46 #define LTQ_ETOP_MDIO 0x11804
47 #define MDIO_REQUEST 0x80000000
48 #define MDIO_READ 0x40000000
49 #define MDIO_ADDR_MASK 0x1f
50 #define MDIO_ADDR_OFFSET 0x15
51 #define MDIO_REG_MASK 0x1f
52 #define MDIO_REG_OFFSET 0x10
53 #define MDIO_VAL_MASK 0xffff
55 #define PPE32_CGEN 0x800
56 #define LQ_PPE32_ENET_MAC_CFG 0x1840
58 #define LTQ_ETOP_ENETS0 0x11850
59 #define LTQ_ETOP_MAC_DA0 0x1186C
60 #define LTQ_ETOP_MAC_DA1 0x11870
61 #define LTQ_ETOP_CFG 0x16020
62 #define LTQ_ETOP_IGPLEN 0x16080
64 #define MAX_DMA_CHAN 0x8
65 #define MAX_DMA_CRC_LEN 0x4
66 #define MAX_DMA_DATA_LEN 0x600
68 #define ETOP_FTCU BIT(28)
69 #define ETOP_MII_MASK 0xf
70 #define ETOP_MII_NORMAL 0xd
71 #define ETOP_MII_REVERSE 0xe
72 #define ETOP_PLEN_UNDER 0x40
73 #define ETOP_CGEN 0x800
75 /* use 2 static channels for TX/RX */
76 #define LTQ_ETOP_TX_CHANNEL 1
77 #define LTQ_ETOP_RX_CHANNEL 6
78 #define IS_TX(x) (x == LTQ_ETOP_TX_CHANNEL)
79 #define IS_RX(x) (x == LTQ_ETOP_RX_CHANNEL)
81 #define ltq_etop_r32(x) ltq_r32(ltq_etop_membase + (x))
82 #define ltq_etop_w32(x, y) ltq_w32(x, ltq_etop_membase + (y))
83 #define ltq_etop_w32_mask(x, y, z) \
84 ltq_w32_mask(x, y, ltq_etop_membase + (z))
86 #define DRV_VERSION "1.0"
88 static void __iomem
*ltq_etop_membase
;
90 struct ltq_etop_chan
{
93 struct net_device
*netdev
;
94 struct napi_struct napi
;
95 struct ltq_dma_channel dma
;
96 struct sk_buff
*skb
[LTQ_DESC_NUM
];
99 struct ltq_etop_priv
{
100 struct net_device
*netdev
;
101 struct platform_device
*pdev
;
102 struct ltq_eth_data
*pldata
;
103 struct resource
*res
;
105 struct mii_bus
*mii_bus
;
106 struct phy_device
*phydev
;
108 struct ltq_etop_chan ch
[MAX_DMA_CHAN
];
109 int tx_free
[MAX_DMA_CHAN
>> 1];
115 ltq_etop_alloc_skb(struct ltq_etop_chan
*ch
)
117 ch
->skb
[ch
->dma
.desc
] = dev_alloc_skb(MAX_DMA_DATA_LEN
);
118 if (!ch
->skb
[ch
->dma
.desc
])
120 ch
->dma
.desc_base
[ch
->dma
.desc
].addr
= dma_map_single(NULL
,
121 ch
->skb
[ch
->dma
.desc
]->data
, MAX_DMA_DATA_LEN
,
123 ch
->dma
.desc_base
[ch
->dma
.desc
].addr
=
124 CPHYSADDR(ch
->skb
[ch
->dma
.desc
]->data
);
125 ch
->dma
.desc_base
[ch
->dma
.desc
].ctl
=
126 LTQ_DMA_OWN
| LTQ_DMA_RX_OFFSET(NET_IP_ALIGN
) |
128 skb_reserve(ch
->skb
[ch
->dma
.desc
], NET_IP_ALIGN
);
133 ltq_etop_hw_receive(struct ltq_etop_chan
*ch
)
135 struct ltq_etop_priv
*priv
= netdev_priv(ch
->netdev
);
136 struct ltq_dma_desc
*desc
= &ch
->dma
.desc_base
[ch
->dma
.desc
];
137 struct sk_buff
*skb
= ch
->skb
[ch
->dma
.desc
];
138 int len
= (desc
->ctl
& LTQ_DMA_SIZE_MASK
) - MAX_DMA_CRC_LEN
;
141 spin_lock_irqsave(&priv
->lock
, flags
);
142 if (ltq_etop_alloc_skb(ch
)) {
143 netdev_err(ch
->netdev
,
144 "failed to allocate new rx buffer, stopping DMA\n");
145 ltq_dma_close(&ch
->dma
);
148 ch
->dma
.desc
%= LTQ_DESC_NUM
;
149 spin_unlock_irqrestore(&priv
->lock
, flags
);
152 skb
->dev
= ch
->netdev
;
153 skb
->protocol
= eth_type_trans(skb
, ch
->netdev
);
154 netif_receive_skb(skb
);
158 ltq_etop_poll_rx(struct napi_struct
*napi
, int budget
)
160 struct ltq_etop_chan
*ch
= container_of(napi
,
161 struct ltq_etop_chan
, napi
);
165 while ((rx
< budget
) && !complete
) {
166 struct ltq_dma_desc
*desc
= &ch
->dma
.desc_base
[ch
->dma
.desc
];
168 if ((desc
->ctl
& (LTQ_DMA_OWN
| LTQ_DMA_C
)) == LTQ_DMA_C
) {
169 ltq_etop_hw_receive(ch
);
175 if (complete
|| !rx
) {
176 napi_complete(&ch
->napi
);
177 ltq_dma_ack_irq(&ch
->dma
);
183 ltq_etop_poll_tx(struct napi_struct
*napi
, int budget
)
185 struct ltq_etop_chan
*ch
=
186 container_of(napi
, struct ltq_etop_chan
, napi
);
187 struct ltq_etop_priv
*priv
= netdev_priv(ch
->netdev
);
188 struct netdev_queue
*txq
=
189 netdev_get_tx_queue(ch
->netdev
, ch
->idx
>> 1);
192 spin_lock_irqsave(&priv
->lock
, flags
);
193 while ((ch
->dma
.desc_base
[ch
->tx_free
].ctl
&
194 (LTQ_DMA_OWN
| LTQ_DMA_C
)) == LTQ_DMA_C
) {
195 dev_kfree_skb_any(ch
->skb
[ch
->tx_free
]);
196 ch
->skb
[ch
->tx_free
] = NULL
;
197 memset(&ch
->dma
.desc_base
[ch
->tx_free
], 0,
198 sizeof(struct ltq_dma_desc
));
200 ch
->tx_free
%= LTQ_DESC_NUM
;
202 spin_unlock_irqrestore(&priv
->lock
, flags
);
204 if (netif_tx_queue_stopped(txq
))
205 netif_tx_start_queue(txq
);
206 napi_complete(&ch
->napi
);
207 ltq_dma_ack_irq(&ch
->dma
);
212 ltq_etop_dma_irq(int irq
, void *_priv
)
214 struct ltq_etop_priv
*priv
= _priv
;
215 int ch
= irq
- LTQ_DMA_CH0_INT
;
217 napi_schedule(&priv
->ch
[ch
].napi
);
222 ltq_etop_free_channel(struct net_device
*dev
, struct ltq_etop_chan
*ch
)
224 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
226 ltq_dma_free(&ch
->dma
);
228 free_irq(ch
->dma
.irq
, priv
);
229 if (IS_RX(ch
->idx
)) {
231 for (desc
= 0; desc
< LTQ_DESC_NUM
; desc
++)
232 dev_kfree_skb_any(ch
->skb
[ch
->dma
.desc
]);
237 ltq_etop_hw_exit(struct net_device
*dev
)
239 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
242 ltq_pmu_disable(PMU_PPE
);
243 for (i
= 0; i
< MAX_DMA_CHAN
; i
++)
244 if (IS_TX(i
) || IS_RX(i
))
245 ltq_etop_free_channel(dev
, &priv
->ch
[i
]);
249 ltq_etop_hw_init(struct net_device
*dev
)
251 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
254 ltq_pmu_enable(PMU_PPE
);
256 switch (priv
->pldata
->mii_mode
) {
257 case PHY_INTERFACE_MODE_RMII
:
258 ltq_etop_w32_mask(ETOP_MII_MASK
,
259 ETOP_MII_REVERSE
, LTQ_ETOP_CFG
);
262 case PHY_INTERFACE_MODE_MII
:
263 ltq_etop_w32_mask(ETOP_MII_MASK
,
264 ETOP_MII_NORMAL
, LTQ_ETOP_CFG
);
268 netdev_err(dev
, "unknown mii mode %d\n",
269 priv
->pldata
->mii_mode
);
273 /* enable crc generation */
274 ltq_etop_w32(PPE32_CGEN
, LQ_PPE32_ENET_MAC_CFG
);
276 ltq_dma_init_port(DMA_PORT_ETOP
);
278 for (i
= 0; i
< MAX_DMA_CHAN
; i
++) {
279 int irq
= LTQ_DMA_CH0_INT
+ i
;
280 struct ltq_etop_chan
*ch
= &priv
->ch
[i
];
282 ch
->idx
= ch
->dma
.nr
= i
;
285 ltq_dma_alloc_tx(&ch
->dma
);
286 request_irq(irq
, ltq_etop_dma_irq
, IRQF_DISABLED
,
288 } else if (IS_RX(i
)) {
289 ltq_dma_alloc_rx(&ch
->dma
);
290 for (ch
->dma
.desc
= 0; ch
->dma
.desc
< LTQ_DESC_NUM
;
292 if (ltq_etop_alloc_skb(ch
))
295 request_irq(irq
, ltq_etop_dma_irq
, IRQF_DISABLED
,
304 ltq_etop_get_drvinfo(struct net_device
*dev
, struct ethtool_drvinfo
*info
)
306 strcpy(info
->driver
, "Lantiq ETOP");
307 strcpy(info
->bus_info
, "internal");
308 strcpy(info
->version
, DRV_VERSION
);
312 ltq_etop_get_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
314 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
316 return phy_ethtool_gset(priv
->phydev
, cmd
);
320 ltq_etop_set_settings(struct net_device
*dev
, struct ethtool_cmd
*cmd
)
322 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
324 return phy_ethtool_sset(priv
->phydev
, cmd
);
328 ltq_etop_nway_reset(struct net_device
*dev
)
330 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
332 return phy_start_aneg(priv
->phydev
);
335 static const struct ethtool_ops ltq_etop_ethtool_ops
= {
336 .get_drvinfo
= ltq_etop_get_drvinfo
,
337 .get_settings
= ltq_etop_get_settings
,
338 .set_settings
= ltq_etop_set_settings
,
339 .nway_reset
= ltq_etop_nway_reset
,
343 ltq_etop_mdio_wr(struct mii_bus
*bus
, int phy_addr
, int phy_reg
, u16 phy_data
)
345 u32 val
= MDIO_REQUEST
|
346 ((phy_addr
& MDIO_ADDR_MASK
) << MDIO_ADDR_OFFSET
) |
347 ((phy_reg
& MDIO_REG_MASK
) << MDIO_REG_OFFSET
) |
350 while (ltq_etop_r32(LTQ_ETOP_MDIO
) & MDIO_REQUEST
)
352 ltq_etop_w32(val
, LTQ_ETOP_MDIO
);
357 ltq_etop_mdio_rd(struct mii_bus
*bus
, int phy_addr
, int phy_reg
)
359 u32 val
= MDIO_REQUEST
| MDIO_READ
|
360 ((phy_addr
& MDIO_ADDR_MASK
) << MDIO_ADDR_OFFSET
) |
361 ((phy_reg
& MDIO_REG_MASK
) << MDIO_REG_OFFSET
);
363 while (ltq_etop_r32(LTQ_ETOP_MDIO
) & MDIO_REQUEST
)
365 ltq_etop_w32(val
, LTQ_ETOP_MDIO
);
366 while (ltq_etop_r32(LTQ_ETOP_MDIO
) & MDIO_REQUEST
)
368 val
= ltq_etop_r32(LTQ_ETOP_MDIO
) & MDIO_VAL_MASK
;
373 ltq_etop_mdio_link(struct net_device
*dev
)
379 ltq_etop_mdio_probe(struct net_device
*dev
)
381 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
382 struct phy_device
*phydev
= NULL
;
385 for (phy_addr
= 0; phy_addr
< PHY_MAX_ADDR
; phy_addr
++) {
386 if (priv
->mii_bus
->phy_map
[phy_addr
]) {
387 phydev
= priv
->mii_bus
->phy_map
[phy_addr
];
393 netdev_err(dev
, "no PHY found\n");
397 phydev
= phy_connect(dev
, dev_name(&phydev
->dev
), <q_etop_mdio_link
,
398 0, priv
->pldata
->mii_mode
);
400 if (IS_ERR(phydev
)) {
401 netdev_err(dev
, "Could not attach to PHY\n");
402 return PTR_ERR(phydev
);
405 phydev
->supported
&= (SUPPORTED_10baseT_Half
406 | SUPPORTED_10baseT_Full
407 | SUPPORTED_100baseT_Half
408 | SUPPORTED_100baseT_Full
413 phydev
->advertising
= phydev
->supported
;
414 priv
->phydev
= phydev
;
415 pr_info("%s: attached PHY [%s] (phy_addr=%s, irq=%d)\n",
416 dev
->name
, phydev
->drv
->name
,
417 dev_name(&phydev
->dev
), phydev
->irq
);
423 ltq_etop_mdio_init(struct net_device
*dev
)
425 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
429 priv
->mii_bus
= mdiobus_alloc();
430 if (!priv
->mii_bus
) {
431 netdev_err(dev
, "failed to allocate mii bus\n");
436 priv
->mii_bus
->priv
= dev
;
437 priv
->mii_bus
->read
= ltq_etop_mdio_rd
;
438 priv
->mii_bus
->write
= ltq_etop_mdio_wr
;
439 priv
->mii_bus
->name
= "ltq_mii";
440 snprintf(priv
->mii_bus
->id
, MII_BUS_ID_SIZE
, "%s-%x",
441 priv
->pdev
->name
, priv
->pdev
->id
);
442 priv
->mii_bus
->irq
= kmalloc(sizeof(int) * PHY_MAX_ADDR
, GFP_KERNEL
);
443 if (!priv
->mii_bus
->irq
) {
445 goto err_out_free_mdiobus
;
448 for (i
= 0; i
< PHY_MAX_ADDR
; ++i
)
449 priv
->mii_bus
->irq
[i
] = PHY_POLL
;
451 if (mdiobus_register(priv
->mii_bus
)) {
453 goto err_out_free_mdio_irq
;
456 if (ltq_etop_mdio_probe(dev
)) {
458 goto err_out_unregister_bus
;
462 err_out_unregister_bus
:
463 mdiobus_unregister(priv
->mii_bus
);
464 err_out_free_mdio_irq
:
465 kfree(priv
->mii_bus
->irq
);
466 err_out_free_mdiobus
:
467 mdiobus_free(priv
->mii_bus
);
473 ltq_etop_mdio_cleanup(struct net_device
*dev
)
475 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
477 phy_disconnect(priv
->phydev
);
478 mdiobus_unregister(priv
->mii_bus
);
479 kfree(priv
->mii_bus
->irq
);
480 mdiobus_free(priv
->mii_bus
);
484 ltq_etop_open(struct net_device
*dev
)
486 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
489 for (i
= 0; i
< MAX_DMA_CHAN
; i
++) {
490 struct ltq_etop_chan
*ch
= &priv
->ch
[i
];
492 if (!IS_TX(i
) && (!IS_RX(i
)))
494 ltq_dma_open(&ch
->dma
);
495 napi_enable(&ch
->napi
);
497 phy_start(priv
->phydev
);
498 netif_tx_start_all_queues(dev
);
503 ltq_etop_stop(struct net_device
*dev
)
505 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
508 netif_tx_stop_all_queues(dev
);
509 phy_stop(priv
->phydev
);
510 for (i
= 0; i
< MAX_DMA_CHAN
; i
++) {
511 struct ltq_etop_chan
*ch
= &priv
->ch
[i
];
513 if (!IS_RX(i
) && !IS_TX(i
))
515 napi_disable(&ch
->napi
);
516 ltq_dma_close(&ch
->dma
);
522 ltq_etop_tx(struct sk_buff
*skb
, struct net_device
*dev
)
524 int queue
= skb_get_queue_mapping(skb
);
525 struct netdev_queue
*txq
= netdev_get_tx_queue(dev
, queue
);
526 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
527 struct ltq_etop_chan
*ch
= &priv
->ch
[(queue
<< 1) | 1];
528 struct ltq_dma_desc
*desc
= &ch
->dma
.desc_base
[ch
->dma
.desc
];
533 len
= skb
->len
< ETH_ZLEN
? ETH_ZLEN
: skb
->len
;
535 if ((desc
->ctl
& (LTQ_DMA_OWN
| LTQ_DMA_C
)) || ch
->skb
[ch
->dma
.desc
]) {
536 dev_kfree_skb_any(skb
);
537 netdev_err(dev
, "tx ring full\n");
538 netif_tx_stop_queue(txq
);
539 return NETDEV_TX_BUSY
;
542 /* dma needs to start on a 16 byte aligned address */
543 byte_offset
= CPHYSADDR(skb
->data
) % 16;
544 ch
->skb
[ch
->dma
.desc
] = skb
;
546 dev
->trans_start
= jiffies
;
548 spin_lock_irqsave(&priv
->lock
, flags
);
549 desc
->addr
= ((unsigned int) dma_map_single(NULL
, skb
->data
, len
,
550 DMA_TO_DEVICE
)) - byte_offset
;
552 desc
->ctl
= LTQ_DMA_OWN
| LTQ_DMA_SOP
| LTQ_DMA_EOP
|
553 LTQ_DMA_TX_OFFSET(byte_offset
) | (len
& LTQ_DMA_SIZE_MASK
);
555 ch
->dma
.desc
%= LTQ_DESC_NUM
;
556 spin_unlock_irqrestore(&priv
->lock
, flags
);
558 if (ch
->dma
.desc_base
[ch
->dma
.desc
].ctl
& LTQ_DMA_OWN
)
559 netif_tx_stop_queue(txq
);
565 ltq_etop_change_mtu(struct net_device
*dev
, int new_mtu
)
567 int ret
= eth_change_mtu(dev
, new_mtu
);
570 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
573 spin_lock_irqsave(&priv
->lock
, flags
);
574 ltq_etop_w32((ETOP_PLEN_UNDER
<< 16) | new_mtu
,
576 spin_unlock_irqrestore(&priv
->lock
, flags
);
582 ltq_etop_ioctl(struct net_device
*dev
, struct ifreq
*rq
, int cmd
)
584 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
586 /* TODO: mii-toll reports "No MII transceiver present!." ?!*/
587 return phy_mii_ioctl(priv
->phydev
, rq
, cmd
);
591 ltq_etop_set_mac_address(struct net_device
*dev
, void *p
)
593 int ret
= eth_mac_addr(dev
, p
);
596 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
599 /* store the mac for the unicast filter */
600 spin_lock_irqsave(&priv
->lock
, flags
);
601 ltq_etop_w32(*((u32
*)dev
->dev_addr
), LTQ_ETOP_MAC_DA0
);
602 ltq_etop_w32(*((u16
*)&dev
->dev_addr
[4]) << 16,
604 spin_unlock_irqrestore(&priv
->lock
, flags
);
610 ltq_etop_set_multicast_list(struct net_device
*dev
)
612 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
615 /* ensure that the unicast filter is not enabled in promiscious mode */
616 spin_lock_irqsave(&priv
->lock
, flags
);
617 if ((dev
->flags
& IFF_PROMISC
) || (dev
->flags
& IFF_ALLMULTI
))
618 ltq_etop_w32_mask(ETOP_FTCU
, 0, LTQ_ETOP_ENETS0
);
620 ltq_etop_w32_mask(0, ETOP_FTCU
, LTQ_ETOP_ENETS0
);
621 spin_unlock_irqrestore(&priv
->lock
, flags
);
625 ltq_etop_select_queue(struct net_device
*dev
, struct sk_buff
*skb
)
627 /* we are currently only using the first queue */
632 ltq_etop_init(struct net_device
*dev
)
634 struct ltq_etop_priv
*priv
= netdev_priv(dev
);
639 dev
->watchdog_timeo
= 10 * HZ
;
640 err
= ltq_etop_hw_init(dev
);
643 ltq_etop_change_mtu(dev
, 1500);
645 memcpy(&mac
, &priv
->pldata
->mac
, sizeof(struct sockaddr
));
646 if (!is_valid_ether_addr(mac
.sa_data
)) {
647 pr_warn("etop: invalid MAC, using random\n");
648 random_ether_addr(mac
.sa_data
);
651 err
= ltq_etop_set_mac_address(dev
, &mac
);
654 ltq_etop_set_multicast_list(dev
);
655 err
= ltq_etop_mdio_init(dev
);
661 unregister_netdev(dev
);
664 ltq_etop_hw_exit(dev
);
669 ltq_etop_tx_timeout(struct net_device
*dev
)
673 ltq_etop_hw_exit(dev
);
674 err
= ltq_etop_hw_init(dev
);
677 dev
->trans_start
= jiffies
;
678 netif_wake_queue(dev
);
682 ltq_etop_hw_exit(dev
);
683 netdev_err(dev
, "failed to restart etop after TX timeout\n");
686 static const struct net_device_ops ltq_eth_netdev_ops
= {
687 .ndo_open
= ltq_etop_open
,
688 .ndo_stop
= ltq_etop_stop
,
689 .ndo_start_xmit
= ltq_etop_tx
,
690 .ndo_change_mtu
= ltq_etop_change_mtu
,
691 .ndo_do_ioctl
= ltq_etop_ioctl
,
692 .ndo_set_mac_address
= ltq_etop_set_mac_address
,
693 .ndo_validate_addr
= eth_validate_addr
,
694 .ndo_set_rx_mode
= ltq_etop_set_multicast_list
,
695 .ndo_select_queue
= ltq_etop_select_queue
,
696 .ndo_init
= ltq_etop_init
,
697 .ndo_tx_timeout
= ltq_etop_tx_timeout
,
701 ltq_etop_probe(struct platform_device
*pdev
)
703 struct net_device
*dev
;
704 struct ltq_etop_priv
*priv
;
705 struct resource
*res
;
709 res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
711 dev_err(&pdev
->dev
, "failed to get etop resource\n");
716 res
= devm_request_mem_region(&pdev
->dev
, res
->start
,
717 resource_size(res
), dev_name(&pdev
->dev
));
719 dev_err(&pdev
->dev
, "failed to request etop resource\n");
724 ltq_etop_membase
= devm_ioremap_nocache(&pdev
->dev
,
725 res
->start
, resource_size(res
));
726 if (!ltq_etop_membase
) {
727 dev_err(&pdev
->dev
, "failed to remap etop engine %d\n",
733 dev
= alloc_etherdev_mq(sizeof(struct ltq_etop_priv
), 4);
734 strcpy(dev
->name
, "eth%d");
735 dev
->netdev_ops
= <q_eth_netdev_ops
;
736 dev
->ethtool_ops
= <q_etop_ethtool_ops
;
737 priv
= netdev_priv(dev
);
740 priv
->pldata
= dev_get_platdata(&pdev
->dev
);
742 spin_lock_init(&priv
->lock
);
744 for (i
= 0; i
< MAX_DMA_CHAN
; i
++) {
746 netif_napi_add(dev
, &priv
->ch
[i
].napi
,
747 ltq_etop_poll_tx
, 8);
749 netif_napi_add(dev
, &priv
->ch
[i
].napi
,
750 ltq_etop_poll_rx
, 32);
751 priv
->ch
[i
].netdev
= dev
;
754 err
= register_netdev(dev
);
758 platform_set_drvdata(pdev
, dev
);
768 ltq_etop_remove(struct platform_device
*pdev
)
770 struct net_device
*dev
= platform_get_drvdata(pdev
);
773 netif_tx_stop_all_queues(dev
);
774 ltq_etop_hw_exit(dev
);
775 ltq_etop_mdio_cleanup(dev
);
776 unregister_netdev(dev
);
781 static struct platform_driver ltq_mii_driver
= {
782 .remove
= __devexit_p(ltq_etop_remove
),
785 .owner
= THIS_MODULE
,
792 int ret
= platform_driver_probe(<q_mii_driver
, ltq_etop_probe
);
795 pr_err("ltq_etop: Error registering platfom driver!");
802 platform_driver_unregister(<q_mii_driver
);
805 module_init(init_ltq_etop
);
806 module_exit(exit_ltq_etop
);
808 MODULE_AUTHOR("John Crispin <blogic@openwrt.org>");
809 MODULE_DESCRIPTION("Lantiq SoC ETOP");
810 MODULE_LICENSE("GPL");