2 * Texas Instruments Ethernet Switch Driver
4 * Copyright (C) 2012 Texas Instruments
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License as
8 * published by the Free Software Foundation version 2.
10 * This program is distributed "as is" WITHOUT ANY WARRANTY of any
11 * kind, whether express or implied; without even the implied warranty
12 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
16 #include <linux/kernel.h>
18 #include <linux/clk.h>
19 #include <linux/timer.h>
20 #include <linux/module.h>
21 #include <linux/platform_device.h>
22 #include <linux/irqreturn.h>
23 #include <linux/interrupt.h>
24 #include <linux/if_ether.h>
25 #include <linux/etherdevice.h>
26 #include <linux/netdevice.h>
27 #include <linux/phy.h>
28 #include <linux/workqueue.h>
29 #include <linux/delay.h>
30 #include <linux/pm_runtime.h>
32 #include <linux/of_net.h>
33 #include <linux/of_device.h>
35 #include <linux/platform_data/cpsw.h>
38 #include "davinci_cpdma.h"
40 #define CPSW_DEBUG (NETIF_MSG_HW | NETIF_MSG_WOL | \
41 NETIF_MSG_DRV | NETIF_MSG_LINK | \
42 NETIF_MSG_IFUP | NETIF_MSG_INTR | \
43 NETIF_MSG_PROBE | NETIF_MSG_TIMER | \
44 NETIF_MSG_IFDOWN | NETIF_MSG_RX_ERR | \
45 NETIF_MSG_TX_ERR | NETIF_MSG_TX_DONE | \
46 NETIF_MSG_PKTDATA | NETIF_MSG_TX_QUEUED | \
49 #define cpsw_info(priv, type, format, ...) \
51 if (netif_msg_##type(priv) && net_ratelimit()) \
52 dev_info(priv->dev, format, ## __VA_ARGS__); \
55 #define cpsw_err(priv, type, format, ...) \
57 if (netif_msg_##type(priv) && net_ratelimit()) \
58 dev_err(priv->dev, format, ## __VA_ARGS__); \
61 #define cpsw_dbg(priv, type, format, ...) \
63 if (netif_msg_##type(priv) && net_ratelimit()) \
64 dev_dbg(priv->dev, format, ## __VA_ARGS__); \
67 #define cpsw_notice(priv, type, format, ...) \
69 if (netif_msg_##type(priv) && net_ratelimit()) \
70 dev_notice(priv->dev, format, ## __VA_ARGS__); \
73 #define CPSW_MAJOR_VERSION(reg) (reg >> 8 & 0x7)
74 #define CPSW_MINOR_VERSION(reg) (reg & 0xff)
75 #define CPSW_RTL_VERSION(reg) ((reg >> 11) & 0x1f)
77 #define CPDMA_RXTHRESH 0x0c0
78 #define CPDMA_RXFREE 0x0e0
79 #define CPDMA_TXHDP 0x00
80 #define CPDMA_RXHDP 0x20
81 #define CPDMA_TXCP 0x40
82 #define CPDMA_RXCP 0x60
84 #define cpsw_dma_regs(base, offset) \
85 (void __iomem *)((base) + (offset))
86 #define cpsw_dma_rxthresh(base, offset) \
87 (void __iomem *)((base) + (offset) + CPDMA_RXTHRESH)
88 #define cpsw_dma_rxfree(base, offset) \
89 (void __iomem *)((base) + (offset) + CPDMA_RXFREE)
90 #define cpsw_dma_txhdp(base, offset) \
91 (void __iomem *)((base) + (offset) + CPDMA_TXHDP)
92 #define cpsw_dma_rxhdp(base, offset) \
93 (void __iomem *)((base) + (offset) + CPDMA_RXHDP)
94 #define cpsw_dma_txcp(base, offset) \
95 (void __iomem *)((base) + (offset) + CPDMA_TXCP)
96 #define cpsw_dma_rxcp(base, offset) \
97 (void __iomem *)((base) + (offset) + CPDMA_RXCP)
99 #define CPSW_POLL_WEIGHT 64
100 #define CPSW_MIN_PACKET_SIZE 60
101 #define CPSW_MAX_PACKET_SIZE (1500 + 14 + 4 + 4)
103 #define RX_PRIORITY_MAPPING 0x76543210
104 #define TX_PRIORITY_MAPPING 0x33221100
105 #define CPDMA_TX_PRIORITY_MAP 0x76543210
107 #define cpsw_enable_irq(priv) \
110 for (i = 0; i < priv->num_irqs; i++) \
111 enable_irq(priv->irqs_table[i]); \
113 #define cpsw_disable_irq(priv) \
116 for (i = 0; i < priv->num_irqs; i++) \
117 disable_irq_nosync(priv->irqs_table[i]); \
120 static int debug_level
;
121 module_param(debug_level
, int, 0);
122 MODULE_PARM_DESC(debug_level
, "cpsw debug level (NETIF_MSG bits)");
124 static int ale_ageout
= 10;
125 module_param(ale_ageout
, int, 0);
126 MODULE_PARM_DESC(ale_ageout
, "cpsw ale ageout interval (seconds)");
128 static int rx_packet_max
= CPSW_MAX_PACKET_SIZE
;
129 module_param(rx_packet_max
, int, 0);
130 MODULE_PARM_DESC(rx_packet_max
, "maximum receive packet size (bytes)");
132 struct cpsw_ss_regs
{
151 struct cpsw_slave_regs
{
164 struct cpsw_host_regs
{
170 u32 cpdma_tx_pri_map
;
171 u32 cpdma_rx_chan_map
;
174 struct cpsw_sliver_regs
{
188 struct cpsw_slave_regs __iomem
*regs
;
189 struct cpsw_sliver_regs __iomem
*sliver
;
192 struct cpsw_slave_data
*data
;
193 struct phy_device
*phy
;
198 struct platform_device
*pdev
;
199 struct net_device
*ndev
;
200 struct resource
*cpsw_res
;
201 struct resource
*cpsw_ss_res
;
202 struct napi_struct napi
;
204 struct cpsw_platform_data data
;
205 struct cpsw_regs __iomem
*regs
;
206 struct cpsw_ss_regs __iomem
*ss_regs
;
207 struct cpsw_host_regs __iomem
*host_port_regs
;
209 struct net_device_stats stats
;
213 u8 mac_addr
[ETH_ALEN
];
214 struct cpsw_slave
*slaves
;
215 struct cpdma_ctlr
*dma
;
216 struct cpdma_chan
*txch
, *rxch
;
217 struct cpsw_ale
*ale
;
218 /* snapshot of IRQ numbers */
223 #define napi_to_priv(napi) container_of(napi, struct cpsw_priv, napi)
224 #define for_each_slave(priv, func, arg...) \
227 for (idx = 0; idx < (priv)->data.slaves; idx++) \
228 (func)((priv)->slaves + idx, ##arg); \
231 static void cpsw_intr_enable(struct cpsw_priv
*priv
)
233 __raw_writel(0xFF, &priv
->ss_regs
->tx_en
);
234 __raw_writel(0xFF, &priv
->ss_regs
->rx_en
);
236 cpdma_ctlr_int_ctrl(priv
->dma
, true);
240 static void cpsw_intr_disable(struct cpsw_priv
*priv
)
242 __raw_writel(0, &priv
->ss_regs
->tx_en
);
243 __raw_writel(0, &priv
->ss_regs
->rx_en
);
245 cpdma_ctlr_int_ctrl(priv
->dma
, false);
249 void cpsw_tx_handler(void *token
, int len
, int status
)
251 struct sk_buff
*skb
= token
;
252 struct net_device
*ndev
= skb
->dev
;
253 struct cpsw_priv
*priv
= netdev_priv(ndev
);
255 if (unlikely(netif_queue_stopped(ndev
)))
256 netif_start_queue(ndev
);
257 priv
->stats
.tx_packets
++;
258 priv
->stats
.tx_bytes
+= len
;
259 dev_kfree_skb_any(skb
);
262 void cpsw_rx_handler(void *token
, int len
, int status
)
264 struct sk_buff
*skb
= token
;
265 struct net_device
*ndev
= skb
->dev
;
266 struct cpsw_priv
*priv
= netdev_priv(ndev
);
269 /* free and bail if we are shutting down */
270 if (unlikely(!netif_running(ndev
)) ||
271 unlikely(!netif_carrier_ok(ndev
))) {
272 dev_kfree_skb_any(skb
);
275 if (likely(status
>= 0)) {
277 skb
->protocol
= eth_type_trans(skb
, ndev
);
278 netif_receive_skb(skb
);
279 priv
->stats
.rx_bytes
+= len
;
280 priv
->stats
.rx_packets
++;
284 if (unlikely(!netif_running(ndev
))) {
286 dev_kfree_skb_any(skb
);
291 skb
= netdev_alloc_skb_ip_align(ndev
, priv
->rx_packet_max
);
295 ret
= cpdma_chan_submit(priv
->rxch
, skb
, skb
->data
,
296 skb_tailroom(skb
), GFP_KERNEL
);
301 static irqreturn_t
cpsw_interrupt(int irq
, void *dev_id
)
303 struct cpsw_priv
*priv
= dev_id
;
305 if (likely(netif_running(priv
->ndev
))) {
306 cpsw_intr_disable(priv
);
307 cpsw_disable_irq(priv
);
308 napi_schedule(&priv
->napi
);
313 static inline int cpsw_get_slave_port(struct cpsw_priv
*priv
, u32 slave_num
)
315 if (priv
->host_port
== 0)
316 return slave_num
+ 1;
321 static int cpsw_poll(struct napi_struct
*napi
, int budget
)
323 struct cpsw_priv
*priv
= napi_to_priv(napi
);
326 num_tx
= cpdma_chan_process(priv
->txch
, 128);
327 num_rx
= cpdma_chan_process(priv
->rxch
, budget
);
329 if (num_rx
|| num_tx
)
330 cpsw_dbg(priv
, intr
, "poll %d rx, %d tx pkts\n",
333 if (num_rx
< budget
) {
335 cpsw_intr_enable(priv
);
336 cpdma_ctlr_eoi(priv
->dma
);
337 cpsw_enable_irq(priv
);
343 static inline void soft_reset(const char *module
, void __iomem
*reg
)
345 unsigned long timeout
= jiffies
+ HZ
;
347 __raw_writel(1, reg
);
350 } while ((__raw_readl(reg
) & 1) && time_after(timeout
, jiffies
));
352 WARN(__raw_readl(reg
) & 1, "failed to soft-reset %s\n", module
);
355 #define mac_hi(mac) (((mac)[0] << 0) | ((mac)[1] << 8) | \
356 ((mac)[2] << 16) | ((mac)[3] << 24))
357 #define mac_lo(mac) (((mac)[4] << 0) | ((mac)[5] << 8))
359 static void cpsw_set_slave_mac(struct cpsw_slave
*slave
,
360 struct cpsw_priv
*priv
)
362 __raw_writel(mac_hi(priv
->mac_addr
), &slave
->regs
->sa_hi
);
363 __raw_writel(mac_lo(priv
->mac_addr
), &slave
->regs
->sa_lo
);
366 static void _cpsw_adjust_link(struct cpsw_slave
*slave
,
367 struct cpsw_priv
*priv
, bool *link
)
369 struct phy_device
*phy
= slave
->phy
;
376 slave_port
= cpsw_get_slave_port(priv
, slave
->slave_num
);
379 mac_control
= priv
->data
.mac_control
;
381 /* enable forwarding */
382 cpsw_ale_control_set(priv
->ale
, slave_port
,
383 ALE_PORT_STATE
, ALE_PORT_STATE_FORWARD
);
385 if (phy
->speed
== 1000)
386 mac_control
|= BIT(7); /* GIGABITEN */
388 mac_control
|= BIT(0); /* FULLDUPLEXEN */
390 /* set speed_in input in case RMII mode is used in 100Mbps */
391 if (phy
->speed
== 100)
392 mac_control
|= BIT(15);
397 /* disable forwarding */
398 cpsw_ale_control_set(priv
->ale
, slave_port
,
399 ALE_PORT_STATE
, ALE_PORT_STATE_DISABLE
);
402 if (mac_control
!= slave
->mac_control
) {
403 phy_print_status(phy
);
404 __raw_writel(mac_control
, &slave
->sliver
->mac_control
);
407 slave
->mac_control
= mac_control
;
410 static void cpsw_adjust_link(struct net_device
*ndev
)
412 struct cpsw_priv
*priv
= netdev_priv(ndev
);
415 for_each_slave(priv
, _cpsw_adjust_link
, priv
, &link
);
418 netif_carrier_on(ndev
);
419 if (netif_running(ndev
))
420 netif_wake_queue(ndev
);
422 netif_carrier_off(ndev
);
423 netif_stop_queue(ndev
);
427 static inline int __show_stat(char *buf
, int maxlen
, const char *name
, u32 val
)
429 static char *leader
= "........................................";
434 return snprintf(buf
, maxlen
, "%s %s %10d\n", name
,
435 leader
+ strlen(name
), val
);
438 static void cpsw_slave_open(struct cpsw_slave
*slave
, struct cpsw_priv
*priv
)
443 sprintf(name
, "slave-%d", slave
->slave_num
);
445 soft_reset(name
, &slave
->sliver
->soft_reset
);
447 /* setup priority mapping */
448 __raw_writel(RX_PRIORITY_MAPPING
, &slave
->sliver
->rx_pri_map
);
449 __raw_writel(TX_PRIORITY_MAPPING
, &slave
->regs
->tx_pri_map
);
451 /* setup max packet size, and mac address */
452 __raw_writel(priv
->rx_packet_max
, &slave
->sliver
->rx_maxlen
);
453 cpsw_set_slave_mac(slave
, priv
);
455 slave
->mac_control
= 0; /* no link yet */
457 slave_port
= cpsw_get_slave_port(priv
, slave
->slave_num
);
459 cpsw_ale_add_mcast(priv
->ale
, priv
->ndev
->broadcast
,
460 1 << slave_port
, 0, ALE_MCAST_FWD_2
);
462 slave
->phy
= phy_connect(priv
->ndev
, slave
->data
->phy_id
,
463 &cpsw_adjust_link
, 0, slave
->data
->phy_if
);
464 if (IS_ERR(slave
->phy
)) {
465 dev_err(priv
->dev
, "phy %s not found on slave %d\n",
466 slave
->data
->phy_id
, slave
->slave_num
);
469 dev_info(priv
->dev
, "phy found : id is : 0x%x\n",
471 phy_start(slave
->phy
);
475 static void cpsw_init_host_port(struct cpsw_priv
*priv
)
477 /* soft reset the controller and initialize ale */
478 soft_reset("cpsw", &priv
->regs
->soft_reset
);
479 cpsw_ale_start(priv
->ale
);
481 /* switch to vlan unaware mode */
482 cpsw_ale_control_set(priv
->ale
, 0, ALE_VLAN_AWARE
, 0);
484 /* setup host port priority mapping */
485 __raw_writel(CPDMA_TX_PRIORITY_MAP
,
486 &priv
->host_port_regs
->cpdma_tx_pri_map
);
487 __raw_writel(0, &priv
->host_port_regs
->cpdma_rx_chan_map
);
489 cpsw_ale_control_set(priv
->ale
, priv
->host_port
,
490 ALE_PORT_STATE
, ALE_PORT_STATE_FORWARD
);
492 cpsw_ale_add_ucast(priv
->ale
, priv
->mac_addr
, priv
->host_port
, 0);
493 cpsw_ale_add_mcast(priv
->ale
, priv
->ndev
->broadcast
,
494 1 << priv
->host_port
, 0, ALE_MCAST_FWD_2
);
497 static int cpsw_ndo_open(struct net_device
*ndev
)
499 struct cpsw_priv
*priv
= netdev_priv(ndev
);
503 cpsw_intr_disable(priv
);
504 netif_carrier_off(ndev
);
506 pm_runtime_get_sync(&priv
->pdev
->dev
);
508 reg
= __raw_readl(&priv
->regs
->id_ver
);
510 dev_info(priv
->dev
, "initializing cpsw version %d.%d (%d)\n",
511 CPSW_MAJOR_VERSION(reg
), CPSW_MINOR_VERSION(reg
),
512 CPSW_RTL_VERSION(reg
));
514 /* initialize host and slave ports */
515 cpsw_init_host_port(priv
);
516 for_each_slave(priv
, cpsw_slave_open
, priv
);
518 /* setup tx dma to fixed prio and zero offset */
519 cpdma_control_set(priv
->dma
, CPDMA_TX_PRIO_FIXED
, 1);
520 cpdma_control_set(priv
->dma
, CPDMA_RX_BUFFER_OFFSET
, 0);
522 /* disable priority elevation and enable statistics on all ports */
523 __raw_writel(0, &priv
->regs
->ptype
);
525 /* enable statistics collection only on the host port */
526 __raw_writel(0x7, &priv
->regs
->stat_port_en
);
528 if (WARN_ON(!priv
->data
.rx_descs
))
529 priv
->data
.rx_descs
= 128;
531 for (i
= 0; i
< priv
->data
.rx_descs
; i
++) {
535 skb
= netdev_alloc_skb_ip_align(priv
->ndev
,
536 priv
->rx_packet_max
);
539 ret
= cpdma_chan_submit(priv
->rxch
, skb
, skb
->data
,
540 skb_tailroom(skb
), GFP_KERNEL
);
541 if (WARN_ON(ret
< 0))
544 /* continue even if we didn't manage to submit all receive descs */
545 cpsw_info(priv
, ifup
, "submitted %d rx descriptors\n", i
);
547 cpdma_ctlr_start(priv
->dma
);
548 cpsw_intr_enable(priv
);
549 napi_enable(&priv
->napi
);
550 cpdma_ctlr_eoi(priv
->dma
);
555 static void cpsw_slave_stop(struct cpsw_slave
*slave
, struct cpsw_priv
*priv
)
559 phy_stop(slave
->phy
);
560 phy_disconnect(slave
->phy
);
564 static int cpsw_ndo_stop(struct net_device
*ndev
)
566 struct cpsw_priv
*priv
= netdev_priv(ndev
);
568 cpsw_info(priv
, ifdown
, "shutting down cpsw device\n");
569 cpsw_intr_disable(priv
);
570 cpdma_ctlr_int_ctrl(priv
->dma
, false);
571 cpdma_ctlr_stop(priv
->dma
);
572 netif_stop_queue(priv
->ndev
);
573 napi_disable(&priv
->napi
);
574 netif_carrier_off(priv
->ndev
);
575 cpsw_ale_stop(priv
->ale
);
576 for_each_slave(priv
, cpsw_slave_stop
, priv
);
577 pm_runtime_put_sync(&priv
->pdev
->dev
);
581 static netdev_tx_t
cpsw_ndo_start_xmit(struct sk_buff
*skb
,
582 struct net_device
*ndev
)
584 struct cpsw_priv
*priv
= netdev_priv(ndev
);
587 ndev
->trans_start
= jiffies
;
589 if (skb_padto(skb
, CPSW_MIN_PACKET_SIZE
)) {
590 cpsw_err(priv
, tx_err
, "packet pad failed\n");
591 priv
->stats
.tx_dropped
++;
595 ret
= cpdma_chan_submit(priv
->txch
, skb
, skb
->data
,
596 skb
->len
, GFP_KERNEL
);
597 if (unlikely(ret
!= 0)) {
598 cpsw_err(priv
, tx_err
, "desc submit failed\n");
604 priv
->stats
.tx_dropped
++;
605 netif_stop_queue(ndev
);
606 return NETDEV_TX_BUSY
;
609 static void cpsw_ndo_change_rx_flags(struct net_device
*ndev
, int flags
)
612 * The switch cannot operate in promiscuous mode without substantial
613 * headache. For promiscuous mode to work, we would need to put the
614 * ALE in bypass mode and route all traffic to the host port.
615 * Subsequently, the host will need to operate as a "bridge", learn,
616 * and flood as needed. For now, we simply complain here and
617 * do nothing about it :-)
619 if ((flags
& IFF_PROMISC
) && (ndev
->flags
& IFF_PROMISC
))
620 dev_err(&ndev
->dev
, "promiscuity ignored!\n");
623 * The switch cannot filter multicast traffic unless it is configured
624 * in "VLAN Aware" mode. Unfortunately, VLAN awareness requires a
625 * whole bunch of additional logic that this driver does not implement
628 if ((flags
& IFF_ALLMULTI
) && !(ndev
->flags
& IFF_ALLMULTI
))
629 dev_err(&ndev
->dev
, "multicast traffic cannot be filtered!\n");
632 static void cpsw_ndo_tx_timeout(struct net_device
*ndev
)
634 struct cpsw_priv
*priv
= netdev_priv(ndev
);
636 cpsw_err(priv
, tx_err
, "transmit timeout, restarting dma\n");
637 priv
->stats
.tx_errors
++;
638 cpsw_intr_disable(priv
);
639 cpdma_ctlr_int_ctrl(priv
->dma
, false);
640 cpdma_chan_stop(priv
->txch
);
641 cpdma_chan_start(priv
->txch
);
642 cpdma_ctlr_int_ctrl(priv
->dma
, true);
643 cpsw_intr_enable(priv
);
644 cpdma_ctlr_eoi(priv
->dma
);
647 static struct net_device_stats
*cpsw_ndo_get_stats(struct net_device
*ndev
)
649 struct cpsw_priv
*priv
= netdev_priv(ndev
);
653 #ifdef CONFIG_NET_POLL_CONTROLLER
654 static void cpsw_ndo_poll_controller(struct net_device
*ndev
)
656 struct cpsw_priv
*priv
= netdev_priv(ndev
);
658 cpsw_intr_disable(priv
);
659 cpdma_ctlr_int_ctrl(priv
->dma
, false);
660 cpsw_interrupt(ndev
->irq
, priv
);
661 cpdma_ctlr_int_ctrl(priv
->dma
, true);
662 cpsw_intr_enable(priv
);
663 cpdma_ctlr_eoi(priv
->dma
);
667 static const struct net_device_ops cpsw_netdev_ops
= {
668 .ndo_open
= cpsw_ndo_open
,
669 .ndo_stop
= cpsw_ndo_stop
,
670 .ndo_start_xmit
= cpsw_ndo_start_xmit
,
671 .ndo_change_rx_flags
= cpsw_ndo_change_rx_flags
,
672 .ndo_validate_addr
= eth_validate_addr
,
673 .ndo_change_mtu
= eth_change_mtu
,
674 .ndo_tx_timeout
= cpsw_ndo_tx_timeout
,
675 .ndo_get_stats
= cpsw_ndo_get_stats
,
676 #ifdef CONFIG_NET_POLL_CONTROLLER
677 .ndo_poll_controller
= cpsw_ndo_poll_controller
,
681 static void cpsw_get_drvinfo(struct net_device
*ndev
,
682 struct ethtool_drvinfo
*info
)
684 struct cpsw_priv
*priv
= netdev_priv(ndev
);
685 strcpy(info
->driver
, "TI CPSW Driver v1.0");
686 strcpy(info
->version
, "1.0");
687 strcpy(info
->bus_info
, priv
->pdev
->name
);
690 static u32
cpsw_get_msglevel(struct net_device
*ndev
)
692 struct cpsw_priv
*priv
= netdev_priv(ndev
);
693 return priv
->msg_enable
;
696 static void cpsw_set_msglevel(struct net_device
*ndev
, u32 value
)
698 struct cpsw_priv
*priv
= netdev_priv(ndev
);
699 priv
->msg_enable
= value
;
702 static const struct ethtool_ops cpsw_ethtool_ops
= {
703 .get_drvinfo
= cpsw_get_drvinfo
,
704 .get_msglevel
= cpsw_get_msglevel
,
705 .set_msglevel
= cpsw_set_msglevel
,
706 .get_link
= ethtool_op_get_link
,
709 static void cpsw_slave_init(struct cpsw_slave
*slave
, struct cpsw_priv
*priv
)
711 void __iomem
*regs
= priv
->regs
;
712 int slave_num
= slave
->slave_num
;
713 struct cpsw_slave_data
*data
= priv
->data
.slave_data
+ slave_num
;
716 slave
->regs
= regs
+ data
->slave_reg_ofs
;
717 slave
->sliver
= regs
+ data
->sliver_reg_ofs
;
720 static int cpsw_probe_dt(struct cpsw_platform_data
*data
,
721 struct platform_device
*pdev
)
723 struct device_node
*node
= pdev
->dev
.of_node
;
724 struct device_node
*slave_node
;
731 if (of_property_read_u32(node
, "slaves", &prop
)) {
732 pr_err("Missing slaves property in the DT.\n");
737 data
->slave_data
= kzalloc(sizeof(struct cpsw_slave_data
) *
738 data
->slaves
, GFP_KERNEL
);
739 if (!data
->slave_data
) {
740 pr_err("Could not allocate slave memory.\n");
744 data
->no_bd_ram
= of_property_read_bool(node
, "no_bd_ram");
746 if (of_property_read_u32(node
, "cpdma_channels", &prop
)) {
747 pr_err("Missing cpdma_channels property in the DT.\n");
751 data
->channels
= prop
;
753 if (of_property_read_u32(node
, "host_port_no", &prop
)) {
754 pr_err("Missing host_port_no property in the DT.\n");
758 data
->host_port_num
= prop
;
760 if (of_property_read_u32(node
, "cpdma_reg_ofs", &prop
)) {
761 pr_err("Missing cpdma_reg_ofs property in the DT.\n");
765 data
->cpdma_reg_ofs
= prop
;
767 if (of_property_read_u32(node
, "cpdma_sram_ofs", &prop
)) {
768 pr_err("Missing cpdma_sram_ofs property in the DT.\n");
772 data
->cpdma_sram_ofs
= prop
;
774 if (of_property_read_u32(node
, "ale_reg_ofs", &prop
)) {
775 pr_err("Missing ale_reg_ofs property in the DT.\n");
779 data
->ale_reg_ofs
= prop
;
781 if (of_property_read_u32(node
, "ale_entries", &prop
)) {
782 pr_err("Missing ale_entries property in the DT.\n");
786 data
->ale_entries
= prop
;
788 if (of_property_read_u32(node
, "host_port_reg_ofs", &prop
)) {
789 pr_err("Missing host_port_reg_ofs property in the DT.\n");
793 data
->host_port_reg_ofs
= prop
;
795 if (of_property_read_u32(node
, "hw_stats_reg_ofs", &prop
)) {
796 pr_err("Missing hw_stats_reg_ofs property in the DT.\n");
800 data
->hw_stats_reg_ofs
= prop
;
802 if (of_property_read_u32(node
, "bd_ram_ofs", &prop
)) {
803 pr_err("Missing bd_ram_ofs property in the DT.\n");
807 data
->bd_ram_ofs
= prop
;
809 if (of_property_read_u32(node
, "bd_ram_size", &prop
)) {
810 pr_err("Missing bd_ram_size property in the DT.\n");
814 data
->bd_ram_size
= prop
;
816 if (of_property_read_u32(node
, "rx_descs", &prop
)) {
817 pr_err("Missing rx_descs property in the DT.\n");
821 data
->rx_descs
= prop
;
823 if (of_property_read_u32(node
, "mac_control", &prop
)) {
824 pr_err("Missing mac_control property in the DT.\n");
828 data
->mac_control
= prop
;
830 for_each_child_of_node(node
, slave_node
) {
831 struct cpsw_slave_data
*slave_data
= data
->slave_data
+ i
;
832 const char *phy_id
= NULL
;
833 const void *mac_addr
= NULL
;
835 if (of_property_read_string(slave_node
, "phy_id", &phy_id
)) {
836 pr_err("Missing slave[%d] phy_id property\n", i
);
840 slave_data
->phy_id
= phy_id
;
842 if (of_property_read_u32(slave_node
, "slave_reg_ofs", &prop
)) {
843 pr_err("Missing slave[%d] slave_reg_ofs property\n", i
);
847 slave_data
->slave_reg_ofs
= prop
;
849 if (of_property_read_u32(slave_node
, "sliver_reg_ofs",
851 pr_err("Missing slave[%d] sliver_reg_ofs property\n",
856 slave_data
->sliver_reg_ofs
= prop
;
858 mac_addr
= of_get_mac_address(slave_node
);
860 memcpy(slave_data
->mac_addr
, mac_addr
, ETH_ALEN
);
868 kfree(data
->slave_data
);
872 static int __devinit
cpsw_probe(struct platform_device
*pdev
)
874 struct cpsw_platform_data
*data
= pdev
->dev
.platform_data
;
875 struct net_device
*ndev
;
876 struct cpsw_priv
*priv
;
877 struct cpdma_params dma_params
;
878 struct cpsw_ale_params ale_params
;
880 struct resource
*res
;
881 int ret
= 0, i
, k
= 0;
883 ndev
= alloc_etherdev(sizeof(struct cpsw_priv
));
885 pr_err("error allocating net_device\n");
889 platform_set_drvdata(pdev
, ndev
);
890 priv
= netdev_priv(ndev
);
891 spin_lock_init(&priv
->lock
);
894 priv
->dev
= &ndev
->dev
;
895 priv
->msg_enable
= netif_msg_init(debug_level
, CPSW_DEBUG
);
896 priv
->rx_packet_max
= max(rx_packet_max
, 128);
898 if (cpsw_probe_dt(&priv
->data
, pdev
)) {
899 pr_err("cpsw: platform data missing\n");
905 if (is_valid_ether_addr(data
->slave_data
[0].mac_addr
)) {
906 memcpy(priv
->mac_addr
, data
->slave_data
[0].mac_addr
, ETH_ALEN
);
907 pr_info("Detected MACID = %pM", priv
->mac_addr
);
909 eth_random_addr(priv
->mac_addr
);
910 pr_info("Random MACID = %pM", priv
->mac_addr
);
913 memcpy(ndev
->dev_addr
, priv
->mac_addr
, ETH_ALEN
);
915 priv
->slaves
= kzalloc(sizeof(struct cpsw_slave
) * data
->slaves
,
921 for (i
= 0; i
< data
->slaves
; i
++)
922 priv
->slaves
[i
].slave_num
= i
;
924 pm_runtime_enable(&pdev
->dev
);
925 priv
->clk
= clk_get(&pdev
->dev
, "fck");
926 if (IS_ERR(priv
->clk
)) {
927 dev_err(&pdev
->dev
, "fck is not found\n");
929 goto clean_slave_ret
;
932 priv
->cpsw_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
933 if (!priv
->cpsw_res
) {
934 dev_err(priv
->dev
, "error getting i/o resource\n");
939 if (!request_mem_region(priv
->cpsw_res
->start
,
940 resource_size(priv
->cpsw_res
), ndev
->name
)) {
941 dev_err(priv
->dev
, "failed request i/o region\n");
946 regs
= ioremap(priv
->cpsw_res
->start
, resource_size(priv
->cpsw_res
));
948 dev_err(priv
->dev
, "unable to map i/o region\n");
949 goto clean_cpsw_iores_ret
;
952 priv
->host_port
= data
->host_port_num
;
953 priv
->host_port_regs
= regs
+ data
->host_port_reg_ofs
;
955 priv
->cpsw_ss_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 1);
956 if (!priv
->cpsw_ss_res
) {
957 dev_err(priv
->dev
, "error getting i/o resource\n");
962 if (!request_mem_region(priv
->cpsw_ss_res
->start
,
963 resource_size(priv
->cpsw_ss_res
), ndev
->name
)) {
964 dev_err(priv
->dev
, "failed request i/o region\n");
969 regs
= ioremap(priv
->cpsw_ss_res
->start
,
970 resource_size(priv
->cpsw_ss_res
));
972 dev_err(priv
->dev
, "unable to map i/o region\n");
973 goto clean_cpsw_ss_iores_ret
;
975 priv
->ss_regs
= regs
;
977 for_each_slave(priv
, cpsw_slave_init
, priv
);
979 memset(&dma_params
, 0, sizeof(dma_params
));
980 dma_params
.dev
= &pdev
->dev
;
981 dma_params
.dmaregs
= cpsw_dma_regs((u32
)priv
->regs
,
982 data
->cpdma_reg_ofs
);
983 dma_params
.rxthresh
= cpsw_dma_rxthresh((u32
)priv
->regs
,
984 data
->cpdma_reg_ofs
);
985 dma_params
.rxfree
= cpsw_dma_rxfree((u32
)priv
->regs
,
986 data
->cpdma_reg_ofs
);
987 dma_params
.txhdp
= cpsw_dma_txhdp((u32
)priv
->regs
,
988 data
->cpdma_sram_ofs
);
989 dma_params
.rxhdp
= cpsw_dma_rxhdp((u32
)priv
->regs
,
990 data
->cpdma_sram_ofs
);
991 dma_params
.txcp
= cpsw_dma_txcp((u32
)priv
->regs
,
992 data
->cpdma_sram_ofs
);
993 dma_params
.rxcp
= cpsw_dma_rxcp((u32
)priv
->regs
,
994 data
->cpdma_sram_ofs
);
996 dma_params
.num_chan
= data
->channels
;
997 dma_params
.has_soft_reset
= true;
998 dma_params
.min_packet_size
= CPSW_MIN_PACKET_SIZE
;
999 dma_params
.desc_mem_size
= data
->bd_ram_size
;
1000 dma_params
.desc_align
= 16;
1001 dma_params
.has_ext_regs
= true;
1002 dma_params
.desc_mem_phys
= data
->no_bd_ram
? 0 :
1003 (u32 __force
)priv
->cpsw_res
->start
+ data
->bd_ram_ofs
;
1004 dma_params
.desc_hw_addr
= data
->hw_ram_addr
?
1005 data
->hw_ram_addr
: dma_params
.desc_mem_phys
;
1007 priv
->dma
= cpdma_ctlr_create(&dma_params
);
1009 dev_err(priv
->dev
, "error initializing dma\n");
1011 goto clean_iomap_ret
;
1014 priv
->txch
= cpdma_chan_create(priv
->dma
, tx_chan_num(0),
1016 priv
->rxch
= cpdma_chan_create(priv
->dma
, rx_chan_num(0),
1019 if (WARN_ON(!priv
->txch
|| !priv
->rxch
)) {
1020 dev_err(priv
->dev
, "error initializing dma channels\n");
1025 memset(&ale_params
, 0, sizeof(ale_params
));
1026 ale_params
.dev
= &ndev
->dev
;
1027 ale_params
.ale_regs
= (void *)((u32
)priv
->regs
) +
1028 ((u32
)data
->ale_reg_ofs
);
1029 ale_params
.ale_ageout
= ale_ageout
;
1030 ale_params
.ale_entries
= data
->ale_entries
;
1031 ale_params
.ale_ports
= data
->slaves
;
1033 priv
->ale
= cpsw_ale_create(&ale_params
);
1035 dev_err(priv
->dev
, "error initializing ale engine\n");
1040 ndev
->irq
= platform_get_irq(pdev
, 0);
1041 if (ndev
->irq
< 0) {
1042 dev_err(priv
->dev
, "error getting irq resource\n");
1047 while ((res
= platform_get_resource(priv
->pdev
, IORESOURCE_IRQ
, k
))) {
1048 for (i
= res
->start
; i
<= res
->end
; i
++) {
1049 if (request_irq(i
, cpsw_interrupt
, IRQF_DISABLED
,
1050 dev_name(&pdev
->dev
), priv
)) {
1051 dev_err(priv
->dev
, "error attaching irq\n");
1054 priv
->irqs_table
[k
] = i
;
1060 ndev
->flags
|= IFF_ALLMULTI
; /* see cpsw_ndo_change_rx_flags() */
1062 ndev
->netdev_ops
= &cpsw_netdev_ops
;
1063 SET_ETHTOOL_OPS(ndev
, &cpsw_ethtool_ops
);
1064 netif_napi_add(ndev
, &priv
->napi
, cpsw_poll
, CPSW_POLL_WEIGHT
);
1066 /* register the network device */
1067 SET_NETDEV_DEV(ndev
, &pdev
->dev
);
1068 ret
= register_netdev(ndev
);
1070 dev_err(priv
->dev
, "error registering net device\n");
1075 cpsw_notice(priv
, probe
, "initialized device (regs %x, irq %d)\n",
1076 priv
->cpsw_res
->start
, ndev
->irq
);
1081 free_irq(ndev
->irq
, priv
);
1083 cpsw_ale_destroy(priv
->ale
);
1085 cpdma_chan_destroy(priv
->txch
);
1086 cpdma_chan_destroy(priv
->rxch
);
1087 cpdma_ctlr_destroy(priv
->dma
);
1089 iounmap(priv
->regs
);
1090 clean_cpsw_ss_iores_ret
:
1091 release_mem_region(priv
->cpsw_ss_res
->start
,
1092 resource_size(priv
->cpsw_ss_res
));
1093 clean_cpsw_iores_ret
:
1094 release_mem_region(priv
->cpsw_res
->start
,
1095 resource_size(priv
->cpsw_res
));
1099 pm_runtime_disable(&pdev
->dev
);
1100 kfree(priv
->slaves
);
1106 static int __devexit
cpsw_remove(struct platform_device
*pdev
)
1108 struct net_device
*ndev
= platform_get_drvdata(pdev
);
1109 struct cpsw_priv
*priv
= netdev_priv(ndev
);
1111 pr_info("removing device");
1112 platform_set_drvdata(pdev
, NULL
);
1114 free_irq(ndev
->irq
, priv
);
1115 cpsw_ale_destroy(priv
->ale
);
1116 cpdma_chan_destroy(priv
->txch
);
1117 cpdma_chan_destroy(priv
->rxch
);
1118 cpdma_ctlr_destroy(priv
->dma
);
1119 iounmap(priv
->regs
);
1120 release_mem_region(priv
->cpsw_res
->start
,
1121 resource_size(priv
->cpsw_res
));
1122 release_mem_region(priv
->cpsw_ss_res
->start
,
1123 resource_size(priv
->cpsw_ss_res
));
1124 pm_runtime_disable(&pdev
->dev
);
1126 kfree(priv
->slaves
);
1132 static int cpsw_suspend(struct device
*dev
)
1134 struct platform_device
*pdev
= to_platform_device(dev
);
1135 struct net_device
*ndev
= platform_get_drvdata(pdev
);
1137 if (netif_running(ndev
))
1138 cpsw_ndo_stop(ndev
);
1139 pm_runtime_put_sync(&pdev
->dev
);
1144 static int cpsw_resume(struct device
*dev
)
1146 struct platform_device
*pdev
= to_platform_device(dev
);
1147 struct net_device
*ndev
= platform_get_drvdata(pdev
);
1149 pm_runtime_get_sync(&pdev
->dev
);
1150 if (netif_running(ndev
))
1151 cpsw_ndo_open(ndev
);
1155 static const struct dev_pm_ops cpsw_pm_ops
= {
1156 .suspend
= cpsw_suspend
,
1157 .resume
= cpsw_resume
,
1160 static const struct of_device_id cpsw_of_mtable
[] = {
1161 { .compatible
= "ti,cpsw", },
1165 static struct platform_driver cpsw_driver
= {
1168 .owner
= THIS_MODULE
,
1170 .of_match_table
= of_match_ptr(cpsw_of_mtable
),
1172 .probe
= cpsw_probe
,
1173 .remove
= __devexit_p(cpsw_remove
),
1176 static int __init
cpsw_init(void)
1178 return platform_driver_register(&cpsw_driver
);
1180 late_initcall(cpsw_init
);
1182 static void __exit
cpsw_exit(void)
1184 platform_driver_unregister(&cpsw_driver
);
1186 module_exit(cpsw_exit
);
1188 MODULE_LICENSE("GPL");
1189 MODULE_AUTHOR("Cyril Chemparathy <cyril@ti.com>");
1190 MODULE_AUTHOR("Mugunthan V N <mugunthanvnm@ti.com>");
1191 MODULE_DESCRIPTION("TI CPSW Ethernet driver");