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