xref: /openbmc/linux/drivers/net/ethernet/ti/cpsw_new.c (revision abe9af53)
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * Texas Instruments Ethernet Switch Driver
4  *
5  * Copyright (C) 2019 Texas Instruments
6  */
7 
8 #include <linux/io.h>
9 #include <linux/clk.h>
10 #include <linux/timer.h>
11 #include <linux/module.h>
12 #include <linux/irqreturn.h>
13 #include <linux/interrupt.h>
14 #include <linux/if_ether.h>
15 #include <linux/etherdevice.h>
16 #include <linux/net_tstamp.h>
17 #include <linux/phy.h>
18 #include <linux/phy/phy.h>
19 #include <linux/delay.h>
20 #include <linux/pinctrl/consumer.h>
21 #include <linux/pm_runtime.h>
22 #include <linux/gpio/consumer.h>
23 #include <linux/of.h>
24 #include <linux/of_mdio.h>
25 #include <linux/of_net.h>
26 #include <linux/of_device.h>
27 #include <linux/if_vlan.h>
28 #include <linux/kmemleak.h>
29 #include <linux/sys_soc.h>
30 
31 #include <net/page_pool.h>
32 #include <net/pkt_cls.h>
33 #include <net/devlink.h>
34 
35 #include "cpsw.h"
36 #include "cpsw_ale.h"
37 #include "cpsw_priv.h"
38 #include "cpsw_sl.h"
39 #include "cpsw_switchdev.h"
40 #include "cpts.h"
41 #include "davinci_cpdma.h"
42 
43 #include <net/pkt_sched.h>
44 
45 static int debug_level;
46 static int ale_ageout = CPSW_ALE_AGEOUT_DEFAULT;
47 static int rx_packet_max = CPSW_MAX_PACKET_SIZE;
48 static int descs_pool_size = CPSW_CPDMA_DESCS_POOL_SIZE_DEFAULT;
49 
50 struct cpsw_devlink {
51 	struct cpsw_common *cpsw;
52 };
53 
54 enum cpsw_devlink_param_id {
55 	CPSW_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
56 	CPSW_DL_PARAM_SWITCH_MODE,
57 	CPSW_DL_PARAM_ALE_BYPASS,
58 };
59 
60 /* struct cpsw_common is not needed, kept here for compatibility
61  * reasons witrh the old driver
62  */
63 static int cpsw_slave_index_priv(struct cpsw_common *cpsw,
64 				 struct cpsw_priv *priv)
65 {
66 	if (priv->emac_port == HOST_PORT_NUM)
67 		return -1;
68 
69 	return priv->emac_port - 1;
70 }
71 
72 static bool cpsw_is_switch_en(struct cpsw_common *cpsw)
73 {
74 	return !cpsw->data.dual_emac;
75 }
76 
77 static void cpsw_set_promiscious(struct net_device *ndev, bool enable)
78 {
79 	struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
80 	bool enable_uni = false;
81 	int i;
82 
83 	if (cpsw_is_switch_en(cpsw))
84 		return;
85 
86 	/* Enabling promiscuous mode for one interface will be
87 	 * common for both the interface as the interface shares
88 	 * the same hardware resource.
89 	 */
90 	for (i = 0; i < cpsw->data.slaves; i++)
91 		if (cpsw->slaves[i].ndev &&
92 		    (cpsw->slaves[i].ndev->flags & IFF_PROMISC))
93 			enable_uni = true;
94 
95 	if (!enable && enable_uni) {
96 		enable = enable_uni;
97 		dev_dbg(cpsw->dev, "promiscuity not disabled as the other interface is still in promiscuity mode\n");
98 	}
99 
100 	if (enable) {
101 		/* Enable unknown unicast, reg/unreg mcast */
102 		cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM,
103 				     ALE_P0_UNI_FLOOD, 1);
104 
105 		dev_dbg(cpsw->dev, "promiscuity enabled\n");
106 	} else {
107 		/* Disable unknown unicast */
108 		cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM,
109 				     ALE_P0_UNI_FLOOD, 0);
110 		dev_dbg(cpsw->dev, "promiscuity disabled\n");
111 	}
112 }
113 
114 /**
115  * cpsw_set_mc - adds multicast entry to the table if it's not added or deletes
116  * if it's not deleted
117  * @ndev: device to sync
118  * @addr: address to be added or deleted
119  * @vid: vlan id, if vid < 0 set/unset address for real device
120  * @add: add address if the flag is set or remove otherwise
121  */
122 static int cpsw_set_mc(struct net_device *ndev, const u8 *addr,
123 		       int vid, int add)
124 {
125 	struct cpsw_priv *priv = netdev_priv(ndev);
126 	struct cpsw_common *cpsw = priv->cpsw;
127 	int mask, flags, ret, slave_no;
128 
129 	slave_no = cpsw_slave_index(cpsw, priv);
130 	if (vid < 0)
131 		vid = cpsw->slaves[slave_no].port_vlan;
132 
133 	mask =  ALE_PORT_HOST;
134 	flags = vid ? ALE_VLAN : 0;
135 
136 	if (add)
137 		ret = cpsw_ale_add_mcast(cpsw->ale, addr, mask, flags, vid, 0);
138 	else
139 		ret = cpsw_ale_del_mcast(cpsw->ale, addr, 0, flags, vid);
140 
141 	return ret;
142 }
143 
144 static int cpsw_update_vlan_mc(struct net_device *vdev, int vid, void *ctx)
145 {
146 	struct addr_sync_ctx *sync_ctx = ctx;
147 	struct netdev_hw_addr *ha;
148 	int found = 0, ret = 0;
149 
150 	if (!vdev || !(vdev->flags & IFF_UP))
151 		return 0;
152 
153 	/* vlan address is relevant if its sync_cnt != 0 */
154 	netdev_for_each_mc_addr(ha, vdev) {
155 		if (ether_addr_equal(ha->addr, sync_ctx->addr)) {
156 			found = ha->sync_cnt;
157 			break;
158 		}
159 	}
160 
161 	if (found)
162 		sync_ctx->consumed++;
163 
164 	if (sync_ctx->flush) {
165 		if (!found)
166 			cpsw_set_mc(sync_ctx->ndev, sync_ctx->addr, vid, 0);
167 		return 0;
168 	}
169 
170 	if (found)
171 		ret = cpsw_set_mc(sync_ctx->ndev, sync_ctx->addr, vid, 1);
172 
173 	return ret;
174 }
175 
176 static int cpsw_add_mc_addr(struct net_device *ndev, const u8 *addr, int num)
177 {
178 	struct addr_sync_ctx sync_ctx;
179 	int ret;
180 
181 	sync_ctx.consumed = 0;
182 	sync_ctx.addr = addr;
183 	sync_ctx.ndev = ndev;
184 	sync_ctx.flush = 0;
185 
186 	ret = vlan_for_each(ndev, cpsw_update_vlan_mc, &sync_ctx);
187 	if (sync_ctx.consumed < num && !ret)
188 		ret = cpsw_set_mc(ndev, addr, -1, 1);
189 
190 	return ret;
191 }
192 
193 static int cpsw_del_mc_addr(struct net_device *ndev, const u8 *addr, int num)
194 {
195 	struct addr_sync_ctx sync_ctx;
196 
197 	sync_ctx.consumed = 0;
198 	sync_ctx.addr = addr;
199 	sync_ctx.ndev = ndev;
200 	sync_ctx.flush = 1;
201 
202 	vlan_for_each(ndev, cpsw_update_vlan_mc, &sync_ctx);
203 	if (sync_ctx.consumed == num)
204 		cpsw_set_mc(ndev, addr, -1, 0);
205 
206 	return 0;
207 }
208 
209 static int cpsw_purge_vlan_mc(struct net_device *vdev, int vid, void *ctx)
210 {
211 	struct addr_sync_ctx *sync_ctx = ctx;
212 	struct netdev_hw_addr *ha;
213 	int found = 0;
214 
215 	if (!vdev || !(vdev->flags & IFF_UP))
216 		return 0;
217 
218 	/* vlan address is relevant if its sync_cnt != 0 */
219 	netdev_for_each_mc_addr(ha, vdev) {
220 		if (ether_addr_equal(ha->addr, sync_ctx->addr)) {
221 			found = ha->sync_cnt;
222 			break;
223 		}
224 	}
225 
226 	if (!found)
227 		return 0;
228 
229 	sync_ctx->consumed++;
230 	cpsw_set_mc(sync_ctx->ndev, sync_ctx->addr, vid, 0);
231 	return 0;
232 }
233 
234 static int cpsw_purge_all_mc(struct net_device *ndev, const u8 *addr, int num)
235 {
236 	struct addr_sync_ctx sync_ctx;
237 
238 	sync_ctx.addr = addr;
239 	sync_ctx.ndev = ndev;
240 	sync_ctx.consumed = 0;
241 
242 	vlan_for_each(ndev, cpsw_purge_vlan_mc, &sync_ctx);
243 	if (sync_ctx.consumed < num)
244 		cpsw_set_mc(ndev, addr, -1, 0);
245 
246 	return 0;
247 }
248 
249 static void cpsw_ndo_set_rx_mode(struct net_device *ndev)
250 {
251 	struct cpsw_priv *priv = netdev_priv(ndev);
252 	struct cpsw_common *cpsw = priv->cpsw;
253 
254 	if (ndev->flags & IFF_PROMISC) {
255 		/* Enable promiscuous mode */
256 		cpsw_set_promiscious(ndev, true);
257 		cpsw_ale_set_allmulti(cpsw->ale, IFF_ALLMULTI, priv->emac_port);
258 		return;
259 	}
260 
261 	/* Disable promiscuous mode */
262 	cpsw_set_promiscious(ndev, false);
263 
264 	/* Restore allmulti on vlans if necessary */
265 	cpsw_ale_set_allmulti(cpsw->ale,
266 			      ndev->flags & IFF_ALLMULTI, priv->emac_port);
267 
268 	/* add/remove mcast address either for real netdev or for vlan */
269 	__hw_addr_ref_sync_dev(&ndev->mc, ndev, cpsw_add_mc_addr,
270 			       cpsw_del_mc_addr);
271 }
272 
273 static unsigned int cpsw_rxbuf_total_len(unsigned int len)
274 {
275 	len += CPSW_HEADROOM;
276 	len += SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
277 
278 	return SKB_DATA_ALIGN(len);
279 }
280 
281 static void cpsw_rx_handler(void *token, int len, int status)
282 {
283 	struct page *new_page, *page = token;
284 	void *pa = page_address(page);
285 	int headroom = CPSW_HEADROOM;
286 	struct cpsw_meta_xdp *xmeta;
287 	struct cpsw_common *cpsw;
288 	struct net_device *ndev;
289 	int port, ch, pkt_size;
290 	struct cpsw_priv *priv;
291 	struct page_pool *pool;
292 	struct sk_buff *skb;
293 	struct xdp_buff xdp;
294 	int ret = 0;
295 	dma_addr_t dma;
296 
297 	xmeta = pa + CPSW_XMETA_OFFSET;
298 	cpsw = ndev_to_cpsw(xmeta->ndev);
299 	ndev = xmeta->ndev;
300 	pkt_size = cpsw->rx_packet_max;
301 	ch = xmeta->ch;
302 
303 	if (status >= 0) {
304 		port = CPDMA_RX_SOURCE_PORT(status);
305 		if (port)
306 			ndev = cpsw->slaves[--port].ndev;
307 	}
308 
309 	priv = netdev_priv(ndev);
310 	pool = cpsw->page_pool[ch];
311 
312 	if (unlikely(status < 0) || unlikely(!netif_running(ndev))) {
313 		/* In dual emac mode check for all interfaces */
314 		if (cpsw->usage_count && status >= 0) {
315 			/* The packet received is for the interface which
316 			 * is already down and the other interface is up
317 			 * and running, instead of freeing which results
318 			 * in reducing of the number of rx descriptor in
319 			 * DMA engine, requeue page back to cpdma.
320 			 */
321 			new_page = page;
322 			goto requeue;
323 		}
324 
325 		/* the interface is going down, pages are purged */
326 		page_pool_recycle_direct(pool, page);
327 		return;
328 	}
329 
330 	new_page = page_pool_dev_alloc_pages(pool);
331 	if (unlikely(!new_page)) {
332 		new_page = page;
333 		ndev->stats.rx_dropped++;
334 		goto requeue;
335 	}
336 
337 	if (priv->xdp_prog) {
338 		if (status & CPDMA_RX_VLAN_ENCAP) {
339 			xdp.data = pa + CPSW_HEADROOM +
340 				   CPSW_RX_VLAN_ENCAP_HDR_SIZE;
341 			xdp.data_end = xdp.data + len -
342 				       CPSW_RX_VLAN_ENCAP_HDR_SIZE;
343 		} else {
344 			xdp.data = pa + CPSW_HEADROOM;
345 			xdp.data_end = xdp.data + len;
346 		}
347 
348 		xdp_set_data_meta_invalid(&xdp);
349 
350 		xdp.data_hard_start = pa;
351 		xdp.rxq = &priv->xdp_rxq[ch];
352 		xdp.frame_sz = PAGE_SIZE;
353 
354 		ret = cpsw_run_xdp(priv, ch, &xdp, page, priv->emac_port);
355 		if (ret != CPSW_XDP_PASS)
356 			goto requeue;
357 
358 		/* XDP prog might have changed packet data and boundaries */
359 		len = xdp.data_end - xdp.data;
360 		headroom = xdp.data - xdp.data_hard_start;
361 
362 		/* XDP prog can modify vlan tag, so can't use encap header */
363 		status &= ~CPDMA_RX_VLAN_ENCAP;
364 	}
365 
366 	/* pass skb to netstack if no XDP prog or returned XDP_PASS */
367 	skb = build_skb(pa, cpsw_rxbuf_total_len(pkt_size));
368 	if (!skb) {
369 		ndev->stats.rx_dropped++;
370 		page_pool_recycle_direct(pool, page);
371 		goto requeue;
372 	}
373 
374 	skb->offload_fwd_mark = priv->offload_fwd_mark;
375 	skb_reserve(skb, headroom);
376 	skb_put(skb, len);
377 	skb->dev = ndev;
378 	if (status & CPDMA_RX_VLAN_ENCAP)
379 		cpsw_rx_vlan_encap(skb);
380 	if (priv->rx_ts_enabled)
381 		cpts_rx_timestamp(cpsw->cpts, skb);
382 	skb->protocol = eth_type_trans(skb, ndev);
383 
384 	/* unmap page as no netstack skb page recycling */
385 	page_pool_release_page(pool, page);
386 	netif_receive_skb(skb);
387 
388 	ndev->stats.rx_bytes += len;
389 	ndev->stats.rx_packets++;
390 
391 requeue:
392 	xmeta = page_address(new_page) + CPSW_XMETA_OFFSET;
393 	xmeta->ndev = ndev;
394 	xmeta->ch = ch;
395 
396 	dma = page_pool_get_dma_addr(new_page) + CPSW_HEADROOM;
397 	ret = cpdma_chan_submit_mapped(cpsw->rxv[ch].ch, new_page, dma,
398 				       pkt_size, 0);
399 	if (ret < 0) {
400 		WARN_ON(ret == -ENOMEM);
401 		page_pool_recycle_direct(pool, new_page);
402 	}
403 }
404 
405 static int cpsw_add_vlan_ale_entry(struct cpsw_priv *priv,
406 				   unsigned short vid)
407 {
408 	struct cpsw_common *cpsw = priv->cpsw;
409 	int unreg_mcast_mask = 0;
410 	int mcast_mask;
411 	u32 port_mask;
412 	int ret;
413 
414 	port_mask = (1 << priv->emac_port) | ALE_PORT_HOST;
415 
416 	mcast_mask = ALE_PORT_HOST;
417 	if (priv->ndev->flags & IFF_ALLMULTI)
418 		unreg_mcast_mask = mcast_mask;
419 
420 	ret = cpsw_ale_add_vlan(cpsw->ale, vid, port_mask, 0, port_mask,
421 				unreg_mcast_mask);
422 	if (ret != 0)
423 		return ret;
424 
425 	ret = cpsw_ale_add_ucast(cpsw->ale, priv->mac_addr,
426 				 HOST_PORT_NUM, ALE_VLAN, vid);
427 	if (ret != 0)
428 		goto clean_vid;
429 
430 	ret = cpsw_ale_add_mcast(cpsw->ale, priv->ndev->broadcast,
431 				 mcast_mask, ALE_VLAN, vid, 0);
432 	if (ret != 0)
433 		goto clean_vlan_ucast;
434 	return 0;
435 
436 clean_vlan_ucast:
437 	cpsw_ale_del_ucast(cpsw->ale, priv->mac_addr,
438 			   HOST_PORT_NUM, ALE_VLAN, vid);
439 clean_vid:
440 	cpsw_ale_del_vlan(cpsw->ale, vid, 0);
441 	return ret;
442 }
443 
444 static int cpsw_ndo_vlan_rx_add_vid(struct net_device *ndev,
445 				    __be16 proto, u16 vid)
446 {
447 	struct cpsw_priv *priv = netdev_priv(ndev);
448 	struct cpsw_common *cpsw = priv->cpsw;
449 	int ret, i;
450 
451 	if (cpsw_is_switch_en(cpsw)) {
452 		dev_dbg(cpsw->dev, ".ndo_vlan_rx_add_vid called in switch mode\n");
453 		return 0;
454 	}
455 
456 	if (vid == cpsw->data.default_vlan)
457 		return 0;
458 
459 	ret = pm_runtime_get_sync(cpsw->dev);
460 	if (ret < 0) {
461 		pm_runtime_put_noidle(cpsw->dev);
462 		return ret;
463 	}
464 
465 	/* In dual EMAC, reserved VLAN id should not be used for
466 	 * creating VLAN interfaces as this can break the dual
467 	 * EMAC port separation
468 	 */
469 	for (i = 0; i < cpsw->data.slaves; i++) {
470 		if (cpsw->slaves[i].ndev &&
471 		    vid == cpsw->slaves[i].port_vlan) {
472 			ret = -EINVAL;
473 			goto err;
474 		}
475 	}
476 
477 	dev_dbg(priv->dev, "Adding vlanid %d to vlan filter\n", vid);
478 	ret = cpsw_add_vlan_ale_entry(priv, vid);
479 err:
480 	pm_runtime_put(cpsw->dev);
481 	return ret;
482 }
483 
484 static int cpsw_restore_vlans(struct net_device *vdev, int vid, void *arg)
485 {
486 	struct cpsw_priv *priv = arg;
487 
488 	if (!vdev || !vid)
489 		return 0;
490 
491 	cpsw_ndo_vlan_rx_add_vid(priv->ndev, 0, vid);
492 	return 0;
493 }
494 
495 /* restore resources after port reset */
496 static void cpsw_restore(struct cpsw_priv *priv)
497 {
498 	struct cpsw_common *cpsw = priv->cpsw;
499 
500 	/* restore vlan configurations */
501 	vlan_for_each(priv->ndev, cpsw_restore_vlans, priv);
502 
503 	/* restore MQPRIO offload */
504 	cpsw_mqprio_resume(&cpsw->slaves[priv->emac_port - 1], priv);
505 
506 	/* restore CBS offload */
507 	cpsw_cbs_resume(&cpsw->slaves[priv->emac_port - 1], priv);
508 }
509 
510 static void cpsw_init_stp_ale_entry(struct cpsw_common *cpsw)
511 {
512 	char stpa[] = {0x01, 0x80, 0xc2, 0x0, 0x0, 0x0};
513 
514 	cpsw_ale_add_mcast(cpsw->ale, stpa,
515 			   ALE_PORT_HOST, ALE_SUPER, 0,
516 			   ALE_MCAST_BLOCK_LEARN_FWD);
517 }
518 
519 static void cpsw_init_host_port_switch(struct cpsw_common *cpsw)
520 {
521 	int vlan = cpsw->data.default_vlan;
522 
523 	writel(CPSW_FIFO_NORMAL_MODE, &cpsw->host_port_regs->tx_in_ctl);
524 
525 	writel(vlan, &cpsw->host_port_regs->port_vlan);
526 
527 	cpsw_ale_add_vlan(cpsw->ale, vlan, ALE_ALL_PORTS,
528 			  ALE_ALL_PORTS, ALE_ALL_PORTS,
529 			  ALE_PORT_1 | ALE_PORT_2);
530 
531 	cpsw_init_stp_ale_entry(cpsw);
532 
533 	cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM, ALE_P0_UNI_FLOOD, 1);
534 	dev_dbg(cpsw->dev, "Set P0_UNI_FLOOD\n");
535 	cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM, ALE_PORT_NOLEARN, 0);
536 }
537 
538 static void cpsw_init_host_port_dual_mac(struct cpsw_common *cpsw)
539 {
540 	int vlan = cpsw->data.default_vlan;
541 
542 	writel(CPSW_FIFO_DUAL_MAC_MODE, &cpsw->host_port_regs->tx_in_ctl);
543 
544 	cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM, ALE_P0_UNI_FLOOD, 0);
545 	dev_dbg(cpsw->dev, "unset P0_UNI_FLOOD\n");
546 
547 	writel(vlan, &cpsw->host_port_regs->port_vlan);
548 
549 	cpsw_ale_add_vlan(cpsw->ale, vlan, ALE_ALL_PORTS, ALE_ALL_PORTS, 0, 0);
550 	/* learning make no sense in dual_mac mode */
551 	cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM, ALE_PORT_NOLEARN, 1);
552 }
553 
554 static void cpsw_init_host_port(struct cpsw_priv *priv)
555 {
556 	struct cpsw_common *cpsw = priv->cpsw;
557 	u32 control_reg;
558 
559 	/* soft reset the controller and initialize ale */
560 	soft_reset("cpsw", &cpsw->regs->soft_reset);
561 	cpsw_ale_start(cpsw->ale);
562 
563 	/* switch to vlan unaware mode */
564 	cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM, ALE_VLAN_AWARE,
565 			     CPSW_ALE_VLAN_AWARE);
566 	control_reg = readl(&cpsw->regs->control);
567 	control_reg |= CPSW_VLAN_AWARE | CPSW_RX_VLAN_ENCAP;
568 	writel(control_reg, &cpsw->regs->control);
569 
570 	/* setup host port priority mapping */
571 	writel_relaxed(CPDMA_TX_PRIORITY_MAP,
572 		       &cpsw->host_port_regs->cpdma_tx_pri_map);
573 	writel_relaxed(0, &cpsw->host_port_regs->cpdma_rx_chan_map);
574 
575 	/* disable priority elevation */
576 	writel_relaxed(0, &cpsw->regs->ptype);
577 
578 	/* enable statistics collection only on all ports */
579 	writel_relaxed(0x7, &cpsw->regs->stat_port_en);
580 
581 	/* Enable internal fifo flow control */
582 	writel(0x7, &cpsw->regs->flow_control);
583 
584 	if (cpsw_is_switch_en(cpsw))
585 		cpsw_init_host_port_switch(cpsw);
586 	else
587 		cpsw_init_host_port_dual_mac(cpsw);
588 
589 	cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM,
590 			     ALE_PORT_STATE, ALE_PORT_STATE_FORWARD);
591 }
592 
593 static void cpsw_port_add_dual_emac_def_ale_entries(struct cpsw_priv *priv,
594 						    struct cpsw_slave *slave)
595 {
596 	u32 port_mask = 1 << priv->emac_port | ALE_PORT_HOST;
597 	struct cpsw_common *cpsw = priv->cpsw;
598 	u32 reg;
599 
600 	reg = (cpsw->version == CPSW_VERSION_1) ? CPSW1_PORT_VLAN :
601 	       CPSW2_PORT_VLAN;
602 	slave_write(slave, slave->port_vlan, reg);
603 
604 	cpsw_ale_add_vlan(cpsw->ale, slave->port_vlan, port_mask,
605 			  port_mask, port_mask, 0);
606 	cpsw_ale_add_mcast(cpsw->ale, priv->ndev->broadcast,
607 			   ALE_PORT_HOST, ALE_VLAN, slave->port_vlan,
608 			   ALE_MCAST_FWD);
609 	cpsw_ale_add_ucast(cpsw->ale, priv->mac_addr,
610 			   HOST_PORT_NUM, ALE_VLAN |
611 			   ALE_SECURE, slave->port_vlan);
612 	cpsw_ale_control_set(cpsw->ale, priv->emac_port,
613 			     ALE_PORT_DROP_UNKNOWN_VLAN, 1);
614 	/* learning make no sense in dual_mac mode */
615 	cpsw_ale_control_set(cpsw->ale, priv->emac_port,
616 			     ALE_PORT_NOLEARN, 1);
617 }
618 
619 static void cpsw_port_add_switch_def_ale_entries(struct cpsw_priv *priv,
620 						 struct cpsw_slave *slave)
621 {
622 	u32 port_mask = 1 << priv->emac_port | ALE_PORT_HOST;
623 	struct cpsw_common *cpsw = priv->cpsw;
624 	u32 reg;
625 
626 	cpsw_ale_control_set(cpsw->ale, priv->emac_port,
627 			     ALE_PORT_DROP_UNKNOWN_VLAN, 0);
628 	cpsw_ale_control_set(cpsw->ale, priv->emac_port,
629 			     ALE_PORT_NOLEARN, 0);
630 	/* disabling SA_UPDATE required to make stp work, without this setting
631 	 * Host MAC addresses will jump between ports.
632 	 * As per TRM MAC address can be defined as unicast supervisory (super)
633 	 * by setting both (ALE_BLOCKED | ALE_SECURE) which should prevent
634 	 * SA_UPDATE, but HW seems works incorrectly and setting ALE_SECURE
635 	 * causes STP packets to be dropped due to ingress filter
636 	 *	if (source address found) and (secure) and
637 	 *	   (receive port number != port_number))
638 	 *	   then discard the packet
639 	 */
640 	cpsw_ale_control_set(cpsw->ale, priv->emac_port,
641 			     ALE_PORT_NO_SA_UPDATE, 1);
642 
643 	cpsw_ale_add_mcast(cpsw->ale, priv->ndev->broadcast,
644 			   port_mask, ALE_VLAN, slave->port_vlan,
645 			   ALE_MCAST_FWD_2);
646 	cpsw_ale_add_ucast(cpsw->ale, priv->mac_addr,
647 			   HOST_PORT_NUM, ALE_VLAN, slave->port_vlan);
648 
649 	reg = (cpsw->version == CPSW_VERSION_1) ? CPSW1_PORT_VLAN :
650 	       CPSW2_PORT_VLAN;
651 	slave_write(slave, slave->port_vlan, reg);
652 }
653 
654 static void cpsw_adjust_link(struct net_device *ndev)
655 {
656 	struct cpsw_priv *priv = netdev_priv(ndev);
657 	struct cpsw_common *cpsw = priv->cpsw;
658 	struct cpsw_slave *slave;
659 	struct phy_device *phy;
660 	u32 mac_control = 0;
661 
662 	slave = &cpsw->slaves[priv->emac_port - 1];
663 	phy = slave->phy;
664 
665 	if (!phy)
666 		return;
667 
668 	if (phy->link) {
669 		mac_control = CPSW_SL_CTL_GMII_EN;
670 
671 		if (phy->speed == 1000)
672 			mac_control |= CPSW_SL_CTL_GIG;
673 		if (phy->duplex)
674 			mac_control |= CPSW_SL_CTL_FULLDUPLEX;
675 
676 		/* set speed_in input in case RMII mode is used in 100Mbps */
677 		if (phy->speed == 100)
678 			mac_control |= CPSW_SL_CTL_IFCTL_A;
679 		/* in band mode only works in 10Mbps RGMII mode */
680 		else if ((phy->speed == 10) && phy_interface_is_rgmii(phy))
681 			mac_control |= CPSW_SL_CTL_EXT_EN; /* In Band mode */
682 
683 		if (priv->rx_pause)
684 			mac_control |= CPSW_SL_CTL_RX_FLOW_EN;
685 
686 		if (priv->tx_pause)
687 			mac_control |= CPSW_SL_CTL_TX_FLOW_EN;
688 
689 		if (mac_control != slave->mac_control)
690 			cpsw_sl_ctl_set(slave->mac_sl, mac_control);
691 
692 		/* enable forwarding */
693 		cpsw_ale_control_set(cpsw->ale, priv->emac_port,
694 				     ALE_PORT_STATE, ALE_PORT_STATE_FORWARD);
695 
696 		netif_tx_wake_all_queues(ndev);
697 
698 		if (priv->shp_cfg_speed &&
699 		    priv->shp_cfg_speed != slave->phy->speed &&
700 		    !cpsw_shp_is_off(priv))
701 			dev_warn(priv->dev, "Speed was changed, CBS shaper speeds are changed!");
702 	} else {
703 		netif_tx_stop_all_queues(ndev);
704 
705 		mac_control = 0;
706 		/* disable forwarding */
707 		cpsw_ale_control_set(cpsw->ale, priv->emac_port,
708 				     ALE_PORT_STATE, ALE_PORT_STATE_DISABLE);
709 
710 		cpsw_sl_wait_for_idle(slave->mac_sl, 100);
711 
712 		cpsw_sl_ctl_reset(slave->mac_sl);
713 	}
714 
715 	if (mac_control != slave->mac_control)
716 		phy_print_status(phy);
717 
718 	slave->mac_control = mac_control;
719 
720 	if (phy->link && cpsw_need_resplit(cpsw))
721 		cpsw_split_res(cpsw);
722 }
723 
724 static void cpsw_slave_open(struct cpsw_slave *slave, struct cpsw_priv *priv)
725 {
726 	struct cpsw_common *cpsw = priv->cpsw;
727 	struct phy_device *phy;
728 
729 	cpsw_sl_reset(slave->mac_sl, 100);
730 	cpsw_sl_ctl_reset(slave->mac_sl);
731 
732 	/* setup priority mapping */
733 	cpsw_sl_reg_write(slave->mac_sl, CPSW_SL_RX_PRI_MAP,
734 			  RX_PRIORITY_MAPPING);
735 
736 	switch (cpsw->version) {
737 	case CPSW_VERSION_1:
738 		slave_write(slave, TX_PRIORITY_MAPPING, CPSW1_TX_PRI_MAP);
739 		/* Increase RX FIFO size to 5 for supporting fullduplex
740 		 * flow control mode
741 		 */
742 		slave_write(slave,
743 			    (CPSW_MAX_BLKS_TX << CPSW_MAX_BLKS_TX_SHIFT) |
744 			    CPSW_MAX_BLKS_RX, CPSW1_MAX_BLKS);
745 		break;
746 	case CPSW_VERSION_2:
747 	case CPSW_VERSION_3:
748 	case CPSW_VERSION_4:
749 		slave_write(slave, TX_PRIORITY_MAPPING, CPSW2_TX_PRI_MAP);
750 		/* Increase RX FIFO size to 5 for supporting fullduplex
751 		 * flow control mode
752 		 */
753 		slave_write(slave,
754 			    (CPSW_MAX_BLKS_TX << CPSW_MAX_BLKS_TX_SHIFT) |
755 			    CPSW_MAX_BLKS_RX, CPSW2_MAX_BLKS);
756 		break;
757 	}
758 
759 	/* setup max packet size, and mac address */
760 	cpsw_sl_reg_write(slave->mac_sl, CPSW_SL_RX_MAXLEN,
761 			  cpsw->rx_packet_max);
762 	cpsw_set_slave_mac(slave, priv);
763 
764 	slave->mac_control = 0;	/* no link yet */
765 
766 	if (cpsw_is_switch_en(cpsw))
767 		cpsw_port_add_switch_def_ale_entries(priv, slave);
768 	else
769 		cpsw_port_add_dual_emac_def_ale_entries(priv, slave);
770 
771 	if (!slave->data->phy_node)
772 		dev_err(priv->dev, "no phy found on slave %d\n",
773 			slave->slave_num);
774 	phy = of_phy_connect(priv->ndev, slave->data->phy_node,
775 			     &cpsw_adjust_link, 0, slave->data->phy_if);
776 	if (!phy) {
777 		dev_err(priv->dev, "phy \"%pOF\" not found on slave %d\n",
778 			slave->data->phy_node,
779 			slave->slave_num);
780 		return;
781 	}
782 	slave->phy = phy;
783 
784 	phy_attached_info(slave->phy);
785 
786 	phy_start(slave->phy);
787 
788 	/* Configure GMII_SEL register */
789 	phy_set_mode_ext(slave->data->ifphy, PHY_MODE_ETHERNET,
790 			 slave->data->phy_if);
791 }
792 
793 static int cpsw_ndo_stop(struct net_device *ndev)
794 {
795 	struct cpsw_priv *priv = netdev_priv(ndev);
796 	struct cpsw_common *cpsw = priv->cpsw;
797 	struct cpsw_slave *slave;
798 
799 	cpsw_info(priv, ifdown, "shutting down ndev\n");
800 	slave = &cpsw->slaves[priv->emac_port - 1];
801 	if (slave->phy)
802 		phy_stop(slave->phy);
803 
804 	netif_tx_stop_all_queues(priv->ndev);
805 
806 	if (slave->phy) {
807 		phy_disconnect(slave->phy);
808 		slave->phy = NULL;
809 	}
810 
811 	__hw_addr_ref_unsync_dev(&ndev->mc, ndev, cpsw_purge_all_mc);
812 
813 	if (cpsw->usage_count <= 1) {
814 		napi_disable(&cpsw->napi_rx);
815 		napi_disable(&cpsw->napi_tx);
816 		cpts_unregister(cpsw->cpts);
817 		cpsw_intr_disable(cpsw);
818 		cpdma_ctlr_stop(cpsw->dma);
819 		cpsw_ale_stop(cpsw->ale);
820 		cpsw_destroy_xdp_rxqs(cpsw);
821 	}
822 
823 	if (cpsw_need_resplit(cpsw))
824 		cpsw_split_res(cpsw);
825 
826 	cpsw->usage_count--;
827 	pm_runtime_put_sync(cpsw->dev);
828 	return 0;
829 }
830 
831 static int cpsw_ndo_open(struct net_device *ndev)
832 {
833 	struct cpsw_priv *priv = netdev_priv(ndev);
834 	struct cpsw_common *cpsw = priv->cpsw;
835 	int ret;
836 
837 	dev_info(priv->dev, "starting ndev. mode: %s\n",
838 		 cpsw_is_switch_en(cpsw) ? "switch" : "dual_mac");
839 	ret = pm_runtime_get_sync(cpsw->dev);
840 	if (ret < 0) {
841 		pm_runtime_put_noidle(cpsw->dev);
842 		return ret;
843 	}
844 
845 	/* Notify the stack of the actual queue counts. */
846 	ret = netif_set_real_num_tx_queues(ndev, cpsw->tx_ch_num);
847 	if (ret) {
848 		dev_err(priv->dev, "cannot set real number of tx queues\n");
849 		goto pm_cleanup;
850 	}
851 
852 	ret = netif_set_real_num_rx_queues(ndev, cpsw->rx_ch_num);
853 	if (ret) {
854 		dev_err(priv->dev, "cannot set real number of rx queues\n");
855 		goto pm_cleanup;
856 	}
857 
858 	/* Initialize host and slave ports */
859 	if (!cpsw->usage_count)
860 		cpsw_init_host_port(priv);
861 	cpsw_slave_open(&cpsw->slaves[priv->emac_port - 1], priv);
862 
863 	/* initialize shared resources for every ndev */
864 	if (!cpsw->usage_count) {
865 		/* create rxqs for both infs in dual mac as they use same pool
866 		 * and must be destroyed together when no users.
867 		 */
868 		ret = cpsw_create_xdp_rxqs(cpsw);
869 		if (ret < 0)
870 			goto err_cleanup;
871 
872 		ret = cpsw_fill_rx_channels(priv);
873 		if (ret < 0)
874 			goto err_cleanup;
875 
876 		if (cpts_register(cpsw->cpts))
877 			dev_err(priv->dev, "error registering cpts device\n");
878 
879 		napi_enable(&cpsw->napi_rx);
880 		napi_enable(&cpsw->napi_tx);
881 
882 		if (cpsw->tx_irq_disabled) {
883 			cpsw->tx_irq_disabled = false;
884 			enable_irq(cpsw->irqs_table[1]);
885 		}
886 
887 		if (cpsw->rx_irq_disabled) {
888 			cpsw->rx_irq_disabled = false;
889 			enable_irq(cpsw->irqs_table[0]);
890 		}
891 	}
892 
893 	cpsw_restore(priv);
894 
895 	/* Enable Interrupt pacing if configured */
896 	if (cpsw->coal_intvl != 0) {
897 		struct ethtool_coalesce coal;
898 
899 		coal.rx_coalesce_usecs = cpsw->coal_intvl;
900 		cpsw_set_coalesce(ndev, &coal);
901 	}
902 
903 	cpdma_ctlr_start(cpsw->dma);
904 	cpsw_intr_enable(cpsw);
905 	cpsw->usage_count++;
906 
907 	return 0;
908 
909 err_cleanup:
910 	cpsw_ndo_stop(ndev);
911 
912 pm_cleanup:
913 	pm_runtime_put_sync(cpsw->dev);
914 	return ret;
915 }
916 
917 static netdev_tx_t cpsw_ndo_start_xmit(struct sk_buff *skb,
918 				       struct net_device *ndev)
919 {
920 	struct cpsw_priv *priv = netdev_priv(ndev);
921 	struct cpsw_common *cpsw = priv->cpsw;
922 	struct cpts *cpts = cpsw->cpts;
923 	struct netdev_queue *txq;
924 	struct cpdma_chan *txch;
925 	int ret, q_idx;
926 
927 	if (skb_padto(skb, CPSW_MIN_PACKET_SIZE)) {
928 		cpsw_err(priv, tx_err, "packet pad failed\n");
929 		ndev->stats.tx_dropped++;
930 		return NET_XMIT_DROP;
931 	}
932 
933 	if (skb_shinfo(skb)->tx_flags & SKBTX_HW_TSTAMP &&
934 	    priv->tx_ts_enabled && cpts_can_timestamp(cpts, skb))
935 		skb_shinfo(skb)->tx_flags |= SKBTX_IN_PROGRESS;
936 
937 	q_idx = skb_get_queue_mapping(skb);
938 	if (q_idx >= cpsw->tx_ch_num)
939 		q_idx = q_idx % cpsw->tx_ch_num;
940 
941 	txch = cpsw->txv[q_idx].ch;
942 	txq = netdev_get_tx_queue(ndev, q_idx);
943 	skb_tx_timestamp(skb);
944 	ret = cpdma_chan_submit(txch, skb, skb->data, skb->len,
945 				priv->emac_port);
946 	if (unlikely(ret != 0)) {
947 		cpsw_err(priv, tx_err, "desc submit failed\n");
948 		goto fail;
949 	}
950 
951 	/* If there is no more tx desc left free then we need to
952 	 * tell the kernel to stop sending us tx frames.
953 	 */
954 	if (unlikely(!cpdma_check_free_tx_desc(txch))) {
955 		netif_tx_stop_queue(txq);
956 
957 		/* Barrier, so that stop_queue visible to other cpus */
958 		smp_mb__after_atomic();
959 
960 		if (cpdma_check_free_tx_desc(txch))
961 			netif_tx_wake_queue(txq);
962 	}
963 
964 	return NETDEV_TX_OK;
965 fail:
966 	ndev->stats.tx_dropped++;
967 	netif_tx_stop_queue(txq);
968 
969 	/* Barrier, so that stop_queue visible to other cpus */
970 	smp_mb__after_atomic();
971 
972 	if (cpdma_check_free_tx_desc(txch))
973 		netif_tx_wake_queue(txq);
974 
975 	return NETDEV_TX_BUSY;
976 }
977 
978 static int cpsw_ndo_set_mac_address(struct net_device *ndev, void *p)
979 {
980 	struct sockaddr *addr = (struct sockaddr *)p;
981 	struct cpsw_priv *priv = netdev_priv(ndev);
982 	struct cpsw_common *cpsw = priv->cpsw;
983 	int ret, slave_no;
984 	int flags = 0;
985 	u16 vid = 0;
986 
987 	slave_no = cpsw_slave_index(cpsw, priv);
988 	if (!is_valid_ether_addr(addr->sa_data))
989 		return -EADDRNOTAVAIL;
990 
991 	ret = pm_runtime_get_sync(cpsw->dev);
992 	if (ret < 0) {
993 		pm_runtime_put_noidle(cpsw->dev);
994 		return ret;
995 	}
996 
997 	vid = cpsw->slaves[slave_no].port_vlan;
998 	flags = ALE_VLAN | ALE_SECURE;
999 
1000 	cpsw_ale_del_ucast(cpsw->ale, priv->mac_addr, HOST_PORT_NUM,
1001 			   flags, vid);
1002 	cpsw_ale_add_ucast(cpsw->ale, addr->sa_data, HOST_PORT_NUM,
1003 			   flags, vid);
1004 
1005 	ether_addr_copy(priv->mac_addr, addr->sa_data);
1006 	ether_addr_copy(ndev->dev_addr, priv->mac_addr);
1007 	cpsw_set_slave_mac(&cpsw->slaves[slave_no], priv);
1008 
1009 	pm_runtime_put(cpsw->dev);
1010 
1011 	return 0;
1012 }
1013 
1014 static int cpsw_ndo_vlan_rx_kill_vid(struct net_device *ndev,
1015 				     __be16 proto, u16 vid)
1016 {
1017 	struct cpsw_priv *priv = netdev_priv(ndev);
1018 	struct cpsw_common *cpsw = priv->cpsw;
1019 	int ret;
1020 	int i;
1021 
1022 	if (cpsw_is_switch_en(cpsw)) {
1023 		dev_dbg(cpsw->dev, "ndo del vlan is called in switch mode\n");
1024 		return 0;
1025 	}
1026 
1027 	if (vid == cpsw->data.default_vlan)
1028 		return 0;
1029 
1030 	ret = pm_runtime_get_sync(cpsw->dev);
1031 	if (ret < 0) {
1032 		pm_runtime_put_noidle(cpsw->dev);
1033 		return ret;
1034 	}
1035 
1036 	/* reset the return code as pm_runtime_get_sync() can return
1037 	 * non zero values as well.
1038 	 */
1039 	ret = 0;
1040 	for (i = 0; i < cpsw->data.slaves; i++) {
1041 		if (cpsw->slaves[i].ndev &&
1042 		    vid == cpsw->slaves[i].port_vlan) {
1043 			ret = -EINVAL;
1044 			goto err;
1045 		}
1046 	}
1047 
1048 	dev_dbg(priv->dev, "removing vlanid %d from vlan filter\n", vid);
1049 	ret = cpsw_ale_del_vlan(cpsw->ale, vid, 0);
1050 	if (ret)
1051 		dev_err(priv->dev, "cpsw_ale_del_vlan() failed: ret %d\n", ret);
1052 	ret = cpsw_ale_del_ucast(cpsw->ale, priv->mac_addr,
1053 				 HOST_PORT_NUM, ALE_VLAN, vid);
1054 	if (ret)
1055 		dev_err(priv->dev, "cpsw_ale_del_ucast() failed: ret %d\n",
1056 			ret);
1057 	ret = cpsw_ale_del_mcast(cpsw->ale, priv->ndev->broadcast,
1058 				 0, ALE_VLAN, vid);
1059 	if (ret)
1060 		dev_err(priv->dev, "cpsw_ale_del_mcast failed. ret %d\n",
1061 			ret);
1062 	cpsw_ale_flush_multicast(cpsw->ale, ALE_PORT_HOST, vid);
1063 	ret = 0;
1064 err:
1065 	pm_runtime_put(cpsw->dev);
1066 	return ret;
1067 }
1068 
1069 static int cpsw_ndo_get_phys_port_name(struct net_device *ndev, char *name,
1070 				       size_t len)
1071 {
1072 	struct cpsw_priv *priv = netdev_priv(ndev);
1073 	int err;
1074 
1075 	err = snprintf(name, len, "p%d", priv->emac_port);
1076 
1077 	if (err >= len)
1078 		return -EINVAL;
1079 
1080 	return 0;
1081 }
1082 
1083 #ifdef CONFIG_NET_POLL_CONTROLLER
1084 static void cpsw_ndo_poll_controller(struct net_device *ndev)
1085 {
1086 	struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
1087 
1088 	cpsw_intr_disable(cpsw);
1089 	cpsw_rx_interrupt(cpsw->irqs_table[0], cpsw);
1090 	cpsw_tx_interrupt(cpsw->irqs_table[1], cpsw);
1091 	cpsw_intr_enable(cpsw);
1092 }
1093 #endif
1094 
1095 static int cpsw_ndo_xdp_xmit(struct net_device *ndev, int n,
1096 			     struct xdp_frame **frames, u32 flags)
1097 {
1098 	struct cpsw_priv *priv = netdev_priv(ndev);
1099 	struct xdp_frame *xdpf;
1100 	int i, drops = 0;
1101 
1102 	if (unlikely(flags & ~XDP_XMIT_FLAGS_MASK))
1103 		return -EINVAL;
1104 
1105 	for (i = 0; i < n; i++) {
1106 		xdpf = frames[i];
1107 		if (xdpf->len < CPSW_MIN_PACKET_SIZE) {
1108 			xdp_return_frame_rx_napi(xdpf);
1109 			drops++;
1110 			continue;
1111 		}
1112 
1113 		if (cpsw_xdp_tx_frame(priv, xdpf, NULL, priv->emac_port))
1114 			drops++;
1115 	}
1116 
1117 	return n - drops;
1118 }
1119 
1120 static int cpsw_get_port_parent_id(struct net_device *ndev,
1121 				   struct netdev_phys_item_id *ppid)
1122 {
1123 	struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
1124 
1125 	ppid->id_len = sizeof(cpsw->base_mac);
1126 	memcpy(&ppid->id, &cpsw->base_mac, ppid->id_len);
1127 
1128 	return 0;
1129 }
1130 
1131 static const struct net_device_ops cpsw_netdev_ops = {
1132 	.ndo_open		= cpsw_ndo_open,
1133 	.ndo_stop		= cpsw_ndo_stop,
1134 	.ndo_start_xmit		= cpsw_ndo_start_xmit,
1135 	.ndo_set_mac_address	= cpsw_ndo_set_mac_address,
1136 	.ndo_do_ioctl		= cpsw_ndo_ioctl,
1137 	.ndo_validate_addr	= eth_validate_addr,
1138 	.ndo_tx_timeout		= cpsw_ndo_tx_timeout,
1139 	.ndo_set_rx_mode	= cpsw_ndo_set_rx_mode,
1140 	.ndo_set_tx_maxrate	= cpsw_ndo_set_tx_maxrate,
1141 #ifdef CONFIG_NET_POLL_CONTROLLER
1142 	.ndo_poll_controller	= cpsw_ndo_poll_controller,
1143 #endif
1144 	.ndo_vlan_rx_add_vid	= cpsw_ndo_vlan_rx_add_vid,
1145 	.ndo_vlan_rx_kill_vid	= cpsw_ndo_vlan_rx_kill_vid,
1146 	.ndo_setup_tc           = cpsw_ndo_setup_tc,
1147 	.ndo_get_phys_port_name = cpsw_ndo_get_phys_port_name,
1148 	.ndo_bpf		= cpsw_ndo_bpf,
1149 	.ndo_xdp_xmit		= cpsw_ndo_xdp_xmit,
1150 	.ndo_get_port_parent_id	= cpsw_get_port_parent_id,
1151 };
1152 
1153 static void cpsw_get_drvinfo(struct net_device *ndev,
1154 			     struct ethtool_drvinfo *info)
1155 {
1156 	struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
1157 	struct platform_device *pdev;
1158 
1159 	pdev = to_platform_device(cpsw->dev);
1160 	strlcpy(info->driver, "cpsw-switch", sizeof(info->driver));
1161 	strlcpy(info->version, "2.0", sizeof(info->version));
1162 	strlcpy(info->bus_info, pdev->name, sizeof(info->bus_info));
1163 }
1164 
1165 static int cpsw_set_pauseparam(struct net_device *ndev,
1166 			       struct ethtool_pauseparam *pause)
1167 {
1168 	struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
1169 	struct cpsw_priv *priv = netdev_priv(ndev);
1170 	int slave_no;
1171 
1172 	slave_no = cpsw_slave_index(cpsw, priv);
1173 	if (!cpsw->slaves[slave_no].phy)
1174 		return -EINVAL;
1175 
1176 	if (!phy_validate_pause(cpsw->slaves[slave_no].phy, pause))
1177 		return -EINVAL;
1178 
1179 	priv->rx_pause = pause->rx_pause ? true : false;
1180 	priv->tx_pause = pause->tx_pause ? true : false;
1181 
1182 	phy_set_asym_pause(cpsw->slaves[slave_no].phy,
1183 			   priv->rx_pause, priv->tx_pause);
1184 
1185 	return 0;
1186 }
1187 
1188 static int cpsw_set_channels(struct net_device *ndev,
1189 			     struct ethtool_channels *chs)
1190 {
1191 	return cpsw_set_channels_common(ndev, chs, cpsw_rx_handler);
1192 }
1193 
1194 static const struct ethtool_ops cpsw_ethtool_ops = {
1195 	.supported_coalesce_params = ETHTOOL_COALESCE_RX_USECS,
1196 	.get_drvinfo		= cpsw_get_drvinfo,
1197 	.get_msglevel		= cpsw_get_msglevel,
1198 	.set_msglevel		= cpsw_set_msglevel,
1199 	.get_link		= ethtool_op_get_link,
1200 	.get_ts_info		= cpsw_get_ts_info,
1201 	.get_coalesce		= cpsw_get_coalesce,
1202 	.set_coalesce		= cpsw_set_coalesce,
1203 	.get_sset_count		= cpsw_get_sset_count,
1204 	.get_strings		= cpsw_get_strings,
1205 	.get_ethtool_stats	= cpsw_get_ethtool_stats,
1206 	.get_pauseparam		= cpsw_get_pauseparam,
1207 	.set_pauseparam		= cpsw_set_pauseparam,
1208 	.get_wol		= cpsw_get_wol,
1209 	.set_wol		= cpsw_set_wol,
1210 	.get_regs_len		= cpsw_get_regs_len,
1211 	.get_regs		= cpsw_get_regs,
1212 	.begin			= cpsw_ethtool_op_begin,
1213 	.complete		= cpsw_ethtool_op_complete,
1214 	.get_channels		= cpsw_get_channels,
1215 	.set_channels		= cpsw_set_channels,
1216 	.get_link_ksettings	= cpsw_get_link_ksettings,
1217 	.set_link_ksettings	= cpsw_set_link_ksettings,
1218 	.get_eee		= cpsw_get_eee,
1219 	.set_eee		= cpsw_set_eee,
1220 	.nway_reset		= cpsw_nway_reset,
1221 	.get_ringparam		= cpsw_get_ringparam,
1222 	.set_ringparam		= cpsw_set_ringparam,
1223 };
1224 
1225 static int cpsw_probe_dt(struct cpsw_common *cpsw)
1226 {
1227 	struct device_node *node = cpsw->dev->of_node, *tmp_node, *port_np;
1228 	struct cpsw_platform_data *data = &cpsw->data;
1229 	struct device *dev = cpsw->dev;
1230 	int ret;
1231 	u32 prop;
1232 
1233 	if (!node)
1234 		return -EINVAL;
1235 
1236 	tmp_node = of_get_child_by_name(node, "ethernet-ports");
1237 	if (!tmp_node)
1238 		return -ENOENT;
1239 	data->slaves = of_get_child_count(tmp_node);
1240 	if (data->slaves != CPSW_SLAVE_PORTS_NUM) {
1241 		of_node_put(tmp_node);
1242 		return -ENOENT;
1243 	}
1244 
1245 	data->active_slave = 0;
1246 	data->channels = CPSW_MAX_QUEUES;
1247 	data->dual_emac = true;
1248 	data->bd_ram_size = CPSW_BD_RAM_SIZE;
1249 	data->mac_control = 0;
1250 
1251 	data->slave_data = devm_kcalloc(dev, CPSW_SLAVE_PORTS_NUM,
1252 					sizeof(struct cpsw_slave_data),
1253 					GFP_KERNEL);
1254 	if (!data->slave_data)
1255 		return -ENOMEM;
1256 
1257 	/* Populate all the child nodes here...
1258 	 */
1259 	ret = devm_of_platform_populate(dev);
1260 	/* We do not want to force this, as in some cases may not have child */
1261 	if (ret)
1262 		dev_warn(dev, "Doesn't have any child node\n");
1263 
1264 	for_each_child_of_node(tmp_node, port_np) {
1265 		struct cpsw_slave_data *slave_data;
1266 		const void *mac_addr;
1267 		u32 port_id;
1268 
1269 		ret = of_property_read_u32(port_np, "reg", &port_id);
1270 		if (ret < 0) {
1271 			dev_err(dev, "%pOF error reading port_id %d\n",
1272 				port_np, ret);
1273 			goto err_node_put;
1274 		}
1275 
1276 		if (!port_id || port_id > CPSW_SLAVE_PORTS_NUM) {
1277 			dev_err(dev, "%pOF has invalid port_id %u\n",
1278 				port_np, port_id);
1279 			ret = -EINVAL;
1280 			goto err_node_put;
1281 		}
1282 
1283 		slave_data = &data->slave_data[port_id - 1];
1284 
1285 		slave_data->disabled = !of_device_is_available(port_np);
1286 		if (slave_data->disabled)
1287 			continue;
1288 
1289 		slave_data->slave_node = port_np;
1290 		slave_data->ifphy = devm_of_phy_get(dev, port_np, NULL);
1291 		if (IS_ERR(slave_data->ifphy)) {
1292 			ret = PTR_ERR(slave_data->ifphy);
1293 			dev_err(dev, "%pOF: Error retrieving port phy: %d\n",
1294 				port_np, ret);
1295 			goto err_node_put;
1296 		}
1297 
1298 		if (of_phy_is_fixed_link(port_np)) {
1299 			ret = of_phy_register_fixed_link(port_np);
1300 			if (ret) {
1301 				if (ret != -EPROBE_DEFER)
1302 					dev_err(dev, "%pOF failed to register fixed-link phy: %d\n",
1303 						port_np, ret);
1304 				goto err_node_put;
1305 			}
1306 			slave_data->phy_node = of_node_get(port_np);
1307 		} else {
1308 			slave_data->phy_node =
1309 				of_parse_phandle(port_np, "phy-handle", 0);
1310 		}
1311 
1312 		if (!slave_data->phy_node) {
1313 			dev_err(dev, "%pOF no phy found\n", port_np);
1314 			ret = -ENODEV;
1315 			goto err_node_put;
1316 		}
1317 
1318 		ret = of_get_phy_mode(port_np, &slave_data->phy_if);
1319 		if (ret) {
1320 			dev_err(dev, "%pOF read phy-mode err %d\n",
1321 				port_np, ret);
1322 			goto err_node_put;
1323 		}
1324 
1325 		mac_addr = of_get_mac_address(port_np);
1326 		if (!IS_ERR(mac_addr)) {
1327 			ether_addr_copy(slave_data->mac_addr, mac_addr);
1328 		} else {
1329 			ret = ti_cm_get_macid(dev, port_id - 1,
1330 					      slave_data->mac_addr);
1331 			if (ret)
1332 				goto err_node_put;
1333 		}
1334 
1335 		if (of_property_read_u32(port_np, "ti,dual-emac-pvid",
1336 					 &prop)) {
1337 			dev_err(dev, "%pOF Missing dual_emac_res_vlan in DT.\n",
1338 				port_np);
1339 			slave_data->dual_emac_res_vlan = port_id;
1340 			dev_err(dev, "%pOF Using %d as Reserved VLAN\n",
1341 				port_np, slave_data->dual_emac_res_vlan);
1342 		} else {
1343 			slave_data->dual_emac_res_vlan = prop;
1344 		}
1345 	}
1346 
1347 	of_node_put(tmp_node);
1348 	return 0;
1349 
1350 err_node_put:
1351 	of_node_put(port_np);
1352 	return ret;
1353 }
1354 
1355 static void cpsw_remove_dt(struct cpsw_common *cpsw)
1356 {
1357 	struct cpsw_platform_data *data = &cpsw->data;
1358 	int i = 0;
1359 
1360 	for (i = 0; i < cpsw->data.slaves; i++) {
1361 		struct cpsw_slave_data *slave_data = &data->slave_data[i];
1362 		struct device_node *port_np = slave_data->phy_node;
1363 
1364 		if (port_np) {
1365 			if (of_phy_is_fixed_link(port_np))
1366 				of_phy_deregister_fixed_link(port_np);
1367 
1368 			of_node_put(port_np);
1369 		}
1370 	}
1371 }
1372 
1373 static int cpsw_create_ports(struct cpsw_common *cpsw)
1374 {
1375 	struct cpsw_platform_data *data = &cpsw->data;
1376 	struct net_device *ndev, *napi_ndev = NULL;
1377 	struct device *dev = cpsw->dev;
1378 	struct cpsw_priv *priv;
1379 	int ret = 0, i = 0;
1380 
1381 	for (i = 0; i < cpsw->data.slaves; i++) {
1382 		struct cpsw_slave_data *slave_data = &data->slave_data[i];
1383 
1384 		if (slave_data->disabled)
1385 			continue;
1386 
1387 		ndev = devm_alloc_etherdev_mqs(dev, sizeof(struct cpsw_priv),
1388 					       CPSW_MAX_QUEUES,
1389 					       CPSW_MAX_QUEUES);
1390 		if (!ndev) {
1391 			dev_err(dev, "error allocating net_device\n");
1392 			return -ENOMEM;
1393 		}
1394 
1395 		priv = netdev_priv(ndev);
1396 		priv->cpsw = cpsw;
1397 		priv->ndev = ndev;
1398 		priv->dev  = dev;
1399 		priv->msg_enable = netif_msg_init(debug_level, CPSW_DEBUG);
1400 		priv->emac_port = i + 1;
1401 
1402 		if (is_valid_ether_addr(slave_data->mac_addr)) {
1403 			ether_addr_copy(priv->mac_addr, slave_data->mac_addr);
1404 			dev_info(cpsw->dev, "Detected MACID = %pM\n",
1405 				 priv->mac_addr);
1406 		} else {
1407 			eth_random_addr(slave_data->mac_addr);
1408 			dev_info(cpsw->dev, "Random MACID = %pM\n",
1409 				 priv->mac_addr);
1410 		}
1411 		ether_addr_copy(ndev->dev_addr, slave_data->mac_addr);
1412 		ether_addr_copy(priv->mac_addr, slave_data->mac_addr);
1413 
1414 		cpsw->slaves[i].ndev = ndev;
1415 
1416 		ndev->features |= NETIF_F_HW_VLAN_CTAG_FILTER |
1417 				  NETIF_F_HW_VLAN_CTAG_RX | NETIF_F_NETNS_LOCAL;
1418 
1419 		ndev->netdev_ops = &cpsw_netdev_ops;
1420 		ndev->ethtool_ops = &cpsw_ethtool_ops;
1421 		SET_NETDEV_DEV(ndev, dev);
1422 
1423 		if (!napi_ndev) {
1424 			/* CPSW Host port CPDMA interface is shared between
1425 			 * ports and there is only one TX and one RX IRQs
1426 			 * available for all possible TX and RX channels
1427 			 * accordingly.
1428 			 */
1429 			netif_napi_add(ndev, &cpsw->napi_rx,
1430 				       cpsw->quirk_irq ?
1431 				       cpsw_rx_poll : cpsw_rx_mq_poll,
1432 				       CPSW_POLL_WEIGHT);
1433 			netif_tx_napi_add(ndev, &cpsw->napi_tx,
1434 					  cpsw->quirk_irq ?
1435 					  cpsw_tx_poll : cpsw_tx_mq_poll,
1436 					  CPSW_POLL_WEIGHT);
1437 		}
1438 
1439 		napi_ndev = ndev;
1440 	}
1441 
1442 	return ret;
1443 }
1444 
1445 static void cpsw_unregister_ports(struct cpsw_common *cpsw)
1446 {
1447 	int i = 0;
1448 
1449 	for (i = 0; i < cpsw->data.slaves; i++) {
1450 		if (!cpsw->slaves[i].ndev)
1451 			continue;
1452 
1453 		unregister_netdev(cpsw->slaves[i].ndev);
1454 	}
1455 }
1456 
1457 static int cpsw_register_ports(struct cpsw_common *cpsw)
1458 {
1459 	int ret = 0, i = 0;
1460 
1461 	for (i = 0; i < cpsw->data.slaves; i++) {
1462 		if (!cpsw->slaves[i].ndev)
1463 			continue;
1464 
1465 		/* register the network device */
1466 		ret = register_netdev(cpsw->slaves[i].ndev);
1467 		if (ret) {
1468 			dev_err(cpsw->dev,
1469 				"cpsw: err registering net device%d\n", i);
1470 			cpsw->slaves[i].ndev = NULL;
1471 			break;
1472 		}
1473 	}
1474 
1475 	if (ret)
1476 		cpsw_unregister_ports(cpsw);
1477 	return ret;
1478 }
1479 
1480 bool cpsw_port_dev_check(const struct net_device *ndev)
1481 {
1482 	if (ndev->netdev_ops == &cpsw_netdev_ops) {
1483 		struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
1484 
1485 		return !cpsw->data.dual_emac;
1486 	}
1487 
1488 	return false;
1489 }
1490 
1491 static void cpsw_port_offload_fwd_mark_update(struct cpsw_common *cpsw)
1492 {
1493 	int set_val = 0;
1494 	int i;
1495 
1496 	if (!cpsw->ale_bypass &&
1497 	    (cpsw->br_members == (ALE_PORT_1 | ALE_PORT_2)))
1498 		set_val = 1;
1499 
1500 	dev_dbg(cpsw->dev, "set offload_fwd_mark %d\n", set_val);
1501 
1502 	for (i = 0; i < cpsw->data.slaves; i++) {
1503 		struct net_device *sl_ndev = cpsw->slaves[i].ndev;
1504 		struct cpsw_priv *priv = netdev_priv(sl_ndev);
1505 
1506 		priv->offload_fwd_mark = set_val;
1507 	}
1508 }
1509 
1510 static int cpsw_netdevice_port_link(struct net_device *ndev,
1511 				    struct net_device *br_ndev)
1512 {
1513 	struct cpsw_priv *priv = netdev_priv(ndev);
1514 	struct cpsw_common *cpsw = priv->cpsw;
1515 
1516 	if (!cpsw->br_members) {
1517 		cpsw->hw_bridge_dev = br_ndev;
1518 	} else {
1519 		/* This is adding the port to a second bridge, this is
1520 		 * unsupported
1521 		 */
1522 		if (cpsw->hw_bridge_dev != br_ndev)
1523 			return -EOPNOTSUPP;
1524 	}
1525 
1526 	cpsw->br_members |= BIT(priv->emac_port);
1527 
1528 	cpsw_port_offload_fwd_mark_update(cpsw);
1529 
1530 	return NOTIFY_DONE;
1531 }
1532 
1533 static void cpsw_netdevice_port_unlink(struct net_device *ndev)
1534 {
1535 	struct cpsw_priv *priv = netdev_priv(ndev);
1536 	struct cpsw_common *cpsw = priv->cpsw;
1537 
1538 	cpsw->br_members &= ~BIT(priv->emac_port);
1539 
1540 	cpsw_port_offload_fwd_mark_update(cpsw);
1541 
1542 	if (!cpsw->br_members)
1543 		cpsw->hw_bridge_dev = NULL;
1544 }
1545 
1546 /* netdev notifier */
1547 static int cpsw_netdevice_event(struct notifier_block *unused,
1548 				unsigned long event, void *ptr)
1549 {
1550 	struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
1551 	struct netdev_notifier_changeupper_info *info;
1552 	int ret = NOTIFY_DONE;
1553 
1554 	if (!cpsw_port_dev_check(ndev))
1555 		return NOTIFY_DONE;
1556 
1557 	switch (event) {
1558 	case NETDEV_CHANGEUPPER:
1559 		info = ptr;
1560 
1561 		if (netif_is_bridge_master(info->upper_dev)) {
1562 			if (info->linking)
1563 				ret = cpsw_netdevice_port_link(ndev,
1564 							       info->upper_dev);
1565 			else
1566 				cpsw_netdevice_port_unlink(ndev);
1567 		}
1568 		break;
1569 	default:
1570 		return NOTIFY_DONE;
1571 	}
1572 
1573 	return notifier_from_errno(ret);
1574 }
1575 
1576 static struct notifier_block cpsw_netdevice_nb __read_mostly = {
1577 	.notifier_call = cpsw_netdevice_event,
1578 };
1579 
1580 static int cpsw_register_notifiers(struct cpsw_common *cpsw)
1581 {
1582 	int ret = 0;
1583 
1584 	ret = register_netdevice_notifier(&cpsw_netdevice_nb);
1585 	if (ret) {
1586 		dev_err(cpsw->dev, "can't register netdevice notifier\n");
1587 		return ret;
1588 	}
1589 
1590 	ret = cpsw_switchdev_register_notifiers(cpsw);
1591 	if (ret)
1592 		unregister_netdevice_notifier(&cpsw_netdevice_nb);
1593 
1594 	return ret;
1595 }
1596 
1597 static void cpsw_unregister_notifiers(struct cpsw_common *cpsw)
1598 {
1599 	cpsw_switchdev_unregister_notifiers(cpsw);
1600 	unregister_netdevice_notifier(&cpsw_netdevice_nb);
1601 }
1602 
1603 static const struct devlink_ops cpsw_devlink_ops = {
1604 };
1605 
1606 static int cpsw_dl_switch_mode_get(struct devlink *dl, u32 id,
1607 				   struct devlink_param_gset_ctx *ctx)
1608 {
1609 	struct cpsw_devlink *dl_priv = devlink_priv(dl);
1610 	struct cpsw_common *cpsw = dl_priv->cpsw;
1611 
1612 	dev_dbg(cpsw->dev, "%s id:%u\n", __func__, id);
1613 
1614 	if (id != CPSW_DL_PARAM_SWITCH_MODE)
1615 		return  -EOPNOTSUPP;
1616 
1617 	ctx->val.vbool = !cpsw->data.dual_emac;
1618 
1619 	return 0;
1620 }
1621 
1622 static int cpsw_dl_switch_mode_set(struct devlink *dl, u32 id,
1623 				   struct devlink_param_gset_ctx *ctx)
1624 {
1625 	struct cpsw_devlink *dl_priv = devlink_priv(dl);
1626 	struct cpsw_common *cpsw = dl_priv->cpsw;
1627 	int vlan = cpsw->data.default_vlan;
1628 	bool switch_en = ctx->val.vbool;
1629 	bool if_running = false;
1630 	int i;
1631 
1632 	dev_dbg(cpsw->dev, "%s id:%u\n", __func__, id);
1633 
1634 	if (id != CPSW_DL_PARAM_SWITCH_MODE)
1635 		return  -EOPNOTSUPP;
1636 
1637 	if (switch_en == !cpsw->data.dual_emac)
1638 		return 0;
1639 
1640 	if (!switch_en && cpsw->br_members) {
1641 		dev_err(cpsw->dev, "Remove ports from BR before disabling switch mode\n");
1642 		return -EINVAL;
1643 	}
1644 
1645 	rtnl_lock();
1646 
1647 	for (i = 0; i < cpsw->data.slaves; i++) {
1648 		struct cpsw_slave *slave = &cpsw->slaves[i];
1649 		struct net_device *sl_ndev = slave->ndev;
1650 
1651 		if (!sl_ndev || !netif_running(sl_ndev))
1652 			continue;
1653 
1654 		if_running = true;
1655 	}
1656 
1657 	if (!if_running) {
1658 		/* all ndevs are down */
1659 		cpsw->data.dual_emac = !switch_en;
1660 		for (i = 0; i < cpsw->data.slaves; i++) {
1661 			struct cpsw_slave *slave = &cpsw->slaves[i];
1662 			struct net_device *sl_ndev = slave->ndev;
1663 
1664 			if (!sl_ndev)
1665 				continue;
1666 
1667 			if (switch_en)
1668 				vlan = cpsw->data.default_vlan;
1669 			else
1670 				vlan = slave->data->dual_emac_res_vlan;
1671 			slave->port_vlan = vlan;
1672 		}
1673 		goto exit;
1674 	}
1675 
1676 	if (switch_en) {
1677 		dev_info(cpsw->dev, "Enable switch mode\n");
1678 
1679 		/* enable bypass - no forwarding; all traffic goes to Host */
1680 		cpsw_ale_control_set(cpsw->ale, 0, ALE_BYPASS, 1);
1681 
1682 		/* clean up ALE table */
1683 		cpsw_ale_control_set(cpsw->ale, 0, ALE_CLEAR, 1);
1684 		cpsw_ale_control_get(cpsw->ale, 0, ALE_AGEOUT);
1685 
1686 		cpsw_init_host_port_switch(cpsw);
1687 
1688 		for (i = 0; i < cpsw->data.slaves; i++) {
1689 			struct cpsw_slave *slave = &cpsw->slaves[i];
1690 			struct net_device *sl_ndev = slave->ndev;
1691 			struct cpsw_priv *priv;
1692 
1693 			if (!sl_ndev)
1694 				continue;
1695 
1696 			priv = netdev_priv(sl_ndev);
1697 			slave->port_vlan = vlan;
1698 			if (netif_running(sl_ndev))
1699 				cpsw_port_add_switch_def_ale_entries(priv,
1700 								     slave);
1701 		}
1702 
1703 		cpsw_ale_control_set(cpsw->ale, 0, ALE_BYPASS, 0);
1704 		cpsw->data.dual_emac = false;
1705 	} else {
1706 		dev_info(cpsw->dev, "Disable switch mode\n");
1707 
1708 		/* enable bypass - no forwarding; all traffic goes to Host */
1709 		cpsw_ale_control_set(cpsw->ale, 0, ALE_BYPASS, 1);
1710 
1711 		cpsw_ale_control_set(cpsw->ale, 0, ALE_CLEAR, 1);
1712 		cpsw_ale_control_get(cpsw->ale, 0, ALE_AGEOUT);
1713 
1714 		cpsw_init_host_port_dual_mac(cpsw);
1715 
1716 		for (i = 0; i < cpsw->data.slaves; i++) {
1717 			struct cpsw_slave *slave = &cpsw->slaves[i];
1718 			struct net_device *sl_ndev = slave->ndev;
1719 			struct cpsw_priv *priv;
1720 
1721 			if (!sl_ndev)
1722 				continue;
1723 
1724 			priv = netdev_priv(slave->ndev);
1725 			slave->port_vlan = slave->data->dual_emac_res_vlan;
1726 			cpsw_port_add_dual_emac_def_ale_entries(priv, slave);
1727 		}
1728 
1729 		cpsw_ale_control_set(cpsw->ale, 0, ALE_BYPASS, 0);
1730 		cpsw->data.dual_emac = true;
1731 	}
1732 exit:
1733 	rtnl_unlock();
1734 
1735 	return 0;
1736 }
1737 
1738 static int cpsw_dl_ale_ctrl_get(struct devlink *dl, u32 id,
1739 				struct devlink_param_gset_ctx *ctx)
1740 {
1741 	struct cpsw_devlink *dl_priv = devlink_priv(dl);
1742 	struct cpsw_common *cpsw = dl_priv->cpsw;
1743 
1744 	dev_dbg(cpsw->dev, "%s id:%u\n", __func__, id);
1745 
1746 	switch (id) {
1747 	case CPSW_DL_PARAM_ALE_BYPASS:
1748 		ctx->val.vbool = cpsw_ale_control_get(cpsw->ale, 0, ALE_BYPASS);
1749 		break;
1750 	default:
1751 		return -EOPNOTSUPP;
1752 	}
1753 
1754 	return 0;
1755 }
1756 
1757 static int cpsw_dl_ale_ctrl_set(struct devlink *dl, u32 id,
1758 				struct devlink_param_gset_ctx *ctx)
1759 {
1760 	struct cpsw_devlink *dl_priv = devlink_priv(dl);
1761 	struct cpsw_common *cpsw = dl_priv->cpsw;
1762 	int ret = -EOPNOTSUPP;
1763 
1764 	dev_dbg(cpsw->dev, "%s id:%u\n", __func__, id);
1765 
1766 	switch (id) {
1767 	case CPSW_DL_PARAM_ALE_BYPASS:
1768 		ret = cpsw_ale_control_set(cpsw->ale, 0, ALE_BYPASS,
1769 					   ctx->val.vbool);
1770 		if (!ret) {
1771 			cpsw->ale_bypass = ctx->val.vbool;
1772 			cpsw_port_offload_fwd_mark_update(cpsw);
1773 		}
1774 		break;
1775 	default:
1776 		return -EOPNOTSUPP;
1777 	}
1778 
1779 	return 0;
1780 }
1781 
1782 static const struct devlink_param cpsw_devlink_params[] = {
1783 	DEVLINK_PARAM_DRIVER(CPSW_DL_PARAM_SWITCH_MODE,
1784 			     "switch_mode", DEVLINK_PARAM_TYPE_BOOL,
1785 			     BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1786 			     cpsw_dl_switch_mode_get, cpsw_dl_switch_mode_set,
1787 			     NULL),
1788 	DEVLINK_PARAM_DRIVER(CPSW_DL_PARAM_ALE_BYPASS,
1789 			     "ale_bypass", DEVLINK_PARAM_TYPE_BOOL,
1790 			     BIT(DEVLINK_PARAM_CMODE_RUNTIME),
1791 			     cpsw_dl_ale_ctrl_get, cpsw_dl_ale_ctrl_set, NULL),
1792 };
1793 
1794 static int cpsw_register_devlink(struct cpsw_common *cpsw)
1795 {
1796 	struct device *dev = cpsw->dev;
1797 	struct cpsw_devlink *dl_priv;
1798 	int ret = 0;
1799 
1800 	cpsw->devlink = devlink_alloc(&cpsw_devlink_ops, sizeof(*dl_priv));
1801 	if (!cpsw->devlink)
1802 		return -ENOMEM;
1803 
1804 	dl_priv = devlink_priv(cpsw->devlink);
1805 	dl_priv->cpsw = cpsw;
1806 
1807 	ret = devlink_register(cpsw->devlink, dev);
1808 	if (ret) {
1809 		dev_err(dev, "DL reg fail ret:%d\n", ret);
1810 		goto dl_free;
1811 	}
1812 
1813 	ret = devlink_params_register(cpsw->devlink, cpsw_devlink_params,
1814 				      ARRAY_SIZE(cpsw_devlink_params));
1815 	if (ret) {
1816 		dev_err(dev, "DL params reg fail ret:%d\n", ret);
1817 		goto dl_unreg;
1818 	}
1819 
1820 	devlink_params_publish(cpsw->devlink);
1821 	return ret;
1822 
1823 dl_unreg:
1824 	devlink_unregister(cpsw->devlink);
1825 dl_free:
1826 	devlink_free(cpsw->devlink);
1827 	return ret;
1828 }
1829 
1830 static void cpsw_unregister_devlink(struct cpsw_common *cpsw)
1831 {
1832 	devlink_params_unpublish(cpsw->devlink);
1833 	devlink_params_unregister(cpsw->devlink, cpsw_devlink_params,
1834 				  ARRAY_SIZE(cpsw_devlink_params));
1835 	devlink_unregister(cpsw->devlink);
1836 	devlink_free(cpsw->devlink);
1837 }
1838 
1839 static const struct of_device_id cpsw_of_mtable[] = {
1840 	{ .compatible = "ti,cpsw-switch"},
1841 	{ .compatible = "ti,am335x-cpsw-switch"},
1842 	{ .compatible = "ti,am4372-cpsw-switch"},
1843 	{ .compatible = "ti,dra7-cpsw-switch"},
1844 	{ /* sentinel */ },
1845 };
1846 MODULE_DEVICE_TABLE(of, cpsw_of_mtable);
1847 
1848 static const struct soc_device_attribute cpsw_soc_devices[] = {
1849 	{ .family = "AM33xx", .revision = "ES1.0"},
1850 	{ /* sentinel */ }
1851 };
1852 
1853 static int cpsw_probe(struct platform_device *pdev)
1854 {
1855 	const struct soc_device_attribute *soc;
1856 	struct device *dev = &pdev->dev;
1857 	struct cpsw_common *cpsw;
1858 	struct resource *ss_res;
1859 	struct gpio_descs *mode;
1860 	void __iomem *ss_regs;
1861 	int ret = 0, ch;
1862 	struct clk *clk;
1863 	int irq;
1864 
1865 	cpsw = devm_kzalloc(dev, sizeof(struct cpsw_common), GFP_KERNEL);
1866 	if (!cpsw)
1867 		return -ENOMEM;
1868 
1869 	cpsw_slave_index = cpsw_slave_index_priv;
1870 
1871 	cpsw->dev = dev;
1872 
1873 	cpsw->slaves = devm_kcalloc(dev,
1874 				    CPSW_SLAVE_PORTS_NUM,
1875 				    sizeof(struct cpsw_slave),
1876 				    GFP_KERNEL);
1877 	if (!cpsw->slaves)
1878 		return -ENOMEM;
1879 
1880 	mode = devm_gpiod_get_array_optional(dev, "mode", GPIOD_OUT_LOW);
1881 	if (IS_ERR(mode)) {
1882 		ret = PTR_ERR(mode);
1883 		dev_err(dev, "gpio request failed, ret %d\n", ret);
1884 		return ret;
1885 	}
1886 
1887 	clk = devm_clk_get(dev, "fck");
1888 	if (IS_ERR(clk)) {
1889 		ret = PTR_ERR(clk);
1890 		dev_err(dev, "fck is not found %d\n", ret);
1891 		return ret;
1892 	}
1893 	cpsw->bus_freq_mhz = clk_get_rate(clk) / 1000000;
1894 
1895 	ss_res = platform_get_resource(pdev, IORESOURCE_MEM, 0);
1896 	ss_regs = devm_ioremap_resource(dev, ss_res);
1897 	if (IS_ERR(ss_regs)) {
1898 		ret = PTR_ERR(ss_regs);
1899 		return ret;
1900 	}
1901 	cpsw->regs = ss_regs;
1902 
1903 	irq = platform_get_irq_byname(pdev, "rx");
1904 	if (irq < 0)
1905 		return irq;
1906 	cpsw->irqs_table[0] = irq;
1907 
1908 	irq = platform_get_irq_byname(pdev, "tx");
1909 	if (irq < 0)
1910 		return irq;
1911 	cpsw->irqs_table[1] = irq;
1912 
1913 	irq = platform_get_irq_byname(pdev, "misc");
1914 	if (irq <= 0)
1915 		return irq;
1916 	cpsw->misc_irq = irq;
1917 
1918 	platform_set_drvdata(pdev, cpsw);
1919 	/* This may be required here for child devices. */
1920 	pm_runtime_enable(dev);
1921 
1922 	/* Need to enable clocks with runtime PM api to access module
1923 	 * registers
1924 	 */
1925 	ret = pm_runtime_get_sync(dev);
1926 	if (ret < 0) {
1927 		pm_runtime_put_noidle(dev);
1928 		pm_runtime_disable(dev);
1929 		return ret;
1930 	}
1931 
1932 	ret = cpsw_probe_dt(cpsw);
1933 	if (ret)
1934 		goto clean_dt_ret;
1935 
1936 	soc = soc_device_match(cpsw_soc_devices);
1937 	if (soc)
1938 		cpsw->quirk_irq = true;
1939 
1940 	cpsw->rx_packet_max = rx_packet_max;
1941 	cpsw->descs_pool_size = descs_pool_size;
1942 	eth_random_addr(cpsw->base_mac);
1943 
1944 	ret = cpsw_init_common(cpsw, ss_regs, ale_ageout,
1945 			       (u32 __force)ss_res->start + CPSW2_BD_OFFSET,
1946 			       descs_pool_size);
1947 	if (ret)
1948 		goto clean_dt_ret;
1949 
1950 	cpsw->wr_regs = cpsw->version == CPSW_VERSION_1 ?
1951 			ss_regs + CPSW1_WR_OFFSET :
1952 			ss_regs + CPSW2_WR_OFFSET;
1953 
1954 	ch = cpsw->quirk_irq ? 0 : 7;
1955 	cpsw->txv[0].ch = cpdma_chan_create(cpsw->dma, ch, cpsw_tx_handler, 0);
1956 	if (IS_ERR(cpsw->txv[0].ch)) {
1957 		dev_err(dev, "error initializing tx dma channel\n");
1958 		ret = PTR_ERR(cpsw->txv[0].ch);
1959 		goto clean_cpts;
1960 	}
1961 
1962 	cpsw->rxv[0].ch = cpdma_chan_create(cpsw->dma, 0, cpsw_rx_handler, 1);
1963 	if (IS_ERR(cpsw->rxv[0].ch)) {
1964 		dev_err(dev, "error initializing rx dma channel\n");
1965 		ret = PTR_ERR(cpsw->rxv[0].ch);
1966 		goto clean_cpts;
1967 	}
1968 	cpsw_split_res(cpsw);
1969 
1970 	/* setup netdevs */
1971 	ret = cpsw_create_ports(cpsw);
1972 	if (ret)
1973 		goto clean_unregister_netdev;
1974 
1975 	/* Grab RX and TX IRQs. Note that we also have RX_THRESHOLD and
1976 	 * MISC IRQs which are always kept disabled with this driver so
1977 	 * we will not request them.
1978 	 *
1979 	 * If anyone wants to implement support for those, make sure to
1980 	 * first request and append them to irqs_table array.
1981 	 */
1982 
1983 	ret = devm_request_irq(dev, cpsw->irqs_table[0], cpsw_rx_interrupt,
1984 			       0, dev_name(dev), cpsw);
1985 	if (ret < 0) {
1986 		dev_err(dev, "error attaching irq (%d)\n", ret);
1987 		goto clean_unregister_netdev;
1988 	}
1989 
1990 	ret = devm_request_irq(dev, cpsw->irqs_table[1], cpsw_tx_interrupt,
1991 			       0, dev_name(dev), cpsw);
1992 	if (ret < 0) {
1993 		dev_err(dev, "error attaching irq (%d)\n", ret);
1994 		goto clean_unregister_netdev;
1995 	}
1996 
1997 	if (!cpsw->cpts)
1998 		goto skip_cpts;
1999 
2000 	ret = devm_request_irq(dev, cpsw->misc_irq, cpsw_misc_interrupt,
2001 			       0, dev_name(&pdev->dev), cpsw);
2002 	if (ret < 0) {
2003 		dev_err(dev, "error attaching misc irq (%d)\n", ret);
2004 		goto clean_unregister_netdev;
2005 	}
2006 
2007 	/* Enable misc CPTS evnt_pend IRQ */
2008 	cpts_set_irqpoll(cpsw->cpts, false);
2009 	writel(0x10, &cpsw->wr_regs->misc_en);
2010 
2011 skip_cpts:
2012 	ret = cpsw_register_notifiers(cpsw);
2013 	if (ret)
2014 		goto clean_unregister_netdev;
2015 
2016 	ret = cpsw_register_devlink(cpsw);
2017 	if (ret)
2018 		goto clean_unregister_notifiers;
2019 
2020 	ret = cpsw_register_ports(cpsw);
2021 	if (ret)
2022 		goto clean_unregister_notifiers;
2023 
2024 	dev_notice(dev, "initialized (regs %pa, pool size %d) hw_ver:%08X %d.%d (%d)\n",
2025 		   &ss_res->start, descs_pool_size,
2026 		   cpsw->version, CPSW_MAJOR_VERSION(cpsw->version),
2027 		   CPSW_MINOR_VERSION(cpsw->version),
2028 		   CPSW_RTL_VERSION(cpsw->version));
2029 
2030 	pm_runtime_put(dev);
2031 
2032 	return 0;
2033 
2034 clean_unregister_notifiers:
2035 	cpsw_unregister_notifiers(cpsw);
2036 clean_unregister_netdev:
2037 	cpsw_unregister_ports(cpsw);
2038 clean_cpts:
2039 	cpts_release(cpsw->cpts);
2040 	cpdma_ctlr_destroy(cpsw->dma);
2041 clean_dt_ret:
2042 	cpsw_remove_dt(cpsw);
2043 	pm_runtime_put_sync(dev);
2044 	pm_runtime_disable(dev);
2045 	return ret;
2046 }
2047 
2048 static int cpsw_remove(struct platform_device *pdev)
2049 {
2050 	struct cpsw_common *cpsw = platform_get_drvdata(pdev);
2051 	int ret;
2052 
2053 	ret = pm_runtime_get_sync(&pdev->dev);
2054 	if (ret < 0) {
2055 		pm_runtime_put_noidle(&pdev->dev);
2056 		return ret;
2057 	}
2058 
2059 	cpsw_unregister_notifiers(cpsw);
2060 	cpsw_unregister_devlink(cpsw);
2061 	cpsw_unregister_ports(cpsw);
2062 
2063 	cpts_release(cpsw->cpts);
2064 	cpdma_ctlr_destroy(cpsw->dma);
2065 	cpsw_remove_dt(cpsw);
2066 	pm_runtime_put_sync(&pdev->dev);
2067 	pm_runtime_disable(&pdev->dev);
2068 	return 0;
2069 }
2070 
2071 static int __maybe_unused cpsw_suspend(struct device *dev)
2072 {
2073 	struct cpsw_common *cpsw = dev_get_drvdata(dev);
2074 	int i;
2075 
2076 	rtnl_lock();
2077 
2078 	for (i = 0; i < cpsw->data.slaves; i++) {
2079 		struct net_device *ndev = cpsw->slaves[i].ndev;
2080 
2081 		if (!(ndev && netif_running(ndev)))
2082 			continue;
2083 
2084 		cpsw_ndo_stop(ndev);
2085 	}
2086 
2087 	rtnl_unlock();
2088 
2089 	/* Select sleep pin state */
2090 	pinctrl_pm_select_sleep_state(dev);
2091 
2092 	return 0;
2093 }
2094 
2095 static int __maybe_unused cpsw_resume(struct device *dev)
2096 {
2097 	struct cpsw_common *cpsw = dev_get_drvdata(dev);
2098 	int i;
2099 
2100 	/* Select default pin state */
2101 	pinctrl_pm_select_default_state(dev);
2102 
2103 	/* shut up ASSERT_RTNL() warning in netif_set_real_num_tx/rx_queues */
2104 	rtnl_lock();
2105 
2106 	for (i = 0; i < cpsw->data.slaves; i++) {
2107 		struct net_device *ndev = cpsw->slaves[i].ndev;
2108 
2109 		if (!(ndev && netif_running(ndev)))
2110 			continue;
2111 
2112 		cpsw_ndo_open(ndev);
2113 	}
2114 
2115 	rtnl_unlock();
2116 
2117 	return 0;
2118 }
2119 
2120 static SIMPLE_DEV_PM_OPS(cpsw_pm_ops, cpsw_suspend, cpsw_resume);
2121 
2122 static struct platform_driver cpsw_driver = {
2123 	.driver = {
2124 		.name	 = "cpsw-switch",
2125 		.pm	 = &cpsw_pm_ops,
2126 		.of_match_table = cpsw_of_mtable,
2127 	},
2128 	.probe = cpsw_probe,
2129 	.remove = cpsw_remove,
2130 };
2131 
2132 module_platform_driver(cpsw_driver);
2133 
2134 MODULE_LICENSE("GPL");
2135 MODULE_DESCRIPTION("TI CPSW switchdev Ethernet driver");
2136