net: ethernet: ti: introduce cpsw switchdev based driver part 2 - switch (111cf1ab) · Commits · 戴 / test

drivers/net/ethernet/ti/Makefile

+1 −1

Original line number	Diff line number	Diff line
		@@ -16,7 +16,7 @@ obj-$(CONFIG_TI_CPTS_MOD) += cpts.o
		obj-$(CONFIG_TI_CPSW) += ti_cpsw.o
		ti_cpsw-y := cpsw.o davinci_cpdma.o cpsw_ale.o cpsw_priv.o cpsw_sl.o cpsw_ethtool.o
		obj-$(CONFIG_TI_CPSW_SWITCHDEV) += ti_cpsw_new.o
		ti_cpsw_new-y := cpsw_new.o davinci_cpdma.o cpsw_ale.o cpsw_sl.o cpsw_priv.o cpsw_ethtool.o
		ti_cpsw_new-y := cpsw_switchdev.o cpsw_new.o davinci_cpdma.o cpsw_ale.o cpsw_sl.o cpsw_priv.o cpsw_ethtool.o

		obj-$(CONFIG_TI_KEYSTONE_NETCP) += keystone_netcp.o
		keystone_netcp-y := netcp_core.o cpsw_ale.o

drivers/net/ethernet/ti/cpsw_new.c

+383 −8

