1 // SPDX-License-Identifier: GPL-2.0
3 * Texas Instruments Ethernet Switch Driver
5 * Copyright (C) 2012 Texas Instruments
9 #include <linux/kernel.h>
11 #include <linux/clk.h>
12 #include <linux/timer.h>
13 #include <linux/module.h>
14 #include <linux/platform_device.h>
15 #include <linux/irqreturn.h>
16 #include <linux/interrupt.h>
17 #include <linux/if_ether.h>
18 #include <linux/etherdevice.h>
19 #include <linux/netdevice.h>
20 #include <linux/net_tstamp.h>
21 #include <linux/phy.h>
22 #include <linux/phy/phy.h>
23 #include <linux/workqueue.h>
24 #include <linux/delay.h>
25 #include <linux/pm_runtime.h>
26 #include <linux/gpio/consumer.h>
28 #include <linux/of_mdio.h>
29 #include <linux/of_net.h>
30 #include <linux/of_device.h>
31 #include <linux/if_vlan.h>
32 #include <linux/kmemleak.h>
33 #include <linux/sys_soc.h>
34 #include <net/page_pool.h>
35 #include <linux/bpf.h>
36 #include <linux/bpf_trace.h>
38 #include <linux/pinctrl/consumer.h>
39 #include <net/pkt_cls.h>
43 #include "cpsw_priv.h"
46 #include "davinci_cpdma.h"
48 #include <net/pkt_sched.h>
50 static int debug_level
;
51 module_param(debug_level
, int, 0);
52 MODULE_PARM_DESC(debug_level
, "cpsw debug level (NETIF_MSG bits)");
54 static int ale_ageout
= 10;
55 module_param(ale_ageout
, int, 0);
56 MODULE_PARM_DESC(ale_ageout
, "cpsw ale ageout interval (seconds)");
58 static int rx_packet_max
= CPSW_MAX_PACKET_SIZE
;
59 module_param(rx_packet_max
, int, 0);
60 MODULE_PARM_DESC(rx_packet_max
, "maximum receive packet size (bytes)");
62 static int descs_pool_size
= CPSW_CPDMA_DESCS_POOL_SIZE_DEFAULT
;
63 module_param(descs_pool_size
, int, 0444);
64 MODULE_PARM_DESC(descs_pool_size
, "Number of CPDMA CPPI descriptors in pool");
66 #define for_each_slave(priv, func, arg...) \
68 struct cpsw_slave *slave; \
69 struct cpsw_common *cpsw = (priv)->cpsw; \
71 if (cpsw->data.dual_emac) \
72 (func)((cpsw)->slaves + priv->emac_port, ##arg);\
74 for (n = cpsw->data.slaves, \
75 slave = cpsw->slaves; \
77 (func)(slave++, ##arg); \
80 static int cpsw_slave_index_priv(struct cpsw_common
*cpsw
,
81 struct cpsw_priv
*priv
)
83 return cpsw
->data
.dual_emac
? priv
->emac_port
: cpsw
->data
.active_slave
;
86 static int cpsw_get_slave_port(u32 slave_num
)
91 static int cpsw_ndo_vlan_rx_add_vid(struct net_device
*ndev
,
92 __be16 proto
, u16 vid
);
94 static void cpsw_set_promiscious(struct net_device
*ndev
, bool enable
)
96 struct cpsw_common
*cpsw
= ndev_to_cpsw(ndev
);
97 struct cpsw_ale
*ale
= cpsw
->ale
;
100 if (cpsw
->data
.dual_emac
) {
103 /* Enabling promiscuous mode for one interface will be
104 * common for both the interface as the interface shares
105 * the same hardware resource.
107 for (i
= 0; i
< cpsw
->data
.slaves
; i
++)
108 if (cpsw
->slaves
[i
].ndev
->flags
& IFF_PROMISC
)
111 if (!enable
&& flag
) {
113 dev_err(&ndev
->dev
, "promiscuity not disabled as the other interface is still in promiscuity mode\n");
118 cpsw_ale_control_set(ale
, 0, ALE_BYPASS
, 1);
120 dev_dbg(&ndev
->dev
, "promiscuity enabled\n");
123 cpsw_ale_control_set(ale
, 0, ALE_BYPASS
, 0);
124 dev_dbg(&ndev
->dev
, "promiscuity disabled\n");
128 unsigned long timeout
= jiffies
+ HZ
;
130 /* Disable Learn for all ports (host is port 0 and slaves are port 1 and up */
131 for (i
= 0; i
<= cpsw
->data
.slaves
; i
++) {
132 cpsw_ale_control_set(ale
, i
,
133 ALE_PORT_NOLEARN
, 1);
134 cpsw_ale_control_set(ale
, i
,
135 ALE_PORT_NO_SA_UPDATE
, 1);
138 /* Clear All Untouched entries */
139 cpsw_ale_control_set(ale
, 0, ALE_AGEOUT
, 1);
142 if (cpsw_ale_control_get(ale
, 0, ALE_AGEOUT
))
144 } while (time_after(timeout
, jiffies
));
145 cpsw_ale_control_set(ale
, 0, ALE_AGEOUT
, 1);
147 /* Clear all mcast from ALE */
148 cpsw_ale_flush_multicast(ale
, ALE_ALL_PORTS
, -1);
149 __hw_addr_ref_unsync_dev(&ndev
->mc
, ndev
, NULL
);
151 /* Flood All Unicast Packets to Host port */
152 cpsw_ale_control_set(ale
, 0, ALE_P0_UNI_FLOOD
, 1);
153 dev_dbg(&ndev
->dev
, "promiscuity enabled\n");
155 /* Don't Flood All Unicast Packets to Host port */
156 cpsw_ale_control_set(ale
, 0, ALE_P0_UNI_FLOOD
, 0);
158 /* Enable Learn for all ports (host is port 0 and slaves are port 1 and up */
159 for (i
= 0; i
<= cpsw
->data
.slaves
; i
++) {
160 cpsw_ale_control_set(ale
, i
,
161 ALE_PORT_NOLEARN
, 0);
162 cpsw_ale_control_set(ale
, i
,
163 ALE_PORT_NO_SA_UPDATE
, 0);
165 dev_dbg(&ndev
->dev
, "promiscuity disabled\n");
171 * cpsw_set_mc - adds multicast entry to the table if it's not added or deletes
172 * if it's not deleted
173 * @ndev: device to sync
174 * @addr: address to be added or deleted
175 * @vid: vlan id, if vid < 0 set/unset address for real device
176 * @add: add address if the flag is set or remove otherwise
178 static int cpsw_set_mc(struct net_device
*ndev
, const u8
*addr
,
181 struct cpsw_priv
*priv
= netdev_priv(ndev
);
182 struct cpsw_common
*cpsw
= priv
->cpsw
;
183 int mask
, flags
, ret
;
186 if (cpsw
->data
.dual_emac
)
187 vid
= cpsw
->slaves
[priv
->emac_port
].port_vlan
;
192 mask
= cpsw
->data
.dual_emac
? ALE_PORT_HOST
: ALE_ALL_PORTS
;
193 flags
= vid
? ALE_VLAN
: 0;
196 ret
= cpsw_ale_add_mcast(cpsw
->ale
, addr
, mask
, flags
, vid
, 0);
198 ret
= cpsw_ale_del_mcast(cpsw
->ale
, addr
, 0, flags
, vid
);
203 static int cpsw_update_vlan_mc(struct net_device
*vdev
, int vid
, void *ctx
)
205 struct addr_sync_ctx
*sync_ctx
= ctx
;
206 struct netdev_hw_addr
*ha
;
207 int found
= 0, ret
= 0;
209 if (!vdev
|| !(vdev
->flags
& IFF_UP
))
212 /* vlan address is relevant if its sync_cnt != 0 */
213 netdev_for_each_mc_addr(ha
, vdev
) {
214 if (ether_addr_equal(ha
->addr
, sync_ctx
->addr
)) {
215 found
= ha
->sync_cnt
;
221 sync_ctx
->consumed
++;
223 if (sync_ctx
->flush
) {
225 cpsw_set_mc(sync_ctx
->ndev
, sync_ctx
->addr
, vid
, 0);
230 ret
= cpsw_set_mc(sync_ctx
->ndev
, sync_ctx
->addr
, vid
, 1);
235 static int cpsw_add_mc_addr(struct net_device
*ndev
, const u8
*addr
, int num
)
237 struct addr_sync_ctx sync_ctx
;
240 sync_ctx
.consumed
= 0;
241 sync_ctx
.addr
= addr
;
242 sync_ctx
.ndev
= ndev
;
245 ret
= vlan_for_each(ndev
, cpsw_update_vlan_mc
, &sync_ctx
);
246 if (sync_ctx
.consumed
< num
&& !ret
)
247 ret
= cpsw_set_mc(ndev
, addr
, -1, 1);
252 static int cpsw_del_mc_addr(struct net_device
*ndev
, const u8
*addr
, int num
)
254 struct addr_sync_ctx sync_ctx
;
256 sync_ctx
.consumed
= 0;
257 sync_ctx
.addr
= addr
;
258 sync_ctx
.ndev
= ndev
;
261 vlan_for_each(ndev
, cpsw_update_vlan_mc
, &sync_ctx
);
262 if (sync_ctx
.consumed
== num
)
263 cpsw_set_mc(ndev
, addr
, -1, 0);
268 static int cpsw_purge_vlan_mc(struct net_device
*vdev
, int vid
, void *ctx
)
270 struct addr_sync_ctx
*sync_ctx
= ctx
;
271 struct netdev_hw_addr
*ha
;
274 if (!vdev
|| !(vdev
->flags
& IFF_UP
))
277 /* vlan address is relevant if its sync_cnt != 0 */
278 netdev_for_each_mc_addr(ha
, vdev
) {
279 if (ether_addr_equal(ha
->addr
, sync_ctx
->addr
)) {
280 found
= ha
->sync_cnt
;
288 sync_ctx
->consumed
++;
289 cpsw_set_mc(sync_ctx
->ndev
, sync_ctx
->addr
, vid
, 0);
293 static int cpsw_purge_all_mc(struct net_device
*ndev
, const u8
*addr
, int num
)
295 struct addr_sync_ctx sync_ctx
;
297 sync_ctx
.addr
= addr
;
298 sync_ctx
.ndev
= ndev
;
299 sync_ctx
.consumed
= 0;
301 vlan_for_each(ndev
, cpsw_purge_vlan_mc
, &sync_ctx
);
302 if (sync_ctx
.consumed
< num
)
303 cpsw_set_mc(ndev
, addr
, -1, 0);
308 static void cpsw_ndo_set_rx_mode(struct net_device
*ndev
)
310 struct cpsw_priv
*priv
= netdev_priv(ndev
);
311 struct cpsw_common
*cpsw
= priv
->cpsw
;
314 if (cpsw
->data
.dual_emac
)
315 slave_port
= priv
->emac_port
+ 1;
317 if (ndev
->flags
& IFF_PROMISC
) {
318 /* Enable promiscuous mode */
319 cpsw_set_promiscious(ndev
, true);
320 cpsw_ale_set_allmulti(cpsw
->ale
, IFF_ALLMULTI
, slave_port
);
323 /* Disable promiscuous mode */
324 cpsw_set_promiscious(ndev
, false);
327 /* Restore allmulti on vlans if necessary */
328 cpsw_ale_set_allmulti(cpsw
->ale
,
329 ndev
->flags
& IFF_ALLMULTI
, slave_port
);
331 /* add/remove mcast address either for real netdev or for vlan */
332 __hw_addr_ref_sync_dev(&ndev
->mc
, ndev
, cpsw_add_mc_addr
,
336 static unsigned int cpsw_rxbuf_total_len(unsigned int len
)
338 len
+= CPSW_HEADROOM
;
339 len
+= SKB_DATA_ALIGN(sizeof(struct skb_shared_info
));
341 return SKB_DATA_ALIGN(len
);
344 static void cpsw_rx_handler(void *token
, int len
, int status
)
346 struct page
*new_page
, *page
= token
;
347 void *pa
= page_address(page
);
348 struct cpsw_meta_xdp
*xmeta
= pa
+ CPSW_XMETA_OFFSET
;
349 struct cpsw_common
*cpsw
= ndev_to_cpsw(xmeta
->ndev
);
350 int pkt_size
= cpsw
->rx_packet_max
;
351 int ret
= 0, port
, ch
= xmeta
->ch
;
352 int headroom
= CPSW_HEADROOM
;
353 struct net_device
*ndev
= xmeta
->ndev
;
354 struct cpsw_priv
*priv
;
355 struct page_pool
*pool
;
360 if (cpsw
->data
.dual_emac
&& status
>= 0) {
361 port
= CPDMA_RX_SOURCE_PORT(status
);
363 ndev
= cpsw
->slaves
[--port
].ndev
;
366 priv
= netdev_priv(ndev
);
367 pool
= cpsw
->page_pool
[ch
];
368 if (unlikely(status
< 0) || unlikely(!netif_running(ndev
))) {
369 /* In dual emac mode check for all interfaces */
370 if (cpsw
->data
.dual_emac
&& cpsw
->usage_count
&&
372 /* The packet received is for the interface which
373 * is already down and the other interface is up
374 * and running, instead of freeing which results
375 * in reducing of the number of rx descriptor in
376 * DMA engine, requeue page back to cpdma.
382 /* the interface is going down, pages are purged */
383 page_pool_recycle_direct(pool
, page
);
387 new_page
= page_pool_dev_alloc_pages(pool
);
388 if (unlikely(!new_page
)) {
390 ndev
->stats
.rx_dropped
++;
394 if (priv
->xdp_prog
) {
395 if (status
& CPDMA_RX_VLAN_ENCAP
) {
396 xdp
.data
= pa
+ CPSW_HEADROOM
+
397 CPSW_RX_VLAN_ENCAP_HDR_SIZE
;
398 xdp
.data_end
= xdp
.data
+ len
-
399 CPSW_RX_VLAN_ENCAP_HDR_SIZE
;
401 xdp
.data
= pa
+ CPSW_HEADROOM
;
402 xdp
.data_end
= xdp
.data
+ len
;
405 xdp_set_data_meta_invalid(&xdp
);
407 xdp
.data_hard_start
= pa
;
408 xdp
.rxq
= &priv
->xdp_rxq
[ch
];
409 xdp
.frame_sz
= PAGE_SIZE
;
411 port
= priv
->emac_port
+ cpsw
->data
.dual_emac
;
412 ret
= cpsw_run_xdp(priv
, ch
, &xdp
, page
, port
);
413 if (ret
!= CPSW_XDP_PASS
)
416 /* XDP prog might have changed packet data and boundaries */
417 len
= xdp
.data_end
- xdp
.data
;
418 headroom
= xdp
.data
- xdp
.data_hard_start
;
420 /* XDP prog can modify vlan tag, so can't use encap header */
421 status
&= ~CPDMA_RX_VLAN_ENCAP
;
424 /* pass skb to netstack if no XDP prog or returned XDP_PASS */
425 skb
= build_skb(pa
, cpsw_rxbuf_total_len(pkt_size
));
427 ndev
->stats
.rx_dropped
++;
428 page_pool_recycle_direct(pool
, page
);
432 skb_reserve(skb
, headroom
);
435 if (status
& CPDMA_RX_VLAN_ENCAP
)
436 cpsw_rx_vlan_encap(skb
);
437 if (priv
->rx_ts_enabled
)
438 cpts_rx_timestamp(cpsw
->cpts
, skb
);
439 skb
->protocol
= eth_type_trans(skb
, ndev
);
441 /* unmap page as no netstack skb page recycling */
442 page_pool_release_page(pool
, page
);
443 netif_receive_skb(skb
);
445 ndev
->stats
.rx_bytes
+= len
;
446 ndev
->stats
.rx_packets
++;
449 xmeta
= page_address(new_page
) + CPSW_XMETA_OFFSET
;
453 dma
= page_pool_get_dma_addr(new_page
) + CPSW_HEADROOM
;
454 ret
= cpdma_chan_submit_mapped(cpsw
->rxv
[ch
].ch
, new_page
, dma
,
457 WARN_ON(ret
== -ENOMEM
);
458 page_pool_recycle_direct(pool
, new_page
);
462 static void _cpsw_adjust_link(struct cpsw_slave
*slave
,
463 struct cpsw_priv
*priv
, bool *link
)
465 struct phy_device
*phy
= slave
->phy
;
468 struct cpsw_common
*cpsw
= priv
->cpsw
;
473 slave_port
= cpsw_get_slave_port(slave
->slave_num
);
476 mac_control
= CPSW_SL_CTL_GMII_EN
;
478 if (phy
->speed
== 1000)
479 mac_control
|= CPSW_SL_CTL_GIG
;
481 mac_control
|= CPSW_SL_CTL_FULLDUPLEX
;
483 /* set speed_in input in case RMII mode is used in 100Mbps */
484 if (phy
->speed
== 100)
485 mac_control
|= CPSW_SL_CTL_IFCTL_A
;
486 /* in band mode only works in 10Mbps RGMII mode */
487 else if ((phy
->speed
== 10) && phy_interface_is_rgmii(phy
))
488 mac_control
|= CPSW_SL_CTL_EXT_EN
; /* In Band mode */
491 mac_control
|= CPSW_SL_CTL_RX_FLOW_EN
;
494 mac_control
|= CPSW_SL_CTL_TX_FLOW_EN
;
496 if (mac_control
!= slave
->mac_control
)
497 cpsw_sl_ctl_set(slave
->mac_sl
, mac_control
);
499 /* enable forwarding */
500 cpsw_ale_control_set(cpsw
->ale
, slave_port
,
501 ALE_PORT_STATE
, ALE_PORT_STATE_FORWARD
);
505 if (priv
->shp_cfg_speed
&&
506 priv
->shp_cfg_speed
!= slave
->phy
->speed
&&
507 !cpsw_shp_is_off(priv
))
509 "Speed was changed, CBS shaper speeds are changed!");
512 /* disable forwarding */
513 cpsw_ale_control_set(cpsw
->ale
, slave_port
,
514 ALE_PORT_STATE
, ALE_PORT_STATE_DISABLE
);
516 cpsw_sl_wait_for_idle(slave
->mac_sl
, 100);
518 cpsw_sl_ctl_reset(slave
->mac_sl
);
521 if (mac_control
!= slave
->mac_control
)
522 phy_print_status(phy
);
524 slave
->mac_control
= mac_control
;
527 static void cpsw_adjust_link(struct net_device
*ndev
)
529 struct cpsw_priv
*priv
= netdev_priv(ndev
);
530 struct cpsw_common
*cpsw
= priv
->cpsw
;
533 for_each_slave(priv
, _cpsw_adjust_link
, priv
, &link
);
536 if (cpsw_need_resplit(cpsw
))
537 cpsw_split_res(cpsw
);
539 netif_carrier_on(ndev
);
540 if (netif_running(ndev
))
541 netif_tx_wake_all_queues(ndev
);
543 netif_carrier_off(ndev
);
544 netif_tx_stop_all_queues(ndev
);
548 static inline void cpsw_add_dual_emac_def_ale_entries(
549 struct cpsw_priv
*priv
, struct cpsw_slave
*slave
,
552 struct cpsw_common
*cpsw
= priv
->cpsw
;
553 u32 port_mask
= 1 << slave_port
| ALE_PORT_HOST
;
555 if (cpsw
->version
== CPSW_VERSION_1
)
556 slave_write(slave
, slave
->port_vlan
, CPSW1_PORT_VLAN
);
558 slave_write(slave
, slave
->port_vlan
, CPSW2_PORT_VLAN
);
559 cpsw_ale_add_vlan(cpsw
->ale
, slave
->port_vlan
, port_mask
,
560 port_mask
, port_mask
, 0);
561 cpsw_ale_add_mcast(cpsw
->ale
, priv
->ndev
->broadcast
,
562 ALE_PORT_HOST
, ALE_VLAN
, slave
->port_vlan
, 0);
563 cpsw_ale_add_ucast(cpsw
->ale
, priv
->mac_addr
,
564 HOST_PORT_NUM
, ALE_VLAN
|
565 ALE_SECURE
, slave
->port_vlan
);
566 cpsw_ale_control_set(cpsw
->ale
, slave_port
,
567 ALE_PORT_DROP_UNKNOWN_VLAN
, 1);
570 static void cpsw_slave_open(struct cpsw_slave
*slave
, struct cpsw_priv
*priv
)
573 struct phy_device
*phy
;
574 struct cpsw_common
*cpsw
= priv
->cpsw
;
576 cpsw_sl_reset(slave
->mac_sl
, 100);
577 cpsw_sl_ctl_reset(slave
->mac_sl
);
579 /* setup priority mapping */
580 cpsw_sl_reg_write(slave
->mac_sl
, CPSW_SL_RX_PRI_MAP
,
581 RX_PRIORITY_MAPPING
);
583 switch (cpsw
->version
) {
585 slave_write(slave
, TX_PRIORITY_MAPPING
, CPSW1_TX_PRI_MAP
);
586 /* Increase RX FIFO size to 5 for supporting fullduplex
590 (CPSW_MAX_BLKS_TX
<< CPSW_MAX_BLKS_TX_SHIFT
) |
591 CPSW_MAX_BLKS_RX
, CPSW1_MAX_BLKS
);
596 slave_write(slave
, TX_PRIORITY_MAPPING
, CPSW2_TX_PRI_MAP
);
597 /* Increase RX FIFO size to 5 for supporting fullduplex
601 (CPSW_MAX_BLKS_TX
<< CPSW_MAX_BLKS_TX_SHIFT
) |
602 CPSW_MAX_BLKS_RX
, CPSW2_MAX_BLKS
);
606 /* setup max packet size, and mac address */
607 cpsw_sl_reg_write(slave
->mac_sl
, CPSW_SL_RX_MAXLEN
,
608 cpsw
->rx_packet_max
);
609 cpsw_set_slave_mac(slave
, priv
);
611 slave
->mac_control
= 0; /* no link yet */
613 slave_port
= cpsw_get_slave_port(slave
->slave_num
);
615 if (cpsw
->data
.dual_emac
)
616 cpsw_add_dual_emac_def_ale_entries(priv
, slave
, slave_port
);
618 cpsw_ale_add_mcast(cpsw
->ale
, priv
->ndev
->broadcast
,
619 1 << slave_port
, 0, 0, ALE_MCAST_FWD_2
);
621 if (slave
->data
->phy_node
) {
622 phy
= of_phy_connect(priv
->ndev
, slave
->data
->phy_node
,
623 &cpsw_adjust_link
, 0, slave
->data
->phy_if
);
625 dev_err(priv
->dev
, "phy \"%pOF\" not found on slave %d\n",
626 slave
->data
->phy_node
,
631 phy
= phy_connect(priv
->ndev
, slave
->data
->phy_id
,
632 &cpsw_adjust_link
, slave
->data
->phy_if
);
635 "phy \"%s\" not found on slave %d, err %ld\n",
636 slave
->data
->phy_id
, slave
->slave_num
,
644 phy_attached_info(slave
->phy
);
646 phy_start(slave
->phy
);
648 /* Configure GMII_SEL register */
649 if (!IS_ERR(slave
->data
->ifphy
))
650 phy_set_mode_ext(slave
->data
->ifphy
, PHY_MODE_ETHERNET
,
651 slave
->data
->phy_if
);
653 cpsw_phy_sel(cpsw
->dev
, slave
->phy
->interface
,
657 static inline void cpsw_add_default_vlan(struct cpsw_priv
*priv
)
659 struct cpsw_common
*cpsw
= priv
->cpsw
;
660 const int vlan
= cpsw
->data
.default_vlan
;
663 int unreg_mcast_mask
;
665 reg
= (cpsw
->version
== CPSW_VERSION_1
) ? CPSW1_PORT_VLAN
:
668 writel(vlan
, &cpsw
->host_port_regs
->port_vlan
);
670 for (i
= 0; i
< cpsw
->data
.slaves
; i
++)
671 slave_write(cpsw
->slaves
+ i
, vlan
, reg
);
673 if (priv
->ndev
->flags
& IFF_ALLMULTI
)
674 unreg_mcast_mask
= ALE_ALL_PORTS
;
676 unreg_mcast_mask
= ALE_PORT_1
| ALE_PORT_2
;
678 cpsw_ale_add_vlan(cpsw
->ale
, vlan
, ALE_ALL_PORTS
,
679 ALE_ALL_PORTS
, ALE_ALL_PORTS
,
683 static void cpsw_init_host_port(struct cpsw_priv
*priv
)
687 struct cpsw_common
*cpsw
= priv
->cpsw
;
689 /* soft reset the controller and initialize ale */
690 soft_reset("cpsw", &cpsw
->regs
->soft_reset
);
691 cpsw_ale_start(cpsw
->ale
);
693 /* switch to vlan unaware mode */
694 cpsw_ale_control_set(cpsw
->ale
, HOST_PORT_NUM
, ALE_VLAN_AWARE
,
695 CPSW_ALE_VLAN_AWARE
);
696 control_reg
= readl(&cpsw
->regs
->control
);
697 control_reg
|= CPSW_VLAN_AWARE
| CPSW_RX_VLAN_ENCAP
;
698 writel(control_reg
, &cpsw
->regs
->control
);
699 fifo_mode
= (cpsw
->data
.dual_emac
) ? CPSW_FIFO_DUAL_MAC_MODE
:
700 CPSW_FIFO_NORMAL_MODE
;
701 writel(fifo_mode
, &cpsw
->host_port_regs
->tx_in_ctl
);
703 /* setup host port priority mapping */
704 writel_relaxed(CPDMA_TX_PRIORITY_MAP
,
705 &cpsw
->host_port_regs
->cpdma_tx_pri_map
);
706 writel_relaxed(0, &cpsw
->host_port_regs
->cpdma_rx_chan_map
);
708 cpsw_ale_control_set(cpsw
->ale
, HOST_PORT_NUM
,
709 ALE_PORT_STATE
, ALE_PORT_STATE_FORWARD
);
711 if (!cpsw
->data
.dual_emac
) {
712 cpsw_ale_add_ucast(cpsw
->ale
, priv
->mac_addr
, HOST_PORT_NUM
,
714 cpsw_ale_add_mcast(cpsw
->ale
, priv
->ndev
->broadcast
,
715 ALE_PORT_HOST
, 0, 0, ALE_MCAST_FWD_2
);
719 static void cpsw_slave_stop(struct cpsw_slave
*slave
, struct cpsw_common
*cpsw
)
723 slave_port
= cpsw_get_slave_port(slave
->slave_num
);
727 phy_stop(slave
->phy
);
728 phy_disconnect(slave
->phy
);
730 cpsw_ale_control_set(cpsw
->ale
, slave_port
,
731 ALE_PORT_STATE
, ALE_PORT_STATE_DISABLE
);
732 cpsw_sl_reset(slave
->mac_sl
, 100);
733 cpsw_sl_ctl_reset(slave
->mac_sl
);
736 static int cpsw_restore_vlans(struct net_device
*vdev
, int vid
, void *arg
)
738 struct cpsw_priv
*priv
= arg
;
743 cpsw_ndo_vlan_rx_add_vid(priv
->ndev
, 0, vid
);
747 /* restore resources after port reset */
748 static void cpsw_restore(struct cpsw_priv
*priv
)
750 /* restore vlan configurations */
751 vlan_for_each(priv
->ndev
, cpsw_restore_vlans
, priv
);
753 /* restore MQPRIO offload */
754 for_each_slave(priv
, cpsw_mqprio_resume
, priv
);
756 /* restore CBS offload */
757 for_each_slave(priv
, cpsw_cbs_resume
, priv
);
760 static int cpsw_ndo_open(struct net_device
*ndev
)
762 struct cpsw_priv
*priv
= netdev_priv(ndev
);
763 struct cpsw_common
*cpsw
= priv
->cpsw
;
767 ret
= pm_runtime_get_sync(cpsw
->dev
);
769 pm_runtime_put_noidle(cpsw
->dev
);
773 netif_carrier_off(ndev
);
775 /* Notify the stack of the actual queue counts. */
776 ret
= netif_set_real_num_tx_queues(ndev
, cpsw
->tx_ch_num
);
778 dev_err(priv
->dev
, "cannot set real number of tx queues\n");
782 ret
= netif_set_real_num_rx_queues(ndev
, cpsw
->rx_ch_num
);
784 dev_err(priv
->dev
, "cannot set real number of rx queues\n");
790 dev_info(priv
->dev
, "initializing cpsw version %d.%d (%d)\n",
791 CPSW_MAJOR_VERSION(reg
), CPSW_MINOR_VERSION(reg
),
792 CPSW_RTL_VERSION(reg
));
794 /* Initialize host and slave ports */
795 if (!cpsw
->usage_count
)
796 cpsw_init_host_port(priv
);
797 for_each_slave(priv
, cpsw_slave_open
, priv
);
799 /* Add default VLAN */
800 if (!cpsw
->data
.dual_emac
)
801 cpsw_add_default_vlan(priv
);
803 cpsw_ale_add_vlan(cpsw
->ale
, cpsw
->data
.default_vlan
,
804 ALE_ALL_PORTS
, ALE_ALL_PORTS
, 0, 0);
806 /* initialize shared resources for every ndev */
807 if (!cpsw
->usage_count
) {
808 /* disable priority elevation */
809 writel_relaxed(0, &cpsw
->regs
->ptype
);
811 /* enable statistics collection only on all ports */
812 writel_relaxed(0x7, &cpsw
->regs
->stat_port_en
);
814 /* Enable internal fifo flow control */
815 writel(0x7, &cpsw
->regs
->flow_control
);
817 napi_enable(&cpsw
->napi_rx
);
818 napi_enable(&cpsw
->napi_tx
);
820 if (cpsw
->tx_irq_disabled
) {
821 cpsw
->tx_irq_disabled
= false;
822 enable_irq(cpsw
->irqs_table
[1]);
825 if (cpsw
->rx_irq_disabled
) {
826 cpsw
->rx_irq_disabled
= false;
827 enable_irq(cpsw
->irqs_table
[0]);
830 /* create rxqs for both infs in dual mac as they use same pool
831 * and must be destroyed together when no users.
833 ret
= cpsw_create_xdp_rxqs(cpsw
);
837 ret
= cpsw_fill_rx_channels(priv
);
842 if (cpts_register(cpsw
->cpts
))
843 dev_err(priv
->dev
, "error registering cpts device\n");
845 writel(0x10, &cpsw
->wr_regs
->misc_en
);
851 /* Enable Interrupt pacing if configured */
852 if (cpsw
->coal_intvl
!= 0) {
853 struct ethtool_coalesce coal
;
855 coal
.rx_coalesce_usecs
= cpsw
->coal_intvl
;
856 cpsw_set_coalesce(ndev
, &coal
);
859 cpdma_ctlr_start(cpsw
->dma
);
860 cpsw_intr_enable(cpsw
);
866 if (!cpsw
->usage_count
) {
867 cpdma_ctlr_stop(cpsw
->dma
);
868 cpsw_destroy_xdp_rxqs(cpsw
);
871 for_each_slave(priv
, cpsw_slave_stop
, cpsw
);
872 pm_runtime_put_sync(cpsw
->dev
);
873 netif_carrier_off(priv
->ndev
);
877 static int cpsw_ndo_stop(struct net_device
*ndev
)
879 struct cpsw_priv
*priv
= netdev_priv(ndev
);
880 struct cpsw_common
*cpsw
= priv
->cpsw
;
882 cpsw_info(priv
, ifdown
, "shutting down cpsw device\n");
883 __hw_addr_ref_unsync_dev(&ndev
->mc
, ndev
, cpsw_purge_all_mc
);
884 netif_tx_stop_all_queues(priv
->ndev
);
885 netif_carrier_off(priv
->ndev
);
887 if (cpsw
->usage_count
<= 1) {
888 napi_disable(&cpsw
->napi_rx
);
889 napi_disable(&cpsw
->napi_tx
);
890 cpts_unregister(cpsw
->cpts
);
891 cpsw_intr_disable(cpsw
);
892 cpdma_ctlr_stop(cpsw
->dma
);
893 cpsw_ale_stop(cpsw
->ale
);
894 cpsw_destroy_xdp_rxqs(cpsw
);
896 for_each_slave(priv
, cpsw_slave_stop
, cpsw
);
898 if (cpsw_need_resplit(cpsw
))
899 cpsw_split_res(cpsw
);
902 pm_runtime_put_sync(cpsw
->dev
);
906 static netdev_tx_t
cpsw_ndo_start_xmit(struct sk_buff
*skb
,
907 struct net_device
*ndev
)
909 struct cpsw_priv
*priv
= netdev_priv(ndev
);
910 struct cpsw_common
*cpsw
= priv
->cpsw
;
911 struct cpts
*cpts
= cpsw
->cpts
;
912 struct netdev_queue
*txq
;
913 struct cpdma_chan
*txch
;
916 if (skb_padto(skb
, CPSW_MIN_PACKET_SIZE
)) {
917 cpsw_err(priv
, tx_err
, "packet pad failed\n");
918 ndev
->stats
.tx_dropped
++;
919 return NET_XMIT_DROP
;
922 if (skb_shinfo(skb
)->tx_flags
& SKBTX_HW_TSTAMP
&&
923 priv
->tx_ts_enabled
&& cpts_can_timestamp(cpts
, skb
))
924 skb_shinfo(skb
)->tx_flags
|= SKBTX_IN_PROGRESS
;
926 q_idx
= skb_get_queue_mapping(skb
);
927 if (q_idx
>= cpsw
->tx_ch_num
)
928 q_idx
= q_idx
% cpsw
->tx_ch_num
;
930 txch
= cpsw
->txv
[q_idx
].ch
;
931 txq
= netdev_get_tx_queue(ndev
, q_idx
);
932 skb_tx_timestamp(skb
);
933 ret
= cpdma_chan_submit(txch
, skb
, skb
->data
, skb
->len
,
934 priv
->emac_port
+ cpsw
->data
.dual_emac
);
935 if (unlikely(ret
!= 0)) {
936 cpsw_err(priv
, tx_err
, "desc submit failed\n");
940 /* If there is no more tx desc left free then we need to
941 * tell the kernel to stop sending us tx frames.
943 if (unlikely(!cpdma_check_free_tx_desc(txch
))) {
944 netif_tx_stop_queue(txq
);
946 /* Barrier, so that stop_queue visible to other cpus */
947 smp_mb__after_atomic();
949 if (cpdma_check_free_tx_desc(txch
))
950 netif_tx_wake_queue(txq
);
955 ndev
->stats
.tx_dropped
++;
956 netif_tx_stop_queue(txq
);
958 /* Barrier, so that stop_queue visible to other cpus */
959 smp_mb__after_atomic();
961 if (cpdma_check_free_tx_desc(txch
))
962 netif_tx_wake_queue(txq
);
964 return NETDEV_TX_BUSY
;
967 static int cpsw_ndo_set_mac_address(struct net_device
*ndev
, void *p
)
969 struct cpsw_priv
*priv
= netdev_priv(ndev
);
970 struct sockaddr
*addr
= (struct sockaddr
*)p
;
971 struct cpsw_common
*cpsw
= priv
->cpsw
;
976 if (!is_valid_ether_addr(addr
->sa_data
))
977 return -EADDRNOTAVAIL
;
979 ret
= pm_runtime_get_sync(cpsw
->dev
);
981 pm_runtime_put_noidle(cpsw
->dev
);
985 if (cpsw
->data
.dual_emac
) {
986 vid
= cpsw
->slaves
[priv
->emac_port
].port_vlan
;
990 cpsw_ale_del_ucast(cpsw
->ale
, priv
->mac_addr
, HOST_PORT_NUM
,
992 cpsw_ale_add_ucast(cpsw
->ale
, addr
->sa_data
, HOST_PORT_NUM
,
995 memcpy(priv
->mac_addr
, addr
->sa_data
, ETH_ALEN
);
996 memcpy(ndev
->dev_addr
, priv
->mac_addr
, ETH_ALEN
);
997 for_each_slave(priv
, cpsw_set_slave_mac
, priv
);
999 pm_runtime_put(cpsw
->dev
);
1004 static inline int cpsw_add_vlan_ale_entry(struct cpsw_priv
*priv
,
1008 int unreg_mcast_mask
= 0;
1011 struct cpsw_common
*cpsw
= priv
->cpsw
;
1013 if (cpsw
->data
.dual_emac
) {
1014 port_mask
= (1 << (priv
->emac_port
+ 1)) | ALE_PORT_HOST
;
1016 mcast_mask
= ALE_PORT_HOST
;
1017 if (priv
->ndev
->flags
& IFF_ALLMULTI
)
1018 unreg_mcast_mask
= mcast_mask
;
1020 port_mask
= ALE_ALL_PORTS
;
1021 mcast_mask
= port_mask
;
1023 if (priv
->ndev
->flags
& IFF_ALLMULTI
)
1024 unreg_mcast_mask
= ALE_ALL_PORTS
;
1026 unreg_mcast_mask
= ALE_PORT_1
| ALE_PORT_2
;
1029 ret
= cpsw_ale_add_vlan(cpsw
->ale
, vid
, port_mask
, 0, port_mask
,
1034 ret
= cpsw_ale_add_ucast(cpsw
->ale
, priv
->mac_addr
,
1035 HOST_PORT_NUM
, ALE_VLAN
, vid
);
1039 ret
= cpsw_ale_add_mcast(cpsw
->ale
, priv
->ndev
->broadcast
,
1040 mcast_mask
, ALE_VLAN
, vid
, 0);
1042 goto clean_vlan_ucast
;
1046 cpsw_ale_del_ucast(cpsw
->ale
, priv
->mac_addr
,
1047 HOST_PORT_NUM
, ALE_VLAN
, vid
);
1049 cpsw_ale_del_vlan(cpsw
->ale
, vid
, 0);
1053 static int cpsw_ndo_vlan_rx_add_vid(struct net_device
*ndev
,
1054 __be16 proto
, u16 vid
)
1056 struct cpsw_priv
*priv
= netdev_priv(ndev
);
1057 struct cpsw_common
*cpsw
= priv
->cpsw
;
1060 if (vid
== cpsw
->data
.default_vlan
)
1063 ret
= pm_runtime_get_sync(cpsw
->dev
);
1065 pm_runtime_put_noidle(cpsw
->dev
);
1069 if (cpsw
->data
.dual_emac
) {
1070 /* In dual EMAC, reserved VLAN id should not be used for
1071 * creating VLAN interfaces as this can break the dual
1072 * EMAC port separation
1076 for (i
= 0; i
< cpsw
->data
.slaves
; i
++) {
1077 if (vid
== cpsw
->slaves
[i
].port_vlan
) {
1084 dev_info(priv
->dev
, "Adding vlanid %d to vlan filter\n", vid
);
1085 ret
= cpsw_add_vlan_ale_entry(priv
, vid
);
1087 pm_runtime_put(cpsw
->dev
);
1091 static int cpsw_ndo_vlan_rx_kill_vid(struct net_device
*ndev
,
1092 __be16 proto
, u16 vid
)
1094 struct cpsw_priv
*priv
= netdev_priv(ndev
);
1095 struct cpsw_common
*cpsw
= priv
->cpsw
;
1098 if (vid
== cpsw
->data
.default_vlan
)
1101 ret
= pm_runtime_get_sync(cpsw
->dev
);
1103 pm_runtime_put_noidle(cpsw
->dev
);
1107 if (cpsw
->data
.dual_emac
) {
1110 for (i
= 0; i
< cpsw
->data
.slaves
; i
++) {
1111 if (vid
== cpsw
->slaves
[i
].port_vlan
)
1116 dev_info(priv
->dev
, "removing vlanid %d from vlan filter\n", vid
);
1117 ret
= cpsw_ale_del_vlan(cpsw
->ale
, vid
, 0);
1118 ret
|= cpsw_ale_del_ucast(cpsw
->ale
, priv
->mac_addr
,
1119 HOST_PORT_NUM
, ALE_VLAN
, vid
);
1120 ret
|= cpsw_ale_del_mcast(cpsw
->ale
, priv
->ndev
->broadcast
,
1122 ret
|= cpsw_ale_flush_multicast(cpsw
->ale
, ALE_PORT_HOST
, vid
);
1124 pm_runtime_put(cpsw
->dev
);
1128 static int cpsw_ndo_xdp_xmit(struct net_device
*ndev
, int n
,
1129 struct xdp_frame
**frames
, u32 flags
)
1131 struct cpsw_priv
*priv
= netdev_priv(ndev
);
1132 struct cpsw_common
*cpsw
= priv
->cpsw
;
1133 struct xdp_frame
*xdpf
;
1134 int i
, drops
= 0, port
;
1136 if (unlikely(flags
& ~XDP_XMIT_FLAGS_MASK
))
1139 for (i
= 0; i
< n
; i
++) {
1141 if (xdpf
->len
< CPSW_MIN_PACKET_SIZE
) {
1142 xdp_return_frame_rx_napi(xdpf
);
1147 port
= priv
->emac_port
+ cpsw
->data
.dual_emac
;
1148 if (cpsw_xdp_tx_frame(priv
, xdpf
, NULL
, port
))
1155 #ifdef CONFIG_NET_POLL_CONTROLLER
1156 static void cpsw_ndo_poll_controller(struct net_device
*ndev
)
1158 struct cpsw_common
*cpsw
= ndev_to_cpsw(ndev
);
1160 cpsw_intr_disable(cpsw
);
1161 cpsw_rx_interrupt(cpsw
->irqs_table
[0], cpsw
);
1162 cpsw_tx_interrupt(cpsw
->irqs_table
[1], cpsw
);
1163 cpsw_intr_enable(cpsw
);
1167 static const struct net_device_ops cpsw_netdev_ops
= {
1168 .ndo_open
= cpsw_ndo_open
,
1169 .ndo_stop
= cpsw_ndo_stop
,
1170 .ndo_start_xmit
= cpsw_ndo_start_xmit
,
1171 .ndo_set_mac_address
= cpsw_ndo_set_mac_address
,
1172 .ndo_do_ioctl
= cpsw_ndo_ioctl
,
1173 .ndo_validate_addr
= eth_validate_addr
,
1174 .ndo_tx_timeout
= cpsw_ndo_tx_timeout
,
1175 .ndo_set_rx_mode
= cpsw_ndo_set_rx_mode
,
1176 .ndo_set_tx_maxrate
= cpsw_ndo_set_tx_maxrate
,
1177 #ifdef CONFIG_NET_POLL_CONTROLLER
1178 .ndo_poll_controller
= cpsw_ndo_poll_controller
,
1180 .ndo_vlan_rx_add_vid
= cpsw_ndo_vlan_rx_add_vid
,
1181 .ndo_vlan_rx_kill_vid
= cpsw_ndo_vlan_rx_kill_vid
,
1182 .ndo_setup_tc
= cpsw_ndo_setup_tc
,
1183 .ndo_bpf
= cpsw_ndo_bpf
,
1184 .ndo_xdp_xmit
= cpsw_ndo_xdp_xmit
,
1187 static void cpsw_get_drvinfo(struct net_device
*ndev
,
1188 struct ethtool_drvinfo
*info
)
1190 struct cpsw_common
*cpsw
= ndev_to_cpsw(ndev
);
1191 struct platform_device
*pdev
= to_platform_device(cpsw
->dev
);
1193 strlcpy(info
->driver
, "cpsw", sizeof(info
->driver
));
1194 strlcpy(info
->version
, "1.0", sizeof(info
->version
));
1195 strlcpy(info
->bus_info
, pdev
->name
, sizeof(info
->bus_info
));
1198 static int cpsw_set_pauseparam(struct net_device
*ndev
,
1199 struct ethtool_pauseparam
*pause
)
1201 struct cpsw_priv
*priv
= netdev_priv(ndev
);
1204 priv
->rx_pause
= pause
->rx_pause
? true : false;
1205 priv
->tx_pause
= pause
->tx_pause
? true : false;
1207 for_each_slave(priv
, _cpsw_adjust_link
, priv
, &link
);
1211 static int cpsw_set_channels(struct net_device
*ndev
,
1212 struct ethtool_channels
*chs
)
1214 return cpsw_set_channels_common(ndev
, chs
, cpsw_rx_handler
);
1217 static const struct ethtool_ops cpsw_ethtool_ops
= {
1218 .supported_coalesce_params
= ETHTOOL_COALESCE_RX_USECS
,
1219 .get_drvinfo
= cpsw_get_drvinfo
,
1220 .get_msglevel
= cpsw_get_msglevel
,
1221 .set_msglevel
= cpsw_set_msglevel
,
1222 .get_link
= ethtool_op_get_link
,
1223 .get_ts_info
= cpsw_get_ts_info
,
1224 .get_coalesce
= cpsw_get_coalesce
,
1225 .set_coalesce
= cpsw_set_coalesce
,
1226 .get_sset_count
= cpsw_get_sset_count
,
1227 .get_strings
= cpsw_get_strings
,
1228 .get_ethtool_stats
= cpsw_get_ethtool_stats
,
1229 .get_pauseparam
= cpsw_get_pauseparam
,
1230 .set_pauseparam
= cpsw_set_pauseparam
,
1231 .get_wol
= cpsw_get_wol
,
1232 .set_wol
= cpsw_set_wol
,
1233 .get_regs_len
= cpsw_get_regs_len
,
1234 .get_regs
= cpsw_get_regs
,
1235 .begin
= cpsw_ethtool_op_begin
,
1236 .complete
= cpsw_ethtool_op_complete
,
1237 .get_channels
= cpsw_get_channels
,
1238 .set_channels
= cpsw_set_channels
,
1239 .get_link_ksettings
= cpsw_get_link_ksettings
,
1240 .set_link_ksettings
= cpsw_set_link_ksettings
,
1241 .get_eee
= cpsw_get_eee
,
1242 .set_eee
= cpsw_set_eee
,
1243 .nway_reset
= cpsw_nway_reset
,
1244 .get_ringparam
= cpsw_get_ringparam
,
1245 .set_ringparam
= cpsw_set_ringparam
,
1248 static int cpsw_probe_dt(struct cpsw_platform_data
*data
,
1249 struct platform_device
*pdev
)
1251 struct device_node
*node
= pdev
->dev
.of_node
;
1252 struct device_node
*slave_node
;
1259 if (of_property_read_u32(node
, "slaves", &prop
)) {
1260 dev_err(&pdev
->dev
, "Missing slaves property in the DT.\n");
1263 data
->slaves
= prop
;
1265 if (of_property_read_u32(node
, "active_slave", &prop
)) {
1266 dev_err(&pdev
->dev
, "Missing active_slave property in the DT.\n");
1269 data
->active_slave
= prop
;
1271 data
->slave_data
= devm_kcalloc(&pdev
->dev
,
1273 sizeof(struct cpsw_slave_data
),
1275 if (!data
->slave_data
)
1278 if (of_property_read_u32(node
, "cpdma_channels", &prop
)) {
1279 dev_err(&pdev
->dev
, "Missing cpdma_channels property in the DT.\n");
1282 data
->channels
= prop
;
1284 if (of_property_read_u32(node
, "bd_ram_size", &prop
)) {
1285 dev_err(&pdev
->dev
, "Missing bd_ram_size property in the DT.\n");
1288 data
->bd_ram_size
= prop
;
1290 if (of_property_read_u32(node
, "mac_control", &prop
)) {
1291 dev_err(&pdev
->dev
, "Missing mac_control property in the DT.\n");
1294 data
->mac_control
= prop
;
1296 if (of_property_read_bool(node
, "dual_emac"))
1297 data
->dual_emac
= true;
1300 * Populate all the child nodes here...
1302 ret
= of_platform_populate(node
, NULL
, NULL
, &pdev
->dev
);
1303 /* We do not want to force this, as in some cases may not have child */
1305 dev_warn(&pdev
->dev
, "Doesn't have any child node\n");
1307 for_each_available_child_of_node(node
, slave_node
) {
1308 struct cpsw_slave_data
*slave_data
= data
->slave_data
+ i
;
1309 const void *mac_addr
= NULL
;
1313 /* This is no slave child node, continue */
1314 if (!of_node_name_eq(slave_node
, "slave"))
1317 slave_data
->ifphy
= devm_of_phy_get(&pdev
->dev
, slave_node
,
1319 if (!IS_ENABLED(CONFIG_TI_CPSW_PHY_SEL
) &&
1320 IS_ERR(slave_data
->ifphy
)) {
1321 ret
= PTR_ERR(slave_data
->ifphy
);
1323 "%d: Error retrieving port phy: %d\n", i
, ret
);
1327 slave_data
->slave_node
= slave_node
;
1328 slave_data
->phy_node
= of_parse_phandle(slave_node
,
1330 parp
= of_get_property(slave_node
, "phy_id", &lenp
);
1331 if (slave_data
->phy_node
) {
1333 "slave[%d] using phy-handle=\"%pOF\"\n",
1334 i
, slave_data
->phy_node
);
1335 } else if (of_phy_is_fixed_link(slave_node
)) {
1336 /* In the case of a fixed PHY, the DT node associated
1337 * to the PHY is the Ethernet MAC DT node.
1339 ret
= of_phy_register_fixed_link(slave_node
);
1341 if (ret
!= -EPROBE_DEFER
)
1342 dev_err(&pdev
->dev
, "failed to register fixed-link phy: %d\n", ret
);
1345 slave_data
->phy_node
= of_node_get(slave_node
);
1348 struct device_node
*mdio_node
;
1349 struct platform_device
*mdio
;
1351 if (lenp
!= (sizeof(__be32
) * 2)) {
1352 dev_err(&pdev
->dev
, "Invalid slave[%d] phy_id property\n", i
);
1355 mdio_node
= of_find_node_by_phandle(be32_to_cpup(parp
));
1356 phyid
= be32_to_cpup(parp
+1);
1357 mdio
= of_find_device_by_node(mdio_node
);
1358 of_node_put(mdio_node
);
1360 dev_err(&pdev
->dev
, "Missing mdio platform device\n");
1364 snprintf(slave_data
->phy_id
, sizeof(slave_data
->phy_id
),
1365 PHY_ID_FMT
, mdio
->name
, phyid
);
1366 put_device(&mdio
->dev
);
1369 "No slave[%d] phy_id, phy-handle, or fixed-link property\n",
1373 ret
= of_get_phy_mode(slave_node
, &slave_data
->phy_if
);
1375 dev_err(&pdev
->dev
, "Missing or malformed slave[%d] phy-mode property\n",
1381 mac_addr
= of_get_mac_address(slave_node
);
1382 if (!IS_ERR(mac_addr
)) {
1383 ether_addr_copy(slave_data
->mac_addr
, mac_addr
);
1385 ret
= ti_cm_get_macid(&pdev
->dev
, i
,
1386 slave_data
->mac_addr
);
1390 if (data
->dual_emac
) {
1391 if (of_property_read_u32(slave_node
, "dual_emac_res_vlan",
1393 dev_err(&pdev
->dev
, "Missing dual_emac_res_vlan in DT.\n");
1394 slave_data
->dual_emac_res_vlan
= i
+1;
1395 dev_err(&pdev
->dev
, "Using %d as Reserved VLAN for %d slave\n",
1396 slave_data
->dual_emac_res_vlan
, i
);
1398 slave_data
->dual_emac_res_vlan
= prop
;
1403 if (i
== data
->slaves
) {
1412 of_node_put(slave_node
);
1416 static void cpsw_remove_dt(struct platform_device
*pdev
)
1418 struct cpsw_common
*cpsw
= platform_get_drvdata(pdev
);
1419 struct cpsw_platform_data
*data
= &cpsw
->data
;
1420 struct device_node
*node
= pdev
->dev
.of_node
;
1421 struct device_node
*slave_node
;
1424 for_each_available_child_of_node(node
, slave_node
) {
1425 struct cpsw_slave_data
*slave_data
= &data
->slave_data
[i
];
1427 if (!of_node_name_eq(slave_node
, "slave"))
1430 if (of_phy_is_fixed_link(slave_node
))
1431 of_phy_deregister_fixed_link(slave_node
);
1433 of_node_put(slave_data
->phy_node
);
1436 if (i
== data
->slaves
) {
1437 of_node_put(slave_node
);
1442 of_platform_depopulate(&pdev
->dev
);
1445 static int cpsw_probe_dual_emac(struct cpsw_priv
*priv
)
1447 struct cpsw_common
*cpsw
= priv
->cpsw
;
1448 struct cpsw_platform_data
*data
= &cpsw
->data
;
1449 struct net_device
*ndev
;
1450 struct cpsw_priv
*priv_sl2
;
1453 ndev
= devm_alloc_etherdev_mqs(cpsw
->dev
, sizeof(struct cpsw_priv
),
1454 CPSW_MAX_QUEUES
, CPSW_MAX_QUEUES
);
1456 dev_err(cpsw
->dev
, "cpsw: error allocating net_device\n");
1460 priv_sl2
= netdev_priv(ndev
);
1461 priv_sl2
->cpsw
= cpsw
;
1462 priv_sl2
->ndev
= ndev
;
1463 priv_sl2
->dev
= &ndev
->dev
;
1464 priv_sl2
->msg_enable
= netif_msg_init(debug_level
, CPSW_DEBUG
);
1466 if (is_valid_ether_addr(data
->slave_data
[1].mac_addr
)) {
1467 memcpy(priv_sl2
->mac_addr
, data
->slave_data
[1].mac_addr
,
1469 dev_info(cpsw
->dev
, "cpsw: Detected MACID = %pM\n",
1470 priv_sl2
->mac_addr
);
1472 eth_random_addr(priv_sl2
->mac_addr
);
1473 dev_info(cpsw
->dev
, "cpsw: Random MACID = %pM\n",
1474 priv_sl2
->mac_addr
);
1476 memcpy(ndev
->dev_addr
, priv_sl2
->mac_addr
, ETH_ALEN
);
1478 priv_sl2
->emac_port
= 1;
1479 cpsw
->slaves
[1].ndev
= ndev
;
1480 ndev
->features
|= NETIF_F_HW_VLAN_CTAG_FILTER
| NETIF_F_HW_VLAN_CTAG_RX
;
1482 ndev
->netdev_ops
= &cpsw_netdev_ops
;
1483 ndev
->ethtool_ops
= &cpsw_ethtool_ops
;
1485 /* register the network device */
1486 SET_NETDEV_DEV(ndev
, cpsw
->dev
);
1487 ndev
->dev
.of_node
= cpsw
->slaves
[1].data
->slave_node
;
1488 ret
= register_netdev(ndev
);
1490 dev_err(cpsw
->dev
, "cpsw: error registering net device\n");
1495 static const struct of_device_id cpsw_of_mtable
[] = {
1496 { .compatible
= "ti,cpsw"},
1497 { .compatible
= "ti,am335x-cpsw"},
1498 { .compatible
= "ti,am4372-cpsw"},
1499 { .compatible
= "ti,dra7-cpsw"},
1502 MODULE_DEVICE_TABLE(of
, cpsw_of_mtable
);
1504 static const struct soc_device_attribute cpsw_soc_devices
[] = {
1505 { .family
= "AM33xx", .revision
= "ES1.0"},
1509 static int cpsw_probe(struct platform_device
*pdev
)
1511 struct device
*dev
= &pdev
->dev
;
1513 struct cpsw_platform_data
*data
;
1514 struct net_device
*ndev
;
1515 struct cpsw_priv
*priv
;
1516 void __iomem
*ss_regs
;
1517 struct resource
*ss_res
;
1518 struct gpio_descs
*mode
;
1519 const struct soc_device_attribute
*soc
;
1520 struct cpsw_common
*cpsw
;
1524 cpsw
= devm_kzalloc(dev
, sizeof(struct cpsw_common
), GFP_KERNEL
);
1528 platform_set_drvdata(pdev
, cpsw
);
1529 cpsw_slave_index
= cpsw_slave_index_priv
;
1533 mode
= devm_gpiod_get_array_optional(dev
, "mode", GPIOD_OUT_LOW
);
1535 ret
= PTR_ERR(mode
);
1536 dev_err(dev
, "gpio request failed, ret %d\n", ret
);
1540 clk
= devm_clk_get(dev
, "fck");
1543 dev_err(dev
, "fck is not found %d\n", ret
);
1546 cpsw
->bus_freq_mhz
= clk_get_rate(clk
) / 1000000;
1548 ss_res
= platform_get_resource(pdev
, IORESOURCE_MEM
, 0);
1549 ss_regs
= devm_ioremap_resource(dev
, ss_res
);
1550 if (IS_ERR(ss_regs
))
1551 return PTR_ERR(ss_regs
);
1552 cpsw
->regs
= ss_regs
;
1554 cpsw
->wr_regs
= devm_platform_ioremap_resource(pdev
, 1);
1555 if (IS_ERR(cpsw
->wr_regs
))
1556 return PTR_ERR(cpsw
->wr_regs
);
1559 irq
= platform_get_irq(pdev
, 1);
1562 cpsw
->irqs_table
[0] = irq
;
1565 irq
= platform_get_irq(pdev
, 2);
1568 cpsw
->irqs_table
[1] = irq
;
1571 irq
= platform_get_irq(pdev
, 3);
1574 cpsw
->misc_irq
= irq
;
1577 * This may be required here for child devices.
1579 pm_runtime_enable(dev
);
1581 /* Need to enable clocks with runtime PM api to access module
1584 ret
= pm_runtime_get_sync(dev
);
1586 pm_runtime_put_noidle(dev
);
1587 goto clean_runtime_disable_ret
;
1590 ret
= cpsw_probe_dt(&cpsw
->data
, pdev
);
1594 soc
= soc_device_match(cpsw_soc_devices
);
1596 cpsw
->quirk_irq
= true;
1599 cpsw
->slaves
= devm_kcalloc(dev
,
1600 data
->slaves
, sizeof(struct cpsw_slave
),
1602 if (!cpsw
->slaves
) {
1607 cpsw
->rx_packet_max
= max(rx_packet_max
, CPSW_MAX_PACKET_SIZE
);
1608 cpsw
->descs_pool_size
= descs_pool_size
;
1610 ret
= cpsw_init_common(cpsw
, ss_regs
, ale_ageout
,
1611 ss_res
->start
+ CPSW2_BD_OFFSET
,
1616 ch
= cpsw
->quirk_irq
? 0 : 7;
1617 cpsw
->txv
[0].ch
= cpdma_chan_create(cpsw
->dma
, ch
, cpsw_tx_handler
, 0);
1618 if (IS_ERR(cpsw
->txv
[0].ch
)) {
1619 dev_err(dev
, "error initializing tx dma channel\n");
1620 ret
= PTR_ERR(cpsw
->txv
[0].ch
);
1624 cpsw
->rxv
[0].ch
= cpdma_chan_create(cpsw
->dma
, 0, cpsw_rx_handler
, 1);
1625 if (IS_ERR(cpsw
->rxv
[0].ch
)) {
1626 dev_err(dev
, "error initializing rx dma channel\n");
1627 ret
= PTR_ERR(cpsw
->rxv
[0].ch
);
1630 cpsw_split_res(cpsw
);
1633 ndev
= devm_alloc_etherdev_mqs(dev
, sizeof(struct cpsw_priv
),
1634 CPSW_MAX_QUEUES
, CPSW_MAX_QUEUES
);
1636 dev_err(dev
, "error allocating net_device\n");
1641 priv
= netdev_priv(ndev
);
1645 priv
->msg_enable
= netif_msg_init(debug_level
, CPSW_DEBUG
);
1646 priv
->emac_port
= 0;
1648 if (is_valid_ether_addr(data
->slave_data
[0].mac_addr
)) {
1649 memcpy(priv
->mac_addr
, data
->slave_data
[0].mac_addr
, ETH_ALEN
);
1650 dev_info(dev
, "Detected MACID = %pM\n", priv
->mac_addr
);
1652 eth_random_addr(priv
->mac_addr
);
1653 dev_info(dev
, "Random MACID = %pM\n", priv
->mac_addr
);
1656 memcpy(ndev
->dev_addr
, priv
->mac_addr
, ETH_ALEN
);
1658 cpsw
->slaves
[0].ndev
= ndev
;
1660 ndev
->features
|= NETIF_F_HW_VLAN_CTAG_FILTER
| NETIF_F_HW_VLAN_CTAG_RX
;
1662 ndev
->netdev_ops
= &cpsw_netdev_ops
;
1663 ndev
->ethtool_ops
= &cpsw_ethtool_ops
;
1664 netif_napi_add(ndev
, &cpsw
->napi_rx
,
1665 cpsw
->quirk_irq
? cpsw_rx_poll
: cpsw_rx_mq_poll
,
1667 netif_tx_napi_add(ndev
, &cpsw
->napi_tx
,
1668 cpsw
->quirk_irq
? cpsw_tx_poll
: cpsw_tx_mq_poll
,
1671 /* register the network device */
1672 SET_NETDEV_DEV(ndev
, dev
);
1673 ndev
->dev
.of_node
= cpsw
->slaves
[0].data
->slave_node
;
1674 ret
= register_netdev(ndev
);
1676 dev_err(dev
, "error registering net device\n");
1681 if (cpsw
->data
.dual_emac
) {
1682 ret
= cpsw_probe_dual_emac(priv
);
1684 cpsw_err(priv
, probe
, "error probe slave 2 emac interface\n");
1685 goto clean_unregister_netdev_ret
;
1689 /* Grab RX and TX IRQs. Note that we also have RX_THRESHOLD and
1690 * MISC IRQs which are always kept disabled with this driver so
1691 * we will not request them.
1693 * If anyone wants to implement support for those, make sure to
1694 * first request and append them to irqs_table array.
1696 ret
= devm_request_irq(dev
, cpsw
->irqs_table
[0], cpsw_rx_interrupt
,
1697 0, dev_name(dev
), cpsw
);
1699 dev_err(dev
, "error attaching irq (%d)\n", ret
);
1700 goto clean_unregister_netdev_ret
;
1704 ret
= devm_request_irq(dev
, cpsw
->irqs_table
[1], cpsw_tx_interrupt
,
1705 0, dev_name(&pdev
->dev
), cpsw
);
1707 dev_err(dev
, "error attaching irq (%d)\n", ret
);
1708 goto clean_unregister_netdev_ret
;
1714 ret
= devm_request_irq(&pdev
->dev
, cpsw
->misc_irq
, cpsw_misc_interrupt
,
1715 0, dev_name(&pdev
->dev
), cpsw
);
1717 dev_err(dev
, "error attaching misc irq (%d)\n", ret
);
1718 goto clean_unregister_netdev_ret
;
1721 /* Enable misc CPTS evnt_pend IRQ */
1722 cpts_set_irqpoll(cpsw
->cpts
, false);
1725 cpsw_notice(priv
, probe
,
1726 "initialized device (regs %pa, irq %d, pool size %d)\n",
1727 &ss_res
->start
, cpsw
->irqs_table
[0], descs_pool_size
);
1729 pm_runtime_put(&pdev
->dev
);
1733 clean_unregister_netdev_ret
:
1734 unregister_netdev(ndev
);
1736 cpts_release(cpsw
->cpts
);
1737 cpdma_ctlr_destroy(cpsw
->dma
);
1739 cpsw_remove_dt(pdev
);
1740 pm_runtime_put_sync(&pdev
->dev
);
1741 clean_runtime_disable_ret
:
1742 pm_runtime_disable(&pdev
->dev
);
1746 static int cpsw_remove(struct platform_device
*pdev
)
1748 struct cpsw_common
*cpsw
= platform_get_drvdata(pdev
);
1751 ret
= pm_runtime_get_sync(&pdev
->dev
);
1753 pm_runtime_put_noidle(&pdev
->dev
);
1757 for (i
= 0; i
< cpsw
->data
.slaves
; i
++)
1758 if (cpsw
->slaves
[i
].ndev
)
1759 unregister_netdev(cpsw
->slaves
[i
].ndev
);
1761 cpts_release(cpsw
->cpts
);
1762 cpdma_ctlr_destroy(cpsw
->dma
);
1763 cpsw_remove_dt(pdev
);
1764 pm_runtime_put_sync(&pdev
->dev
);
1765 pm_runtime_disable(&pdev
->dev
);
1769 #ifdef CONFIG_PM_SLEEP
1770 static int cpsw_suspend(struct device
*dev
)
1772 struct cpsw_common
*cpsw
= dev_get_drvdata(dev
);
1777 for (i
= 0; i
< cpsw
->data
.slaves
; i
++)
1778 if (cpsw
->slaves
[i
].ndev
)
1779 if (netif_running(cpsw
->slaves
[i
].ndev
))
1780 cpsw_ndo_stop(cpsw
->slaves
[i
].ndev
);
1784 /* Select sleep pin state */
1785 pinctrl_pm_select_sleep_state(dev
);
1790 static int cpsw_resume(struct device
*dev
)
1792 struct cpsw_common
*cpsw
= dev_get_drvdata(dev
);
1795 /* Select default pin state */
1796 pinctrl_pm_select_default_state(dev
);
1798 /* shut up ASSERT_RTNL() warning in netif_set_real_num_tx/rx_queues */
1801 for (i
= 0; i
< cpsw
->data
.slaves
; i
++)
1802 if (cpsw
->slaves
[i
].ndev
)
1803 if (netif_running(cpsw
->slaves
[i
].ndev
))
1804 cpsw_ndo_open(cpsw
->slaves
[i
].ndev
);
1812 static SIMPLE_DEV_PM_OPS(cpsw_pm_ops
, cpsw_suspend
, cpsw_resume
);
1814 static struct platform_driver cpsw_driver
= {
1818 .of_match_table
= cpsw_of_mtable
,
1820 .probe
= cpsw_probe
,
1821 .remove
= cpsw_remove
,
1824 module_platform_driver(cpsw_driver
);
1826 MODULE_LICENSE("GPL");
1827 MODULE_AUTHOR("Cyril Chemparathy <cyril@ti.com>");
1828 MODULE_AUTHOR("Mugunthan V N <mugunthanvnm@ti.com>");
1829 MODULE_DESCRIPTION("TI CPSW Ethernet driver");