Original line number	Diff line number	Diff line
		@@ -35,6 +35,7 @@
		#include "cpsw_ale.h"
		#include "cpsw_priv.h"
		#include "cpsw_sl.h"
		#include "cpsw_switchdev.h"
		#include "cpts.h"
		#include "davinci_cpdma.h"

		@@ -51,6 +52,7 @@ struct cpsw_devlink {

		enum cpsw_devlink_param_id {
		CPSW_DEVLINK_PARAM_ID_BASE = DEVLINK_PARAM_GENERIC_ID_MAX,
		CPSW_DL_PARAM_SWITCH_MODE,
		CPSW_DL_PARAM_ALE_BYPASS,
		};

		@@ -66,12 +68,20 @@ static int cpsw_slave_index_priv(struct cpsw_common *cpsw,
		return priv->emac_port - 1;
		}

		static bool cpsw_is_switch_en(struct cpsw_common *cpsw)
		{
		return !cpsw->data.dual_emac;
		}

		static void cpsw_set_promiscious(struct net_device *ndev, bool enable)
		{
		struct cpsw_common *cpsw = ndev_to_cpsw(ndev);
		bool enable_uni = false;
		int i;

		if (cpsw_is_switch_en(cpsw))
		return;

		/* Enabling promiscuous mode for one interface will be
		* common for both the interface as the interface shares
		* the same hardware resource.
		@@ -359,6 +369,7 @@ static void cpsw_rx_handler(void *token, int len, int status)
		goto requeue;
		}

		skb->offload_fwd_mark = priv->offload_fwd_mark;
		skb_reserve(skb, headroom);
		skb_put(skb, len);
		skb->dev = ndev;
		@@ -389,7 +400,7 @@ requeue:
		}
		}

		static inline int cpsw_add_vlan_ale_entry(struct cpsw_priv *priv,
		static int cpsw_add_vlan_ale_entry(struct cpsw_priv *priv,
		unsigned short vid)
		{
		struct cpsw_common *cpsw = priv->cpsw;
		@@ -435,6 +446,11 @@ static int cpsw_ndo_vlan_rx_add_vid(struct net_device *ndev,
		struct cpsw_common *cpsw = priv->cpsw;
		int ret, i;

		if (cpsw_is_switch_en(cpsw)) {
		dev_dbg(cpsw->dev, ".ndo_vlan_rx_add_vid called in switch mode\n");
		return 0;
		}

		if (vid == cpsw->data.default_vlan)
		return 0;

		@@ -489,9 +505,36 @@ static void cpsw_restore(struct cpsw_priv *priv)
		cpsw_cbs_resume(&cpsw->slaves[priv->emac_port - 1], priv);
		}

		static void cpsw_init_host_port_dual_mac(struct cpsw_priv *priv)
		static void cpsw_init_stp_ale_entry(struct cpsw_common *cpsw)
		{
		char stpa[] = {0x01, 0x80, 0xc2, 0x0, 0x0, 0x0};

		cpsw_ale_add_mcast(cpsw->ale, stpa,
		ALE_PORT_HOST, ALE_SUPER, 0,
		ALE_MCAST_BLOCK_LEARN_FWD);
		}

		static void cpsw_init_host_port_switch(struct cpsw_common *cpsw)
		{
		int vlan = cpsw->data.default_vlan;

		writel(CPSW_FIFO_NORMAL_MODE, &cpsw->host_port_regs->tx_in_ctl);

		writel(vlan, &cpsw->host_port_regs->port_vlan);

		cpsw_ale_add_vlan(cpsw->ale, vlan, ALE_ALL_PORTS,
		ALE_ALL_PORTS, ALE_ALL_PORTS,
		ALE_PORT_1 \| ALE_PORT_2);

		cpsw_init_stp_ale_entry(cpsw);

		cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM, ALE_P0_UNI_FLOOD, 1);
		dev_dbg(cpsw->dev, "Set P0_UNI_FLOOD\n");
		cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM, ALE_PORT_NOLEARN, 0);
		}

		static void cpsw_init_host_port_dual_mac(struct cpsw_common *cpsw)
		{
		struct cpsw_common *cpsw = priv->cpsw;
		int vlan = cpsw->data.default_vlan;

		writel(CPSW_FIFO_DUAL_MAC_MODE, &cpsw->host_port_regs->tx_in_ctl);
		@@ -536,7 +579,10 @@ static void cpsw_init_host_port(struct cpsw_priv *priv)
		/* Enable internal fifo flow control */
		writel(0x7, &cpsw->regs->flow_control);

		cpsw_init_host_port_dual_mac(priv);
		if (cpsw_is_switch_en(cpsw))
		cpsw_init_host_port_switch(cpsw);
		else
		cpsw_init_host_port_dual_mac(cpsw);

		cpsw_ale_control_set(cpsw->ale, HOST_PORT_NUM,
		ALE_PORT_STATE, ALE_PORT_STATE_FORWARD);
		@@ -568,6 +614,41 @@ static void cpsw_port_add_dual_emac_def_ale_entries(struct cpsw_priv *priv,
		ALE_PORT_NOLEARN, 1);
		}

		static void cpsw_port_add_switch_def_ale_entries(struct cpsw_priv *priv,
		struct cpsw_slave *slave)
		{
		u32 port_mask = 1 << priv->emac_port \| ALE_PORT_HOST;
		struct cpsw_common *cpsw = priv->cpsw;
		u32 reg;

		cpsw_ale_control_set(cpsw->ale, priv->emac_port,
		ALE_PORT_DROP_UNKNOWN_VLAN, 0);
		cpsw_ale_control_set(cpsw->ale, priv->emac_port,
		ALE_PORT_NOLEARN, 0);
		/* disabling SA_UPDATE required to make stp work, without this setting
		* Host MAC addresses will jump between ports.
		* As per TRM MAC address can be defined as unicast supervisory (super)
		* by setting both (ALE_BLOCKED \| ALE_SECURE) which should prevent
		* SA_UPDATE, but HW seems works incorrectly and setting ALE_SECURE
		* causes STP packets to be dropped due to ingress filter
		* if (source address found) and (secure) and
		* (receive port number != port_number))
		* then discard the packet
		*/
		cpsw_ale_control_set(cpsw->ale, priv->emac_port,
		ALE_PORT_NO_SA_UPDATE, 1);

		cpsw_ale_add_mcast(cpsw->ale, priv->ndev->broadcast,
		port_mask, ALE_VLAN, slave->port_vlan,
		ALE_MCAST_FWD_2);
		cpsw_ale_add_ucast(cpsw->ale, priv->mac_addr,
		HOST_PORT_NUM, ALE_VLAN, slave->port_vlan);

		reg = (cpsw->version == CPSW_VERSION_1) ? CPSW1_PORT_VLAN :
		CPSW2_PORT_VLAN;
		slave_write(slave, slave->port_vlan, reg);
		}

		static void cpsw_adjust_link(struct net_device *ndev)
		{
		struct cpsw_priv *priv = netdev_priv(ndev);
		@@ -680,6 +761,9 @@ static void cpsw_slave_open(struct cpsw_slave slave, struct cpsw_priv priv)

		slave->mac_control = 0; /* no link yet */

		if (cpsw_is_switch_en(cpsw))
		cpsw_port_add_switch_def_ale_entries(priv, slave);
		else
		cpsw_port_add_dual_emac_def_ale_entries(priv, slave);

		if (!slave->data->phy_node)
		@@ -748,7 +832,8 @@ static int cpsw_ndo_open(struct net_device *ndev)
		struct cpsw_common *cpsw = priv->cpsw;
		int ret;

		cpsw_info(priv, ifdown, "starting ndev\n");
		dev_info(priv->dev, "starting ndev. mode: %s\n",
		cpsw_is_switch_en(cpsw) ? "switch" : "dual_mac");
		ret = pm_runtime_get_sync(cpsw->dev);
		if (ret < 0) {
		pm_runtime_put_noidle(cpsw->dev);
		@@ -932,6 +1017,11 @@ static int cpsw_ndo_vlan_rx_kill_vid(struct net_device *ndev,
		int ret;
		int i;

		if (cpsw_is_switch_en(cpsw)) {
		dev_dbg(cpsw->dev, "ndo del vlan is called in switch mode\n");
		return 0;
		}

		if (vid == cpsw->data.default_vlan)
		return 0;

		@@ -1010,6 +1100,17 @@ static int cpsw_ndo_xdp_xmit(struct net_device *ndev, int n,
		return n - drops;
		}

		static int cpsw_get_port_parent_id(struct net_device *ndev,
		struct netdev_phys_item_id *ppid)
		{
		struct cpsw_common *cpsw = ndev_to_cpsw(ndev);

		ppid->id_len = sizeof(cpsw->base_mac);
		memcpy(&ppid->id, &cpsw->base_mac, ppid->id_len);

		return 0;
		}

		static const struct net_device_ops cpsw_netdev_ops = {
		.ndo_open = cpsw_ndo_open,
		.ndo_stop = cpsw_ndo_stop,
		@@ -1029,6 +1130,7 @@ static const struct net_device_ops cpsw_netdev_ops = {
		.ndo_get_phys_port_name = cpsw_ndo_get_phys_port_name,
		.ndo_bpf = cpsw_ndo_bpf,
		.ndo_xdp_xmit = cpsw_ndo_xdp_xmit,
		.ndo_get_port_parent_id = cpsw_get_port_parent_id,
		};

		static void cpsw_get_drvinfo(struct net_device *ndev,
		@@ -1358,7 +1460,265 @@ static int cpsw_register_ports(struct cpsw_common *cpsw)
		return ret;
		}

		static const struct devlink_ops cpsw_devlink_ops;
		bool cpsw_port_dev_check(const struct net_device *ndev)
		{
		if (ndev->netdev_ops == &cpsw_netdev_ops) {
		struct cpsw_common *cpsw = ndev_to_cpsw(ndev);

		return !cpsw->data.dual_emac;
		}

		return false;
		}

		static void cpsw_port_offload_fwd_mark_update(struct cpsw_common *cpsw)
		{
		int set_val = 0;
		int i;

		if (!cpsw->ale_bypass &&
		(cpsw->br_members == (ALE_PORT_1 \| ALE_PORT_2)))
		set_val = 1;

		dev_dbg(cpsw->dev, "set offload_fwd_mark %d\n", set_val);

		for (i = 0; i < cpsw->data.slaves; i++) {
		struct net_device *sl_ndev = cpsw->slaves[i].ndev;
		struct cpsw_priv *priv = netdev_priv(sl_ndev);

		priv->offload_fwd_mark = set_val;
		}
		}

		static int cpsw_netdevice_port_link(struct net_device *ndev,
		struct net_device *br_ndev)
		{
		struct cpsw_priv *priv = netdev_priv(ndev);
		struct cpsw_common *cpsw = priv->cpsw;

		if (!cpsw->br_members) {
		cpsw->hw_bridge_dev = br_ndev;
		} else {
		/* This is adding the port to a second bridge, this is
		* unsupported
		*/
		if (cpsw->hw_bridge_dev != br_ndev)
		return -EOPNOTSUPP;
		}

		cpsw->br_members \|= BIT(priv->emac_port);

		cpsw_port_offload_fwd_mark_update(cpsw);

		return NOTIFY_DONE;
		}

		static void cpsw_netdevice_port_unlink(struct net_device *ndev)
		{
		struct cpsw_priv *priv = netdev_priv(ndev);
		struct cpsw_common *cpsw = priv->cpsw;

		cpsw->br_members &= ~BIT(priv->emac_port);

		cpsw_port_offload_fwd_mark_update(cpsw);

		if (!cpsw->br_members)
		cpsw->hw_bridge_dev = NULL;
		}

		/* netdev notifier */
		static int cpsw_netdevice_event(struct notifier_block *unused,
		unsigned long event, void *ptr)
		{
		struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
		struct netdev_notifier_changeupper_info *info;
		int ret = NOTIFY_DONE;

		if (!cpsw_port_dev_check(ndev))
		return NOTIFY_DONE;

		switch (event) {
		case NETDEV_CHANGEUPPER:
		info = ptr;

		if (netif_is_bridge_master(info->upper_dev)) {
		if (info->linking)
		ret = cpsw_netdevice_port_link(ndev,
		info->upper_dev);
		else
		cpsw_netdevice_port_unlink(ndev);
		}
		break;
		default:
		return NOTIFY_DONE;
		}

		return notifier_from_errno(ret);
		}

		static struct notifier_block cpsw_netdevice_nb __read_mostly = {
		.notifier_call = cpsw_netdevice_event,
		};

		static int cpsw_register_notifiers(struct cpsw_common *cpsw)
		{
		int ret = 0;

		ret = register_netdevice_notifier(&cpsw_netdevice_nb);
		if (ret) {
		dev_err(cpsw->dev, "can't register netdevice notifier\n");
		return ret;
		}

		ret = cpsw_switchdev_register_notifiers(cpsw);
		if (ret)
		unregister_netdevice_notifier(&cpsw_netdevice_nb);

		return ret;
		}

		static void cpsw_unregister_notifiers(struct cpsw_common *cpsw)
		{
		cpsw_switchdev_unregister_notifiers(cpsw);
		unregister_netdevice_notifier(&cpsw_netdevice_nb);
		}

		static const struct devlink_ops cpsw_devlink_ops = {
		};

		static int cpsw_dl_switch_mode_get(struct devlink *dl, u32 id,
		struct devlink_param_gset_ctx *ctx)
		{
		struct cpsw_devlink *dl_priv = devlink_priv(dl);
		struct cpsw_common *cpsw = dl_priv->cpsw;

		dev_dbg(cpsw->dev, "%s id:%u\n", __func__, id);

		if (id != CPSW_DL_PARAM_SWITCH_MODE)
		return -EOPNOTSUPP;

		ctx->val.vbool = !cpsw->data.dual_emac;

		return 0;
		}

		static int cpsw_dl_switch_mode_set(struct devlink *dl, u32 id,
		struct devlink_param_gset_ctx *ctx)
		{
		struct cpsw_devlink *dl_priv = devlink_priv(dl);
		struct cpsw_common *cpsw = dl_priv->cpsw;
		int vlan = cpsw->data.default_vlan;
		bool switch_en = ctx->val.vbool;
		bool if_running = false;
		int i;

		dev_dbg(cpsw->dev, "%s id:%u\n", __func__, id);

		if (id != CPSW_DL_PARAM_SWITCH_MODE)
		return -EOPNOTSUPP;

		if (switch_en == !cpsw->data.dual_emac)
		return 0;

		if (!switch_en && cpsw->br_members) {
		dev_err(cpsw->dev, "Remove ports from BR before disabling switch mode\n");
		return -EINVAL;
		}

		rtnl_lock();

		for (i = 0; i < cpsw->data.slaves; i++) {
		struct cpsw_slave *slave = &cpsw->slaves[i];
		struct net_device *sl_ndev = slave->ndev;

		if (!sl_ndev \|\| !netif_running(sl_ndev))
		continue;

		if_running = true;
		}

		if (!if_running) {
		/* all ndevs are down */
		cpsw->data.dual_emac = !switch_en;
		for (i = 0; i < cpsw->data.slaves; i++) {
		struct cpsw_slave *slave = &cpsw->slaves[i];
		struct net_device *sl_ndev = slave->ndev;
		struct cpsw_priv *priv;

		if (!sl_ndev)
		continue;

		priv = netdev_priv(sl_ndev);
		if (switch_en)
		vlan = cpsw->data.default_vlan;
		else
		vlan = slave->data->dual_emac_res_vlan;
		slave->port_vlan = vlan;
		}
		goto exit;
		}

		if (switch_en) {
		dev_info(cpsw->dev, "Enable switch mode\n");

		/* enable bypass - no forwarding; all traffic goes to Host */
		cpsw_ale_control_set(cpsw->ale, 0, ALE_BYPASS, 1);

		/* clean up ALE table */
		cpsw_ale_control_set(cpsw->ale, 0, ALE_CLEAR, 1);
		cpsw_ale_control_get(cpsw->ale, 0, ALE_AGEOUT);

		cpsw_init_host_port_switch(cpsw);

		for (i = 0; i < cpsw->data.slaves; i++) {
		struct cpsw_slave *slave = &cpsw->slaves[i];
		struct net_device *sl_ndev = slave->ndev;
		struct cpsw_priv *priv;

		if (!sl_ndev)
		continue;

		priv = netdev_priv(sl_ndev);
		slave->port_vlan = vlan;
		if (netif_running(sl_ndev))
		cpsw_port_add_switch_def_ale_entries(priv,
		slave);
		}

		cpsw_ale_control_set(cpsw->ale, 0, ALE_BYPASS, 0);
		cpsw->data.dual_emac = false;
		} else {
		dev_info(cpsw->dev, "Disable switch mode\n");

		/* enable bypass - no forwarding; all traffic goes to Host */
		cpsw_ale_control_set(cpsw->ale, 0, ALE_BYPASS, 1);

		cpsw_ale_control_set(cpsw->ale, 0, ALE_CLEAR, 1);
		cpsw_ale_control_get(cpsw->ale, 0, ALE_AGEOUT);

		cpsw_init_host_port_dual_mac(cpsw);

		for (i = 0; i < cpsw->data.slaves; i++) {
		struct cpsw_slave *slave = &cpsw->slaves[i];
		struct net_device *sl_ndev = slave->ndev;
		struct cpsw_priv *priv;

		if (!sl_ndev)
		continue;

		priv = netdev_priv(slave->ndev);
		slave->port_vlan = slave->data->dual_emac_res_vlan;
		cpsw_port_add_dual_emac_def_ale_entries(priv, slave);
		}

		cpsw_ale_control_set(cpsw->ale, 0, ALE_BYPASS, 0);
		cpsw->data.dual_emac = true;
		}
		exit:
		rtnl_unlock();

		return 0;
		}

		static int cpsw_dl_ale_ctrl_get(struct devlink *dl, u32 id,
		struct devlink_param_gset_ctx *ctx)
		@@ -1392,6 +1752,10 @@ static int cpsw_dl_ale_ctrl_set(struct devlink *dl, u32 id,
		case CPSW_DL_PARAM_ALE_BYPASS:
		ret = cpsw_ale_control_set(cpsw->ale, 0, ALE_BYPASS,
		ctx->val.vbool);
		if (!ret) {
		cpsw->ale_bypass = ctx->val.vbool;
		cpsw_port_offload_fwd_mark_update(cpsw);
		}
		break;
		default:
		return -EOPNOTSUPP;
		@@ -1401,6 +1765,11 @@ static int cpsw_dl_ale_ctrl_set(struct devlink *dl, u32 id,
		}

		static const struct devlink_param cpsw_devlink_params[] = {
		DEVLINK_PARAM_DRIVER(CPSW_DL_PARAM_SWITCH_MODE,
		"switch_mode", DEVLINK_PARAM_TYPE_BOOL,
		BIT(DEVLINK_PARAM_CMODE_RUNTIME),
		cpsw_dl_switch_mode_get, cpsw_dl_switch_mode_set,
		NULL),
		DEVLINK_PARAM_DRIVER(CPSW_DL_PARAM_ALE_BYPASS,
		"ale_bypass", DEVLINK_PARAM_TYPE_BOOL,
		BIT(DEVLINK_PARAM_CMODE_RUNTIME),
		@@ -1550,6 +1919,7 @@ static int cpsw_probe(struct platform_device *pdev)

		cpsw->rx_packet_max = rx_packet_max;
		cpsw->descs_pool_size = descs_pool_size;
		eth_random_addr(cpsw->base_mac);

		ret = cpsw_init_common(cpsw, ss_regs, ale_ageout,
		(u32 __force)ss_res->start + CPSW2_BD_OFFSET,
		@@ -1604,6 +1974,10 @@ static int cpsw_probe(struct platform_device *pdev)
		goto clean_unregister_netdev;
		}

		ret = cpsw_register_notifiers(cpsw);
		if (ret)
		goto clean_unregister_netdev;

		ret = cpsw_register_devlink(cpsw);
		if (ret)
		goto clean_unregister_notifiers;
		@@ -1647,6 +2021,7 @@ static int cpsw_remove(struct platform_device *pdev)
		return ret;
		}

		cpsw_unregister_notifiers(cpsw);
		cpsw_unregister_devlink(cpsw);
		cpsw_unregister_ports(cpsw);

drivers/net/ethernet/ti/cpsw_priv.h

+5 −0

Original line number	Diff line number	Diff line
		@@ -356,6 +356,10 @@ struct cpsw_common {
		int speed;
		int usage_count;
		struct page_pool *page_pool[CPSW_MAX_QUEUES];
		u8 br_members;
		struct net_device *hw_bridge_dev;
		bool ale_bypass;
		u8 base_mac[ETH_ALEN];
		};

		struct cpsw_priv {
		@@ -376,6 +380,7 @@ struct cpsw_priv {

		u32 emac_port;
		struct cpsw_common *cpsw;
		int offload_fwd_mark;
		};

		#define ndev_to_cpsw(ndev) (((struct cpsw_priv *)netdev_priv(ndev))->cpsw)

drivers/net/ethernet/ti/cpsw_switchdev.c

0 → 100644

+589 −0

File added.

Preview size limit exceeded, changes collapsed.

drivers/net/ethernet/ti/cpsw_switchdev.h

0 → 100644

+15 −0

Original line number	Diff line number	Diff line
		/* SPDX-License-Identifier: GPL-2.0 */
		/*
		* Texas Instruments Ethernet Switch Driver
		*/

		#ifndef DRIVERS_NET_ETHERNET_TI_CPSW_SWITCHDEV_H_
		#define DRIVERS_NET_ETHERNET_TI_CPSW_SWITCHDEV_H_

		#include <net/switchdev.h>

		bool cpsw_port_dev_check(const struct net_device *dev);
		int cpsw_switchdev_register_notifiers(struct cpsw_common *cpsw);
		void cpsw_switchdev_unregister_notifiers(struct cpsw_common *cpsw);

		#endif /* DRIVERS_NET_ETHERNET_TI_CPSW_SWITCHDEV_H_ */

Admin message