1f48298d3SIoana Ciornei // SPDX-License-Identifier: GPL-2.0 2f48298d3SIoana Ciornei /* 3f48298d3SIoana Ciornei * DPAA2 Ethernet Switch driver 4f48298d3SIoana Ciornei * 5f48298d3SIoana Ciornei * Copyright 2014-2016 Freescale Semiconductor Inc. 6f48298d3SIoana Ciornei * Copyright 2017-2021 NXP 7f48298d3SIoana Ciornei * 8f48298d3SIoana Ciornei */ 9f48298d3SIoana Ciornei 10f48298d3SIoana Ciornei #include <linux/module.h> 11f48298d3SIoana Ciornei 12f48298d3SIoana Ciornei #include <linux/interrupt.h> 13f48298d3SIoana Ciornei #include <linux/msi.h> 14f48298d3SIoana Ciornei #include <linux/kthread.h> 15f48298d3SIoana Ciornei #include <linux/workqueue.h> 16f48298d3SIoana Ciornei #include <linux/iommu.h> 171110318dSIoana Ciornei #include <net/pkt_cls.h> 18f48298d3SIoana Ciornei 19f48298d3SIoana Ciornei #include <linux/fsl/mc.h> 20f48298d3SIoana Ciornei 21f48298d3SIoana Ciornei #include "dpaa2-switch.h" 22f48298d3SIoana Ciornei 23f48298d3SIoana Ciornei /* Minimal supported DPSW version */ 24f48298d3SIoana Ciornei #define DPSW_MIN_VER_MAJOR 8 25f48298d3SIoana Ciornei #define DPSW_MIN_VER_MINOR 9 26f48298d3SIoana Ciornei 27f48298d3SIoana Ciornei #define DEFAULT_VLAN_ID 1 28f48298d3SIoana Ciornei 29f48298d3SIoana Ciornei static u16 dpaa2_switch_port_get_fdb_id(struct ethsw_port_priv *port_priv) 30f48298d3SIoana Ciornei { 31f48298d3SIoana Ciornei return port_priv->fdb->fdb_id; 32f48298d3SIoana Ciornei } 33f48298d3SIoana Ciornei 34f48298d3SIoana Ciornei static struct dpaa2_switch_fdb *dpaa2_switch_fdb_get_unused(struct ethsw_core *ethsw) 35f48298d3SIoana Ciornei { 36f48298d3SIoana Ciornei int i; 37f48298d3SIoana Ciornei 38f48298d3SIoana Ciornei for (i = 0; i < ethsw->sw_attr.num_ifs; i++) 39f48298d3SIoana Ciornei if (!ethsw->fdbs[i].in_use) 40f48298d3SIoana Ciornei return ðsw->fdbs[i]; 41f48298d3SIoana Ciornei return NULL; 42f48298d3SIoana Ciornei } 43f48298d3SIoana Ciornei 441b0f14b6SIoana Ciornei static struct dpaa2_switch_acl_tbl * 451b0f14b6SIoana Ciornei dpaa2_switch_acl_tbl_get_unused(struct ethsw_core *ethsw) 461b0f14b6SIoana Ciornei { 471b0f14b6SIoana Ciornei int i; 481b0f14b6SIoana Ciornei 491b0f14b6SIoana Ciornei for (i = 0; i < ethsw->sw_attr.num_ifs; i++) 501b0f14b6SIoana Ciornei if (!ethsw->acls[i].in_use) 511b0f14b6SIoana Ciornei return ðsw->acls[i]; 521b0f14b6SIoana Ciornei return NULL; 531b0f14b6SIoana Ciornei } 541b0f14b6SIoana Ciornei 55f48298d3SIoana Ciornei static u16 dpaa2_switch_port_set_fdb(struct ethsw_port_priv *port_priv, 56f48298d3SIoana Ciornei struct net_device *bridge_dev) 57f48298d3SIoana Ciornei { 58f48298d3SIoana Ciornei struct ethsw_port_priv *other_port_priv = NULL; 59f48298d3SIoana Ciornei struct dpaa2_switch_fdb *fdb; 60f48298d3SIoana Ciornei struct net_device *other_dev; 61f48298d3SIoana Ciornei struct list_head *iter; 62f48298d3SIoana Ciornei 63f48298d3SIoana Ciornei /* If we leave a bridge (bridge_dev is NULL), find an unused 64f48298d3SIoana Ciornei * FDB and use that. 65f48298d3SIoana Ciornei */ 66f48298d3SIoana Ciornei if (!bridge_dev) { 67f48298d3SIoana Ciornei fdb = dpaa2_switch_fdb_get_unused(port_priv->ethsw_data); 68f48298d3SIoana Ciornei 69f48298d3SIoana Ciornei /* If there is no unused FDB, we must be the last port that 70f48298d3SIoana Ciornei * leaves the last bridge, all the others are standalone. We 71f48298d3SIoana Ciornei * can just keep the FDB that we already have. 72f48298d3SIoana Ciornei */ 73f48298d3SIoana Ciornei 74f48298d3SIoana Ciornei if (!fdb) { 75f48298d3SIoana Ciornei port_priv->fdb->bridge_dev = NULL; 76f48298d3SIoana Ciornei return 0; 77f48298d3SIoana Ciornei } 78f48298d3SIoana Ciornei 79f48298d3SIoana Ciornei port_priv->fdb = fdb; 80f48298d3SIoana Ciornei port_priv->fdb->in_use = true; 81f48298d3SIoana Ciornei port_priv->fdb->bridge_dev = NULL; 82f48298d3SIoana Ciornei return 0; 83f48298d3SIoana Ciornei } 84f48298d3SIoana Ciornei 85f48298d3SIoana Ciornei /* The below call to netdev_for_each_lower_dev() demands the RTNL lock 86f48298d3SIoana Ciornei * being held. Assert on it so that it's easier to catch new code 87f48298d3SIoana Ciornei * paths that reach this point without the RTNL lock. 88f48298d3SIoana Ciornei */ 89f48298d3SIoana Ciornei ASSERT_RTNL(); 90f48298d3SIoana Ciornei 91f48298d3SIoana Ciornei /* If part of a bridge, use the FDB of the first dpaa2 switch interface 92f48298d3SIoana Ciornei * to be present in that bridge 93f48298d3SIoana Ciornei */ 94f48298d3SIoana Ciornei netdev_for_each_lower_dev(bridge_dev, other_dev, iter) { 95f48298d3SIoana Ciornei if (!dpaa2_switch_port_dev_check(other_dev)) 96f48298d3SIoana Ciornei continue; 97f48298d3SIoana Ciornei 98f48298d3SIoana Ciornei if (other_dev == port_priv->netdev) 99f48298d3SIoana Ciornei continue; 100f48298d3SIoana Ciornei 101f48298d3SIoana Ciornei other_port_priv = netdev_priv(other_dev); 102f48298d3SIoana Ciornei break; 103f48298d3SIoana Ciornei } 104f48298d3SIoana Ciornei 105f48298d3SIoana Ciornei /* The current port is about to change its FDB to the one used by the 106f48298d3SIoana Ciornei * first port that joined the bridge. 107f48298d3SIoana Ciornei */ 108f48298d3SIoana Ciornei if (other_port_priv) { 109f48298d3SIoana Ciornei /* The previous FDB is about to become unused, since the 110f48298d3SIoana Ciornei * interface is no longer standalone. 111f48298d3SIoana Ciornei */ 112f48298d3SIoana Ciornei port_priv->fdb->in_use = false; 113f48298d3SIoana Ciornei port_priv->fdb->bridge_dev = NULL; 114f48298d3SIoana Ciornei 115f48298d3SIoana Ciornei /* Get a reference to the new FDB */ 116f48298d3SIoana Ciornei port_priv->fdb = other_port_priv->fdb; 117f48298d3SIoana Ciornei } 118f48298d3SIoana Ciornei 119f48298d3SIoana Ciornei /* Keep track of the new upper bridge device */ 120f48298d3SIoana Ciornei port_priv->fdb->bridge_dev = bridge_dev; 121f48298d3SIoana Ciornei 122f48298d3SIoana Ciornei return 0; 123f48298d3SIoana Ciornei } 124f48298d3SIoana Ciornei 125f054e3e2SIoana Ciornei static void dpaa2_switch_fdb_get_flood_cfg(struct ethsw_core *ethsw, u16 fdb_id, 126f054e3e2SIoana Ciornei enum dpsw_flood_type type, 127f054e3e2SIoana Ciornei struct dpsw_egress_flood_cfg *cfg) 128c7e856c8SIoana Ciornei { 129c7e856c8SIoana Ciornei int i = 0, j; 130f054e3e2SIoana Ciornei 131f054e3e2SIoana Ciornei memset(cfg, 0, sizeof(*cfg)); 132c7e856c8SIoana Ciornei 133c7e856c8SIoana Ciornei /* Add all the DPAA2 switch ports found in the same bridging domain to 134c7e856c8SIoana Ciornei * the egress flooding domain 135c7e856c8SIoana Ciornei */ 136f054e3e2SIoana Ciornei for (j = 0; j < ethsw->sw_attr.num_ifs; j++) { 137f054e3e2SIoana Ciornei if (!ethsw->ports[j]) 138f054e3e2SIoana Ciornei continue; 139f054e3e2SIoana Ciornei if (ethsw->ports[j]->fdb->fdb_id != fdb_id) 140f054e3e2SIoana Ciornei continue; 141f054e3e2SIoana Ciornei 142b54eb093SIoana Ciornei if (type == DPSW_BROADCAST && ethsw->ports[j]->bcast_flood) 143b54eb093SIoana Ciornei cfg->if_id[i++] = ethsw->ports[j]->idx; 1446253d5e3SIoana Ciornei else if (type == DPSW_FLOODING && ethsw->ports[j]->ucast_flood) 145f054e3e2SIoana Ciornei cfg->if_id[i++] = ethsw->ports[j]->idx; 146f054e3e2SIoana Ciornei } 147c7e856c8SIoana Ciornei 148c7e856c8SIoana Ciornei /* Add the CTRL interface to the egress flooding domain */ 149f054e3e2SIoana Ciornei cfg->if_id[i++] = ethsw->sw_attr.num_ifs; 150c7e856c8SIoana Ciornei 151f054e3e2SIoana Ciornei cfg->fdb_id = fdb_id; 152f054e3e2SIoana Ciornei cfg->flood_type = type; 153f054e3e2SIoana Ciornei cfg->num_ifs = i; 154f054e3e2SIoana Ciornei } 155f054e3e2SIoana Ciornei 156f054e3e2SIoana Ciornei static int dpaa2_switch_fdb_set_egress_flood(struct ethsw_core *ethsw, u16 fdb_id) 157f054e3e2SIoana Ciornei { 158f054e3e2SIoana Ciornei struct dpsw_egress_flood_cfg flood_cfg; 159f054e3e2SIoana Ciornei int err; 160c7e856c8SIoana Ciornei 161c7e856c8SIoana Ciornei /* Setup broadcast flooding domain */ 162f054e3e2SIoana Ciornei dpaa2_switch_fdb_get_flood_cfg(ethsw, fdb_id, DPSW_BROADCAST, &flood_cfg); 163c7e856c8SIoana Ciornei err = dpsw_set_egress_flood(ethsw->mc_io, 0, ethsw->dpsw_handle, 164c7e856c8SIoana Ciornei &flood_cfg); 165c7e856c8SIoana Ciornei if (err) { 166c7e856c8SIoana Ciornei dev_err(ethsw->dev, "dpsw_set_egress_flood() = %d\n", err); 167c7e856c8SIoana Ciornei return err; 168c7e856c8SIoana Ciornei } 169c7e856c8SIoana Ciornei 170c7e856c8SIoana Ciornei /* Setup unknown flooding domain */ 171f054e3e2SIoana Ciornei dpaa2_switch_fdb_get_flood_cfg(ethsw, fdb_id, DPSW_FLOODING, &flood_cfg); 172c7e856c8SIoana Ciornei err = dpsw_set_egress_flood(ethsw->mc_io, 0, ethsw->dpsw_handle, 173c7e856c8SIoana Ciornei &flood_cfg); 174c7e856c8SIoana Ciornei if (err) { 175c7e856c8SIoana Ciornei dev_err(ethsw->dev, "dpsw_set_egress_flood() = %d\n", err); 176c7e856c8SIoana Ciornei return err; 177c7e856c8SIoana Ciornei } 178c7e856c8SIoana Ciornei 179c7e856c8SIoana Ciornei return 0; 180c7e856c8SIoana Ciornei } 181c7e856c8SIoana Ciornei 182f48298d3SIoana Ciornei static void *dpaa2_iova_to_virt(struct iommu_domain *domain, 183f48298d3SIoana Ciornei dma_addr_t iova_addr) 184f48298d3SIoana Ciornei { 185f48298d3SIoana Ciornei phys_addr_t phys_addr; 186f48298d3SIoana Ciornei 187f48298d3SIoana Ciornei phys_addr = domain ? iommu_iova_to_phys(domain, iova_addr) : iova_addr; 188f48298d3SIoana Ciornei 189f48298d3SIoana Ciornei return phys_to_virt(phys_addr); 190f48298d3SIoana Ciornei } 191f48298d3SIoana Ciornei 192f48298d3SIoana Ciornei static int dpaa2_switch_add_vlan(struct ethsw_port_priv *port_priv, u16 vid) 193f48298d3SIoana Ciornei { 194f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 195f48298d3SIoana Ciornei struct dpsw_vlan_cfg vcfg = {0}; 196f48298d3SIoana Ciornei int err; 197f48298d3SIoana Ciornei 198f48298d3SIoana Ciornei vcfg.fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 199f48298d3SIoana Ciornei err = dpsw_vlan_add(ethsw->mc_io, 0, 200f48298d3SIoana Ciornei ethsw->dpsw_handle, vid, &vcfg); 201f48298d3SIoana Ciornei if (err) { 202f48298d3SIoana Ciornei dev_err(ethsw->dev, "dpsw_vlan_add err %d\n", err); 203f48298d3SIoana Ciornei return err; 204f48298d3SIoana Ciornei } 205f48298d3SIoana Ciornei ethsw->vlans[vid] = ETHSW_VLAN_MEMBER; 206f48298d3SIoana Ciornei 207f48298d3SIoana Ciornei return 0; 208f48298d3SIoana Ciornei } 209f48298d3SIoana Ciornei 210f48298d3SIoana Ciornei static bool dpaa2_switch_port_is_up(struct ethsw_port_priv *port_priv) 211f48298d3SIoana Ciornei { 212f48298d3SIoana Ciornei struct net_device *netdev = port_priv->netdev; 213f48298d3SIoana Ciornei struct dpsw_link_state state; 214f48298d3SIoana Ciornei int err; 215f48298d3SIoana Ciornei 216f48298d3SIoana Ciornei err = dpsw_if_get_link_state(port_priv->ethsw_data->mc_io, 0, 217f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 218f48298d3SIoana Ciornei port_priv->idx, &state); 219f48298d3SIoana Ciornei if (err) { 220f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_if_get_link_state() err %d\n", err); 221f48298d3SIoana Ciornei return true; 222f48298d3SIoana Ciornei } 223f48298d3SIoana Ciornei 224f48298d3SIoana Ciornei WARN_ONCE(state.up > 1, "Garbage read into link_state"); 225f48298d3SIoana Ciornei 226f48298d3SIoana Ciornei return state.up ? true : false; 227f48298d3SIoana Ciornei } 228f48298d3SIoana Ciornei 229f48298d3SIoana Ciornei static int dpaa2_switch_port_set_pvid(struct ethsw_port_priv *port_priv, u16 pvid) 230f48298d3SIoana Ciornei { 231f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 232f48298d3SIoana Ciornei struct net_device *netdev = port_priv->netdev; 233f48298d3SIoana Ciornei struct dpsw_tci_cfg tci_cfg = { 0 }; 234f48298d3SIoana Ciornei bool up; 235f48298d3SIoana Ciornei int err, ret; 236f48298d3SIoana Ciornei 237f48298d3SIoana Ciornei err = dpsw_if_get_tci(ethsw->mc_io, 0, ethsw->dpsw_handle, 238f48298d3SIoana Ciornei port_priv->idx, &tci_cfg); 239f48298d3SIoana Ciornei if (err) { 240f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_if_get_tci err %d\n", err); 241f48298d3SIoana Ciornei return err; 242f48298d3SIoana Ciornei } 243f48298d3SIoana Ciornei 244f48298d3SIoana Ciornei tci_cfg.vlan_id = pvid; 245f48298d3SIoana Ciornei 246f48298d3SIoana Ciornei /* Interface needs to be down to change PVID */ 247f48298d3SIoana Ciornei up = dpaa2_switch_port_is_up(port_priv); 248f48298d3SIoana Ciornei if (up) { 249f48298d3SIoana Ciornei err = dpsw_if_disable(ethsw->mc_io, 0, 250f48298d3SIoana Ciornei ethsw->dpsw_handle, 251f48298d3SIoana Ciornei port_priv->idx); 252f48298d3SIoana Ciornei if (err) { 253f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_if_disable err %d\n", err); 254f48298d3SIoana Ciornei return err; 255f48298d3SIoana Ciornei } 256f48298d3SIoana Ciornei } 257f48298d3SIoana Ciornei 258f48298d3SIoana Ciornei err = dpsw_if_set_tci(ethsw->mc_io, 0, ethsw->dpsw_handle, 259f48298d3SIoana Ciornei port_priv->idx, &tci_cfg); 260f48298d3SIoana Ciornei if (err) { 261f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_if_set_tci err %d\n", err); 262f48298d3SIoana Ciornei goto set_tci_error; 263f48298d3SIoana Ciornei } 264f48298d3SIoana Ciornei 265f48298d3SIoana Ciornei /* Delete previous PVID info and mark the new one */ 266f48298d3SIoana Ciornei port_priv->vlans[port_priv->pvid] &= ~ETHSW_VLAN_PVID; 267f48298d3SIoana Ciornei port_priv->vlans[pvid] |= ETHSW_VLAN_PVID; 268f48298d3SIoana Ciornei port_priv->pvid = pvid; 269f48298d3SIoana Ciornei 270f48298d3SIoana Ciornei set_tci_error: 271f48298d3SIoana Ciornei if (up) { 272f48298d3SIoana Ciornei ret = dpsw_if_enable(ethsw->mc_io, 0, 273f48298d3SIoana Ciornei ethsw->dpsw_handle, 274f48298d3SIoana Ciornei port_priv->idx); 275f48298d3SIoana Ciornei if (ret) { 276f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_if_enable err %d\n", ret); 277f48298d3SIoana Ciornei return ret; 278f48298d3SIoana Ciornei } 279f48298d3SIoana Ciornei } 280f48298d3SIoana Ciornei 281f48298d3SIoana Ciornei return err; 282f48298d3SIoana Ciornei } 283f48298d3SIoana Ciornei 284f48298d3SIoana Ciornei static int dpaa2_switch_port_add_vlan(struct ethsw_port_priv *port_priv, 285f48298d3SIoana Ciornei u16 vid, u16 flags) 286f48298d3SIoana Ciornei { 287f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 288f48298d3SIoana Ciornei struct net_device *netdev = port_priv->netdev; 289f48298d3SIoana Ciornei struct dpsw_vlan_if_cfg vcfg = {0}; 290f48298d3SIoana Ciornei int err; 291f48298d3SIoana Ciornei 292f48298d3SIoana Ciornei if (port_priv->vlans[vid]) { 293f48298d3SIoana Ciornei netdev_warn(netdev, "VLAN %d already configured\n", vid); 294f48298d3SIoana Ciornei return -EEXIST; 295f48298d3SIoana Ciornei } 296f48298d3SIoana Ciornei 297f48298d3SIoana Ciornei /* If hit, this VLAN rule will lead the packet into the FDB table 298f48298d3SIoana Ciornei * specified in the vlan configuration below 299f48298d3SIoana Ciornei */ 300f48298d3SIoana Ciornei vcfg.num_ifs = 1; 301f48298d3SIoana Ciornei vcfg.if_id[0] = port_priv->idx; 302f48298d3SIoana Ciornei vcfg.fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 303f48298d3SIoana Ciornei vcfg.options |= DPSW_VLAN_ADD_IF_OPT_FDB_ID; 304f48298d3SIoana Ciornei err = dpsw_vlan_add_if(ethsw->mc_io, 0, ethsw->dpsw_handle, vid, &vcfg); 305f48298d3SIoana Ciornei if (err) { 306f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_vlan_add_if err %d\n", err); 307f48298d3SIoana Ciornei return err; 308f48298d3SIoana Ciornei } 309f48298d3SIoana Ciornei 310f48298d3SIoana Ciornei port_priv->vlans[vid] = ETHSW_VLAN_MEMBER; 311f48298d3SIoana Ciornei 312f48298d3SIoana Ciornei if (flags & BRIDGE_VLAN_INFO_UNTAGGED) { 313f48298d3SIoana Ciornei err = dpsw_vlan_add_if_untagged(ethsw->mc_io, 0, 314f48298d3SIoana Ciornei ethsw->dpsw_handle, 315f48298d3SIoana Ciornei vid, &vcfg); 316f48298d3SIoana Ciornei if (err) { 317f48298d3SIoana Ciornei netdev_err(netdev, 318f48298d3SIoana Ciornei "dpsw_vlan_add_if_untagged err %d\n", err); 319f48298d3SIoana Ciornei return err; 320f48298d3SIoana Ciornei } 321f48298d3SIoana Ciornei port_priv->vlans[vid] |= ETHSW_VLAN_UNTAGGED; 322f48298d3SIoana Ciornei } 323f48298d3SIoana Ciornei 324f48298d3SIoana Ciornei if (flags & BRIDGE_VLAN_INFO_PVID) { 325f48298d3SIoana Ciornei err = dpaa2_switch_port_set_pvid(port_priv, vid); 326f48298d3SIoana Ciornei if (err) 327f48298d3SIoana Ciornei return err; 328f48298d3SIoana Ciornei } 329f48298d3SIoana Ciornei 330f48298d3SIoana Ciornei return 0; 331f48298d3SIoana Ciornei } 332f48298d3SIoana Ciornei 3336aa6791dSIoana Ciornei static enum dpsw_stp_state br_stp_state_to_dpsw(u8 state) 3346aa6791dSIoana Ciornei { 3356aa6791dSIoana Ciornei switch (state) { 3366aa6791dSIoana Ciornei case BR_STATE_DISABLED: 3376aa6791dSIoana Ciornei return DPSW_STP_STATE_DISABLED; 3386aa6791dSIoana Ciornei case BR_STATE_LISTENING: 3396aa6791dSIoana Ciornei return DPSW_STP_STATE_LISTENING; 3406aa6791dSIoana Ciornei case BR_STATE_LEARNING: 3416aa6791dSIoana Ciornei return DPSW_STP_STATE_LEARNING; 3426aa6791dSIoana Ciornei case BR_STATE_FORWARDING: 3436aa6791dSIoana Ciornei return DPSW_STP_STATE_FORWARDING; 3446aa6791dSIoana Ciornei case BR_STATE_BLOCKING: 3456aa6791dSIoana Ciornei return DPSW_STP_STATE_BLOCKING; 3466aa6791dSIoana Ciornei default: 3476aa6791dSIoana Ciornei return DPSW_STP_STATE_DISABLED; 3486aa6791dSIoana Ciornei } 3496aa6791dSIoana Ciornei } 3506aa6791dSIoana Ciornei 351f48298d3SIoana Ciornei static int dpaa2_switch_port_set_stp_state(struct ethsw_port_priv *port_priv, u8 state) 352f48298d3SIoana Ciornei { 3536aa6791dSIoana Ciornei struct dpsw_stp_cfg stp_cfg = {0}; 354f48298d3SIoana Ciornei int err; 355f48298d3SIoana Ciornei u16 vid; 356f48298d3SIoana Ciornei 357f48298d3SIoana Ciornei if (!netif_running(port_priv->netdev) || state == port_priv->stp_state) 358f48298d3SIoana Ciornei return 0; /* Nothing to do */ 359f48298d3SIoana Ciornei 3606aa6791dSIoana Ciornei stp_cfg.state = br_stp_state_to_dpsw(state); 361f48298d3SIoana Ciornei for (vid = 0; vid <= VLAN_VID_MASK; vid++) { 362f48298d3SIoana Ciornei if (port_priv->vlans[vid] & ETHSW_VLAN_MEMBER) { 363f48298d3SIoana Ciornei stp_cfg.vlan_id = vid; 364f48298d3SIoana Ciornei err = dpsw_if_set_stp(port_priv->ethsw_data->mc_io, 0, 365f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 366f48298d3SIoana Ciornei port_priv->idx, &stp_cfg); 367f48298d3SIoana Ciornei if (err) { 368f48298d3SIoana Ciornei netdev_err(port_priv->netdev, 369f48298d3SIoana Ciornei "dpsw_if_set_stp err %d\n", err); 370f48298d3SIoana Ciornei return err; 371f48298d3SIoana Ciornei } 372f48298d3SIoana Ciornei } 373f48298d3SIoana Ciornei } 374f48298d3SIoana Ciornei 375f48298d3SIoana Ciornei port_priv->stp_state = state; 376f48298d3SIoana Ciornei 377f48298d3SIoana Ciornei return 0; 378f48298d3SIoana Ciornei } 379f48298d3SIoana Ciornei 380f48298d3SIoana Ciornei static int dpaa2_switch_dellink(struct ethsw_core *ethsw, u16 vid) 381f48298d3SIoana Ciornei { 382f48298d3SIoana Ciornei struct ethsw_port_priv *ppriv_local = NULL; 383f48298d3SIoana Ciornei int i, err; 384f48298d3SIoana Ciornei 385f48298d3SIoana Ciornei if (!ethsw->vlans[vid]) 386f48298d3SIoana Ciornei return -ENOENT; 387f48298d3SIoana Ciornei 388f48298d3SIoana Ciornei err = dpsw_vlan_remove(ethsw->mc_io, 0, ethsw->dpsw_handle, vid); 389f48298d3SIoana Ciornei if (err) { 390f48298d3SIoana Ciornei dev_err(ethsw->dev, "dpsw_vlan_remove err %d\n", err); 391f48298d3SIoana Ciornei return err; 392f48298d3SIoana Ciornei } 393f48298d3SIoana Ciornei ethsw->vlans[vid] = 0; 394f48298d3SIoana Ciornei 395f48298d3SIoana Ciornei for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 396f48298d3SIoana Ciornei ppriv_local = ethsw->ports[i]; 397f48298d3SIoana Ciornei ppriv_local->vlans[vid] = 0; 398f48298d3SIoana Ciornei } 399f48298d3SIoana Ciornei 400f48298d3SIoana Ciornei return 0; 401f48298d3SIoana Ciornei } 402f48298d3SIoana Ciornei 403f48298d3SIoana Ciornei static int dpaa2_switch_port_fdb_add_uc(struct ethsw_port_priv *port_priv, 404f48298d3SIoana Ciornei const unsigned char *addr) 405f48298d3SIoana Ciornei { 406f48298d3SIoana Ciornei struct dpsw_fdb_unicast_cfg entry = {0}; 407f48298d3SIoana Ciornei u16 fdb_id; 408f48298d3SIoana Ciornei int err; 409f48298d3SIoana Ciornei 410f48298d3SIoana Ciornei entry.if_egress = port_priv->idx; 411f48298d3SIoana Ciornei entry.type = DPSW_FDB_ENTRY_STATIC; 412f48298d3SIoana Ciornei ether_addr_copy(entry.mac_addr, addr); 413f48298d3SIoana Ciornei 414f48298d3SIoana Ciornei fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 415f48298d3SIoana Ciornei err = dpsw_fdb_add_unicast(port_priv->ethsw_data->mc_io, 0, 416f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 417f48298d3SIoana Ciornei fdb_id, &entry); 418f48298d3SIoana Ciornei if (err) 419f48298d3SIoana Ciornei netdev_err(port_priv->netdev, 420f48298d3SIoana Ciornei "dpsw_fdb_add_unicast err %d\n", err); 421f48298d3SIoana Ciornei return err; 422f48298d3SIoana Ciornei } 423f48298d3SIoana Ciornei 424f48298d3SIoana Ciornei static int dpaa2_switch_port_fdb_del_uc(struct ethsw_port_priv *port_priv, 425f48298d3SIoana Ciornei const unsigned char *addr) 426f48298d3SIoana Ciornei { 427f48298d3SIoana Ciornei struct dpsw_fdb_unicast_cfg entry = {0}; 428f48298d3SIoana Ciornei u16 fdb_id; 429f48298d3SIoana Ciornei int err; 430f48298d3SIoana Ciornei 431f48298d3SIoana Ciornei entry.if_egress = port_priv->idx; 432f48298d3SIoana Ciornei entry.type = DPSW_FDB_ENTRY_STATIC; 433f48298d3SIoana Ciornei ether_addr_copy(entry.mac_addr, addr); 434f48298d3SIoana Ciornei 435f48298d3SIoana Ciornei fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 436f48298d3SIoana Ciornei err = dpsw_fdb_remove_unicast(port_priv->ethsw_data->mc_io, 0, 437f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 438f48298d3SIoana Ciornei fdb_id, &entry); 439f48298d3SIoana Ciornei /* Silently discard error for calling multiple times the del command */ 440f48298d3SIoana Ciornei if (err && err != -ENXIO) 441f48298d3SIoana Ciornei netdev_err(port_priv->netdev, 442f48298d3SIoana Ciornei "dpsw_fdb_remove_unicast err %d\n", err); 443f48298d3SIoana Ciornei return err; 444f48298d3SIoana Ciornei } 445f48298d3SIoana Ciornei 446f48298d3SIoana Ciornei static int dpaa2_switch_port_fdb_add_mc(struct ethsw_port_priv *port_priv, 447f48298d3SIoana Ciornei const unsigned char *addr) 448f48298d3SIoana Ciornei { 449f48298d3SIoana Ciornei struct dpsw_fdb_multicast_cfg entry = {0}; 450f48298d3SIoana Ciornei u16 fdb_id; 451f48298d3SIoana Ciornei int err; 452f48298d3SIoana Ciornei 453f48298d3SIoana Ciornei ether_addr_copy(entry.mac_addr, addr); 454f48298d3SIoana Ciornei entry.type = DPSW_FDB_ENTRY_STATIC; 455f48298d3SIoana Ciornei entry.num_ifs = 1; 456f48298d3SIoana Ciornei entry.if_id[0] = port_priv->idx; 457f48298d3SIoana Ciornei 458f48298d3SIoana Ciornei fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 459f48298d3SIoana Ciornei err = dpsw_fdb_add_multicast(port_priv->ethsw_data->mc_io, 0, 460f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 461f48298d3SIoana Ciornei fdb_id, &entry); 462f48298d3SIoana Ciornei /* Silently discard error for calling multiple times the add command */ 463f48298d3SIoana Ciornei if (err && err != -ENXIO) 464f48298d3SIoana Ciornei netdev_err(port_priv->netdev, "dpsw_fdb_add_multicast err %d\n", 465f48298d3SIoana Ciornei err); 466f48298d3SIoana Ciornei return err; 467f48298d3SIoana Ciornei } 468f48298d3SIoana Ciornei 469f48298d3SIoana Ciornei static int dpaa2_switch_port_fdb_del_mc(struct ethsw_port_priv *port_priv, 470f48298d3SIoana Ciornei const unsigned char *addr) 471f48298d3SIoana Ciornei { 472f48298d3SIoana Ciornei struct dpsw_fdb_multicast_cfg entry = {0}; 473f48298d3SIoana Ciornei u16 fdb_id; 474f48298d3SIoana Ciornei int err; 475f48298d3SIoana Ciornei 476f48298d3SIoana Ciornei ether_addr_copy(entry.mac_addr, addr); 477f48298d3SIoana Ciornei entry.type = DPSW_FDB_ENTRY_STATIC; 478f48298d3SIoana Ciornei entry.num_ifs = 1; 479f48298d3SIoana Ciornei entry.if_id[0] = port_priv->idx; 480f48298d3SIoana Ciornei 481f48298d3SIoana Ciornei fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 482f48298d3SIoana Ciornei err = dpsw_fdb_remove_multicast(port_priv->ethsw_data->mc_io, 0, 483f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 484f48298d3SIoana Ciornei fdb_id, &entry); 485f48298d3SIoana Ciornei /* Silently discard error for calling multiple times the del command */ 486f48298d3SIoana Ciornei if (err && err != -ENAVAIL) 487f48298d3SIoana Ciornei netdev_err(port_priv->netdev, 488f48298d3SIoana Ciornei "dpsw_fdb_remove_multicast err %d\n", err); 489f48298d3SIoana Ciornei return err; 490f48298d3SIoana Ciornei } 491f48298d3SIoana Ciornei 492f48298d3SIoana Ciornei static void dpaa2_switch_port_get_stats(struct net_device *netdev, 493f48298d3SIoana Ciornei struct rtnl_link_stats64 *stats) 494f48298d3SIoana Ciornei { 495f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 496f48298d3SIoana Ciornei u64 tmp; 497f48298d3SIoana Ciornei int err; 498f48298d3SIoana Ciornei 499f48298d3SIoana Ciornei err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 500f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 501f48298d3SIoana Ciornei port_priv->idx, 502f48298d3SIoana Ciornei DPSW_CNT_ING_FRAME, &stats->rx_packets); 503f48298d3SIoana Ciornei if (err) 504f48298d3SIoana Ciornei goto error; 505f48298d3SIoana Ciornei 506f48298d3SIoana Ciornei err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 507f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 508f48298d3SIoana Ciornei port_priv->idx, 509f48298d3SIoana Ciornei DPSW_CNT_EGR_FRAME, &stats->tx_packets); 510f48298d3SIoana Ciornei if (err) 511f48298d3SIoana Ciornei goto error; 512f48298d3SIoana Ciornei 513f48298d3SIoana Ciornei err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 514f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 515f48298d3SIoana Ciornei port_priv->idx, 516f48298d3SIoana Ciornei DPSW_CNT_ING_BYTE, &stats->rx_bytes); 517f48298d3SIoana Ciornei if (err) 518f48298d3SIoana Ciornei goto error; 519f48298d3SIoana Ciornei 520f48298d3SIoana Ciornei err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 521f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 522f48298d3SIoana Ciornei port_priv->idx, 523f48298d3SIoana Ciornei DPSW_CNT_EGR_BYTE, &stats->tx_bytes); 524f48298d3SIoana Ciornei if (err) 525f48298d3SIoana Ciornei goto error; 526f48298d3SIoana Ciornei 527f48298d3SIoana Ciornei err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 528f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 529f48298d3SIoana Ciornei port_priv->idx, 530f48298d3SIoana Ciornei DPSW_CNT_ING_FRAME_DISCARD, 531f48298d3SIoana Ciornei &stats->rx_dropped); 532f48298d3SIoana Ciornei if (err) 533f48298d3SIoana Ciornei goto error; 534f48298d3SIoana Ciornei 535f48298d3SIoana Ciornei err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 536f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 537f48298d3SIoana Ciornei port_priv->idx, 538f48298d3SIoana Ciornei DPSW_CNT_ING_FLTR_FRAME, 539f48298d3SIoana Ciornei &tmp); 540f48298d3SIoana Ciornei if (err) 541f48298d3SIoana Ciornei goto error; 542f48298d3SIoana Ciornei stats->rx_dropped += tmp; 543f48298d3SIoana Ciornei 544f48298d3SIoana Ciornei err = dpsw_if_get_counter(port_priv->ethsw_data->mc_io, 0, 545f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 546f48298d3SIoana Ciornei port_priv->idx, 547f48298d3SIoana Ciornei DPSW_CNT_EGR_FRAME_DISCARD, 548f48298d3SIoana Ciornei &stats->tx_dropped); 549f48298d3SIoana Ciornei if (err) 550f48298d3SIoana Ciornei goto error; 551f48298d3SIoana Ciornei 552f48298d3SIoana Ciornei return; 553f48298d3SIoana Ciornei 554f48298d3SIoana Ciornei error: 555f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_if_get_counter err %d\n", err); 556f48298d3SIoana Ciornei } 557f48298d3SIoana Ciornei 558f48298d3SIoana Ciornei static bool dpaa2_switch_port_has_offload_stats(const struct net_device *netdev, 559f48298d3SIoana Ciornei int attr_id) 560f48298d3SIoana Ciornei { 561f48298d3SIoana Ciornei return (attr_id == IFLA_OFFLOAD_XSTATS_CPU_HIT); 562f48298d3SIoana Ciornei } 563f48298d3SIoana Ciornei 564f48298d3SIoana Ciornei static int dpaa2_switch_port_get_offload_stats(int attr_id, 565f48298d3SIoana Ciornei const struct net_device *netdev, 566f48298d3SIoana Ciornei void *sp) 567f48298d3SIoana Ciornei { 568f48298d3SIoana Ciornei switch (attr_id) { 569f48298d3SIoana Ciornei case IFLA_OFFLOAD_XSTATS_CPU_HIT: 570f48298d3SIoana Ciornei dpaa2_switch_port_get_stats((struct net_device *)netdev, sp); 571f48298d3SIoana Ciornei return 0; 572f48298d3SIoana Ciornei } 573f48298d3SIoana Ciornei 574f48298d3SIoana Ciornei return -EINVAL; 575f48298d3SIoana Ciornei } 576f48298d3SIoana Ciornei 577f48298d3SIoana Ciornei static int dpaa2_switch_port_change_mtu(struct net_device *netdev, int mtu) 578f48298d3SIoana Ciornei { 579f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 580f48298d3SIoana Ciornei int err; 581f48298d3SIoana Ciornei 582f48298d3SIoana Ciornei err = dpsw_if_set_max_frame_length(port_priv->ethsw_data->mc_io, 583f48298d3SIoana Ciornei 0, 584f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 585f48298d3SIoana Ciornei port_priv->idx, 586f48298d3SIoana Ciornei (u16)ETHSW_L2_MAX_FRM(mtu)); 587f48298d3SIoana Ciornei if (err) { 588f48298d3SIoana Ciornei netdev_err(netdev, 589f48298d3SIoana Ciornei "dpsw_if_set_max_frame_length() err %d\n", err); 590f48298d3SIoana Ciornei return err; 591f48298d3SIoana Ciornei } 592f48298d3SIoana Ciornei 593f48298d3SIoana Ciornei netdev->mtu = mtu; 594f48298d3SIoana Ciornei return 0; 595f48298d3SIoana Ciornei } 596f48298d3SIoana Ciornei 597f48298d3SIoana Ciornei static int dpaa2_switch_port_carrier_state_sync(struct net_device *netdev) 598f48298d3SIoana Ciornei { 599f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 600f48298d3SIoana Ciornei struct dpsw_link_state state; 601f48298d3SIoana Ciornei int err; 602f48298d3SIoana Ciornei 603f48298d3SIoana Ciornei /* Interrupts are received even though no one issued an 'ifconfig up' 604f48298d3SIoana Ciornei * on the switch interface. Ignore these link state update interrupts 605f48298d3SIoana Ciornei */ 606f48298d3SIoana Ciornei if (!netif_running(netdev)) 607f48298d3SIoana Ciornei return 0; 608f48298d3SIoana Ciornei 609f48298d3SIoana Ciornei err = dpsw_if_get_link_state(port_priv->ethsw_data->mc_io, 0, 610f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 611f48298d3SIoana Ciornei port_priv->idx, &state); 612f48298d3SIoana Ciornei if (err) { 613f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_if_get_link_state() err %d\n", err); 614f48298d3SIoana Ciornei return err; 615f48298d3SIoana Ciornei } 616f48298d3SIoana Ciornei 617f48298d3SIoana Ciornei WARN_ONCE(state.up > 1, "Garbage read into link_state"); 618f48298d3SIoana Ciornei 619f48298d3SIoana Ciornei if (state.up != port_priv->link_state) { 620f48298d3SIoana Ciornei if (state.up) { 621f48298d3SIoana Ciornei netif_carrier_on(netdev); 622f48298d3SIoana Ciornei netif_tx_start_all_queues(netdev); 623f48298d3SIoana Ciornei } else { 624f48298d3SIoana Ciornei netif_carrier_off(netdev); 625f48298d3SIoana Ciornei netif_tx_stop_all_queues(netdev); 626f48298d3SIoana Ciornei } 627f48298d3SIoana Ciornei port_priv->link_state = state.up; 628f48298d3SIoana Ciornei } 629f48298d3SIoana Ciornei 630f48298d3SIoana Ciornei return 0; 631f48298d3SIoana Ciornei } 632f48298d3SIoana Ciornei 633f48298d3SIoana Ciornei /* Manage all NAPI instances for the control interface. 634f48298d3SIoana Ciornei * 635f48298d3SIoana Ciornei * We only have one RX queue and one Tx Conf queue for all 636f48298d3SIoana Ciornei * switch ports. Therefore, we only need to enable the NAPI instance once, the 637f48298d3SIoana Ciornei * first time one of the switch ports runs .dev_open(). 638f48298d3SIoana Ciornei */ 639f48298d3SIoana Ciornei 640f48298d3SIoana Ciornei static void dpaa2_switch_enable_ctrl_if_napi(struct ethsw_core *ethsw) 641f48298d3SIoana Ciornei { 642f48298d3SIoana Ciornei int i; 643f48298d3SIoana Ciornei 644f48298d3SIoana Ciornei /* Access to the ethsw->napi_users relies on the RTNL lock */ 645f48298d3SIoana Ciornei ASSERT_RTNL(); 646f48298d3SIoana Ciornei 647f48298d3SIoana Ciornei /* a new interface is using the NAPI instance */ 648f48298d3SIoana Ciornei ethsw->napi_users++; 649f48298d3SIoana Ciornei 650f48298d3SIoana Ciornei /* if there is already a user of the instance, return */ 651f48298d3SIoana Ciornei if (ethsw->napi_users > 1) 652f48298d3SIoana Ciornei return; 653f48298d3SIoana Ciornei 654f48298d3SIoana Ciornei for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) 655f48298d3SIoana Ciornei napi_enable(ðsw->fq[i].napi); 656f48298d3SIoana Ciornei } 657f48298d3SIoana Ciornei 658f48298d3SIoana Ciornei static void dpaa2_switch_disable_ctrl_if_napi(struct ethsw_core *ethsw) 659f48298d3SIoana Ciornei { 660f48298d3SIoana Ciornei int i; 661f48298d3SIoana Ciornei 662f48298d3SIoana Ciornei /* Access to the ethsw->napi_users relies on the RTNL lock */ 663f48298d3SIoana Ciornei ASSERT_RTNL(); 664f48298d3SIoana Ciornei 665f48298d3SIoana Ciornei /* If we are not the last interface using the NAPI, return */ 666f48298d3SIoana Ciornei ethsw->napi_users--; 667f48298d3SIoana Ciornei if (ethsw->napi_users) 668f48298d3SIoana Ciornei return; 669f48298d3SIoana Ciornei 670f48298d3SIoana Ciornei for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) 671f48298d3SIoana Ciornei napi_disable(ðsw->fq[i].napi); 672f48298d3SIoana Ciornei } 673f48298d3SIoana Ciornei 674f48298d3SIoana Ciornei static int dpaa2_switch_port_open(struct net_device *netdev) 675f48298d3SIoana Ciornei { 676f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 677f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 678f48298d3SIoana Ciornei int err; 679f48298d3SIoana Ciornei 680f48298d3SIoana Ciornei /* Explicitly set carrier off, otherwise 681f48298d3SIoana Ciornei * netif_carrier_ok() will return true and cause 'ip link show' 682f48298d3SIoana Ciornei * to report the LOWER_UP flag, even though the link 683f48298d3SIoana Ciornei * notification wasn't even received. 684f48298d3SIoana Ciornei */ 685f48298d3SIoana Ciornei netif_carrier_off(netdev); 686f48298d3SIoana Ciornei 687f48298d3SIoana Ciornei err = dpsw_if_enable(port_priv->ethsw_data->mc_io, 0, 688f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 689f48298d3SIoana Ciornei port_priv->idx); 690f48298d3SIoana Ciornei if (err) { 691f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_if_enable err %d\n", err); 692f48298d3SIoana Ciornei return err; 693f48298d3SIoana Ciornei } 694f48298d3SIoana Ciornei 695f48298d3SIoana Ciornei /* sync carrier state */ 696f48298d3SIoana Ciornei err = dpaa2_switch_port_carrier_state_sync(netdev); 697f48298d3SIoana Ciornei if (err) { 698f48298d3SIoana Ciornei netdev_err(netdev, 699f48298d3SIoana Ciornei "dpaa2_switch_port_carrier_state_sync err %d\n", err); 700f48298d3SIoana Ciornei goto err_carrier_sync; 701f48298d3SIoana Ciornei } 702f48298d3SIoana Ciornei 703f48298d3SIoana Ciornei dpaa2_switch_enable_ctrl_if_napi(ethsw); 704f48298d3SIoana Ciornei 705f48298d3SIoana Ciornei return 0; 706f48298d3SIoana Ciornei 707f48298d3SIoana Ciornei err_carrier_sync: 708f48298d3SIoana Ciornei dpsw_if_disable(port_priv->ethsw_data->mc_io, 0, 709f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 710f48298d3SIoana Ciornei port_priv->idx); 711f48298d3SIoana Ciornei return err; 712f48298d3SIoana Ciornei } 713f48298d3SIoana Ciornei 714f48298d3SIoana Ciornei static int dpaa2_switch_port_stop(struct net_device *netdev) 715f48298d3SIoana Ciornei { 716f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 717f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 718f48298d3SIoana Ciornei int err; 719f48298d3SIoana Ciornei 720f48298d3SIoana Ciornei err = dpsw_if_disable(port_priv->ethsw_data->mc_io, 0, 721f48298d3SIoana Ciornei port_priv->ethsw_data->dpsw_handle, 722f48298d3SIoana Ciornei port_priv->idx); 723f48298d3SIoana Ciornei if (err) { 724f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_if_disable err %d\n", err); 725f48298d3SIoana Ciornei return err; 726f48298d3SIoana Ciornei } 727f48298d3SIoana Ciornei 728f48298d3SIoana Ciornei dpaa2_switch_disable_ctrl_if_napi(ethsw); 729f48298d3SIoana Ciornei 730f48298d3SIoana Ciornei return 0; 731f48298d3SIoana Ciornei } 732f48298d3SIoana Ciornei 733f48298d3SIoana Ciornei static int dpaa2_switch_port_parent_id(struct net_device *dev, 734f48298d3SIoana Ciornei struct netdev_phys_item_id *ppid) 735f48298d3SIoana Ciornei { 736f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(dev); 737f48298d3SIoana Ciornei 738f48298d3SIoana Ciornei ppid->id_len = 1; 739f48298d3SIoana Ciornei ppid->id[0] = port_priv->ethsw_data->dev_id; 740f48298d3SIoana Ciornei 741f48298d3SIoana Ciornei return 0; 742f48298d3SIoana Ciornei } 743f48298d3SIoana Ciornei 744f48298d3SIoana Ciornei static int dpaa2_switch_port_get_phys_name(struct net_device *netdev, char *name, 745f48298d3SIoana Ciornei size_t len) 746f48298d3SIoana Ciornei { 747f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 748f48298d3SIoana Ciornei int err; 749f48298d3SIoana Ciornei 750f48298d3SIoana Ciornei err = snprintf(name, len, "p%d", port_priv->idx); 751f48298d3SIoana Ciornei if (err >= len) 752f48298d3SIoana Ciornei return -EINVAL; 753f48298d3SIoana Ciornei 754f48298d3SIoana Ciornei return 0; 755f48298d3SIoana Ciornei } 756f48298d3SIoana Ciornei 757f48298d3SIoana Ciornei struct ethsw_dump_ctx { 758f48298d3SIoana Ciornei struct net_device *dev; 759f48298d3SIoana Ciornei struct sk_buff *skb; 760f48298d3SIoana Ciornei struct netlink_callback *cb; 761f48298d3SIoana Ciornei int idx; 762f48298d3SIoana Ciornei }; 763f48298d3SIoana Ciornei 764f48298d3SIoana Ciornei static int dpaa2_switch_fdb_dump_nl(struct fdb_dump_entry *entry, 765f48298d3SIoana Ciornei struct ethsw_dump_ctx *dump) 766f48298d3SIoana Ciornei { 767f48298d3SIoana Ciornei int is_dynamic = entry->type & DPSW_FDB_ENTRY_DINAMIC; 768f48298d3SIoana Ciornei u32 portid = NETLINK_CB(dump->cb->skb).portid; 769f48298d3SIoana Ciornei u32 seq = dump->cb->nlh->nlmsg_seq; 770f48298d3SIoana Ciornei struct nlmsghdr *nlh; 771f48298d3SIoana Ciornei struct ndmsg *ndm; 772f48298d3SIoana Ciornei 773f48298d3SIoana Ciornei if (dump->idx < dump->cb->args[2]) 774f48298d3SIoana Ciornei goto skip; 775f48298d3SIoana Ciornei 776f48298d3SIoana Ciornei nlh = nlmsg_put(dump->skb, portid, seq, RTM_NEWNEIGH, 777f48298d3SIoana Ciornei sizeof(*ndm), NLM_F_MULTI); 778f48298d3SIoana Ciornei if (!nlh) 779f48298d3SIoana Ciornei return -EMSGSIZE; 780f48298d3SIoana Ciornei 781f48298d3SIoana Ciornei ndm = nlmsg_data(nlh); 782f48298d3SIoana Ciornei ndm->ndm_family = AF_BRIDGE; 783f48298d3SIoana Ciornei ndm->ndm_pad1 = 0; 784f48298d3SIoana Ciornei ndm->ndm_pad2 = 0; 785f48298d3SIoana Ciornei ndm->ndm_flags = NTF_SELF; 786f48298d3SIoana Ciornei ndm->ndm_type = 0; 787f48298d3SIoana Ciornei ndm->ndm_ifindex = dump->dev->ifindex; 788f48298d3SIoana Ciornei ndm->ndm_state = is_dynamic ? NUD_REACHABLE : NUD_NOARP; 789f48298d3SIoana Ciornei 790f48298d3SIoana Ciornei if (nla_put(dump->skb, NDA_LLADDR, ETH_ALEN, entry->mac_addr)) 791f48298d3SIoana Ciornei goto nla_put_failure; 792f48298d3SIoana Ciornei 793f48298d3SIoana Ciornei nlmsg_end(dump->skb, nlh); 794f48298d3SIoana Ciornei 795f48298d3SIoana Ciornei skip: 796f48298d3SIoana Ciornei dump->idx++; 797f48298d3SIoana Ciornei return 0; 798f48298d3SIoana Ciornei 799f48298d3SIoana Ciornei nla_put_failure: 800f48298d3SIoana Ciornei nlmsg_cancel(dump->skb, nlh); 801f48298d3SIoana Ciornei return -EMSGSIZE; 802f48298d3SIoana Ciornei } 803f48298d3SIoana Ciornei 804f48298d3SIoana Ciornei static int dpaa2_switch_port_fdb_valid_entry(struct fdb_dump_entry *entry, 805f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv) 806f48298d3SIoana Ciornei { 807f48298d3SIoana Ciornei int idx = port_priv->idx; 808f48298d3SIoana Ciornei int valid; 809f48298d3SIoana Ciornei 810f48298d3SIoana Ciornei if (entry->type & DPSW_FDB_ENTRY_TYPE_UNICAST) 811f48298d3SIoana Ciornei valid = entry->if_info == port_priv->idx; 812f48298d3SIoana Ciornei else 813f48298d3SIoana Ciornei valid = entry->if_mask[idx / 8] & BIT(idx % 8); 814f48298d3SIoana Ciornei 815f48298d3SIoana Ciornei return valid; 816f48298d3SIoana Ciornei } 817f48298d3SIoana Ciornei 818f48298d3SIoana Ciornei static int dpaa2_switch_fdb_iterate(struct ethsw_port_priv *port_priv, 819f48298d3SIoana Ciornei dpaa2_switch_fdb_cb_t cb, void *data) 820f48298d3SIoana Ciornei { 821f48298d3SIoana Ciornei struct net_device *net_dev = port_priv->netdev; 822f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 823f48298d3SIoana Ciornei struct device *dev = net_dev->dev.parent; 824f48298d3SIoana Ciornei struct fdb_dump_entry *fdb_entries; 825f48298d3SIoana Ciornei struct fdb_dump_entry fdb_entry; 826f48298d3SIoana Ciornei dma_addr_t fdb_dump_iova; 827f48298d3SIoana Ciornei u16 num_fdb_entries; 828f48298d3SIoana Ciornei u32 fdb_dump_size; 829f48298d3SIoana Ciornei int err = 0, i; 830f48298d3SIoana Ciornei u8 *dma_mem; 831f48298d3SIoana Ciornei u16 fdb_id; 832f48298d3SIoana Ciornei 833f48298d3SIoana Ciornei fdb_dump_size = ethsw->sw_attr.max_fdb_entries * sizeof(fdb_entry); 834f48298d3SIoana Ciornei dma_mem = kzalloc(fdb_dump_size, GFP_KERNEL); 835f48298d3SIoana Ciornei if (!dma_mem) 836f48298d3SIoana Ciornei return -ENOMEM; 837f48298d3SIoana Ciornei 838f48298d3SIoana Ciornei fdb_dump_iova = dma_map_single(dev, dma_mem, fdb_dump_size, 839f48298d3SIoana Ciornei DMA_FROM_DEVICE); 840f48298d3SIoana Ciornei if (dma_mapping_error(dev, fdb_dump_iova)) { 841f48298d3SIoana Ciornei netdev_err(net_dev, "dma_map_single() failed\n"); 842f48298d3SIoana Ciornei err = -ENOMEM; 843f48298d3SIoana Ciornei goto err_map; 844f48298d3SIoana Ciornei } 845f48298d3SIoana Ciornei 846f48298d3SIoana Ciornei fdb_id = dpaa2_switch_port_get_fdb_id(port_priv); 847f48298d3SIoana Ciornei err = dpsw_fdb_dump(ethsw->mc_io, 0, ethsw->dpsw_handle, fdb_id, 848f48298d3SIoana Ciornei fdb_dump_iova, fdb_dump_size, &num_fdb_entries); 849f48298d3SIoana Ciornei if (err) { 850f48298d3SIoana Ciornei netdev_err(net_dev, "dpsw_fdb_dump() = %d\n", err); 851f48298d3SIoana Ciornei goto err_dump; 852f48298d3SIoana Ciornei } 853f48298d3SIoana Ciornei 854f48298d3SIoana Ciornei dma_unmap_single(dev, fdb_dump_iova, fdb_dump_size, DMA_FROM_DEVICE); 855f48298d3SIoana Ciornei 856f48298d3SIoana Ciornei fdb_entries = (struct fdb_dump_entry *)dma_mem; 857f48298d3SIoana Ciornei for (i = 0; i < num_fdb_entries; i++) { 858f48298d3SIoana Ciornei fdb_entry = fdb_entries[i]; 859f48298d3SIoana Ciornei 860f48298d3SIoana Ciornei err = cb(port_priv, &fdb_entry, data); 861f48298d3SIoana Ciornei if (err) 862f48298d3SIoana Ciornei goto end; 863f48298d3SIoana Ciornei } 864f48298d3SIoana Ciornei 865f48298d3SIoana Ciornei end: 866f48298d3SIoana Ciornei kfree(dma_mem); 867f48298d3SIoana Ciornei 868f48298d3SIoana Ciornei return 0; 869f48298d3SIoana Ciornei 870f48298d3SIoana Ciornei err_dump: 871f48298d3SIoana Ciornei dma_unmap_single(dev, fdb_dump_iova, fdb_dump_size, DMA_TO_DEVICE); 872f48298d3SIoana Ciornei err_map: 873f48298d3SIoana Ciornei kfree(dma_mem); 874f48298d3SIoana Ciornei return err; 875f48298d3SIoana Ciornei } 876f48298d3SIoana Ciornei 877f48298d3SIoana Ciornei static int dpaa2_switch_fdb_entry_dump(struct ethsw_port_priv *port_priv, 878f48298d3SIoana Ciornei struct fdb_dump_entry *fdb_entry, 879f48298d3SIoana Ciornei void *data) 880f48298d3SIoana Ciornei { 881f48298d3SIoana Ciornei if (!dpaa2_switch_port_fdb_valid_entry(fdb_entry, port_priv)) 882f48298d3SIoana Ciornei return 0; 883f48298d3SIoana Ciornei 884f48298d3SIoana Ciornei return dpaa2_switch_fdb_dump_nl(fdb_entry, data); 885f48298d3SIoana Ciornei } 886f48298d3SIoana Ciornei 887f48298d3SIoana Ciornei static int dpaa2_switch_port_fdb_dump(struct sk_buff *skb, struct netlink_callback *cb, 888f48298d3SIoana Ciornei struct net_device *net_dev, 889f48298d3SIoana Ciornei struct net_device *filter_dev, int *idx) 890f48298d3SIoana Ciornei { 891f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(net_dev); 892f48298d3SIoana Ciornei struct ethsw_dump_ctx dump = { 893f48298d3SIoana Ciornei .dev = net_dev, 894f48298d3SIoana Ciornei .skb = skb, 895f48298d3SIoana Ciornei .cb = cb, 896f48298d3SIoana Ciornei .idx = *idx, 897f48298d3SIoana Ciornei }; 898f48298d3SIoana Ciornei int err; 899f48298d3SIoana Ciornei 900f48298d3SIoana Ciornei err = dpaa2_switch_fdb_iterate(port_priv, dpaa2_switch_fdb_entry_dump, &dump); 901f48298d3SIoana Ciornei *idx = dump.idx; 902f48298d3SIoana Ciornei 903f48298d3SIoana Ciornei return err; 904f48298d3SIoana Ciornei } 905f48298d3SIoana Ciornei 906f48298d3SIoana Ciornei static int dpaa2_switch_fdb_entry_fast_age(struct ethsw_port_priv *port_priv, 907f48298d3SIoana Ciornei struct fdb_dump_entry *fdb_entry, 908f48298d3SIoana Ciornei void *data __always_unused) 909f48298d3SIoana Ciornei { 910f48298d3SIoana Ciornei if (!dpaa2_switch_port_fdb_valid_entry(fdb_entry, port_priv)) 911f48298d3SIoana Ciornei return 0; 912f48298d3SIoana Ciornei 913f48298d3SIoana Ciornei if (!(fdb_entry->type & DPSW_FDB_ENTRY_TYPE_DYNAMIC)) 914f48298d3SIoana Ciornei return 0; 915f48298d3SIoana Ciornei 916f48298d3SIoana Ciornei if (fdb_entry->type & DPSW_FDB_ENTRY_TYPE_UNICAST) 917f48298d3SIoana Ciornei dpaa2_switch_port_fdb_del_uc(port_priv, fdb_entry->mac_addr); 918f48298d3SIoana Ciornei else 919f48298d3SIoana Ciornei dpaa2_switch_port_fdb_del_mc(port_priv, fdb_entry->mac_addr); 920f48298d3SIoana Ciornei 921f48298d3SIoana Ciornei return 0; 922f48298d3SIoana Ciornei } 923f48298d3SIoana Ciornei 924f48298d3SIoana Ciornei static void dpaa2_switch_port_fast_age(struct ethsw_port_priv *port_priv) 925f48298d3SIoana Ciornei { 926f48298d3SIoana Ciornei dpaa2_switch_fdb_iterate(port_priv, 927f48298d3SIoana Ciornei dpaa2_switch_fdb_entry_fast_age, NULL); 928f48298d3SIoana Ciornei } 929f48298d3SIoana Ciornei 930f48298d3SIoana Ciornei static int dpaa2_switch_port_vlan_add(struct net_device *netdev, __be16 proto, 931f48298d3SIoana Ciornei u16 vid) 932f48298d3SIoana Ciornei { 933f48298d3SIoana Ciornei struct switchdev_obj_port_vlan vlan = { 934f48298d3SIoana Ciornei .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 935f48298d3SIoana Ciornei .vid = vid, 936f48298d3SIoana Ciornei .obj.orig_dev = netdev, 937f48298d3SIoana Ciornei /* This API only allows programming tagged, non-PVID VIDs */ 938f48298d3SIoana Ciornei .flags = 0, 939f48298d3SIoana Ciornei }; 940f48298d3SIoana Ciornei 941f48298d3SIoana Ciornei return dpaa2_switch_port_vlans_add(netdev, &vlan); 942f48298d3SIoana Ciornei } 943f48298d3SIoana Ciornei 944f48298d3SIoana Ciornei static int dpaa2_switch_port_vlan_kill(struct net_device *netdev, __be16 proto, 945f48298d3SIoana Ciornei u16 vid) 946f48298d3SIoana Ciornei { 947f48298d3SIoana Ciornei struct switchdev_obj_port_vlan vlan = { 948f48298d3SIoana Ciornei .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 949f48298d3SIoana Ciornei .vid = vid, 950f48298d3SIoana Ciornei .obj.orig_dev = netdev, 951f48298d3SIoana Ciornei /* This API only allows programming tagged, non-PVID VIDs */ 952f48298d3SIoana Ciornei .flags = 0, 953f48298d3SIoana Ciornei }; 954f48298d3SIoana Ciornei 955f48298d3SIoana Ciornei return dpaa2_switch_port_vlans_del(netdev, &vlan); 956f48298d3SIoana Ciornei } 957f48298d3SIoana Ciornei 958f48298d3SIoana Ciornei static int dpaa2_switch_port_set_mac_addr(struct ethsw_port_priv *port_priv) 959f48298d3SIoana Ciornei { 960f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 961f48298d3SIoana Ciornei struct net_device *net_dev = port_priv->netdev; 962f48298d3SIoana Ciornei struct device *dev = net_dev->dev.parent; 963f48298d3SIoana Ciornei u8 mac_addr[ETH_ALEN]; 964f48298d3SIoana Ciornei int err; 965f48298d3SIoana Ciornei 966f48298d3SIoana Ciornei if (!(ethsw->features & ETHSW_FEATURE_MAC_ADDR)) 967f48298d3SIoana Ciornei return 0; 968f48298d3SIoana Ciornei 969f48298d3SIoana Ciornei /* Get firmware address, if any */ 970f48298d3SIoana Ciornei err = dpsw_if_get_port_mac_addr(ethsw->mc_io, 0, ethsw->dpsw_handle, 971f48298d3SIoana Ciornei port_priv->idx, mac_addr); 972f48298d3SIoana Ciornei if (err) { 973f48298d3SIoana Ciornei dev_err(dev, "dpsw_if_get_port_mac_addr() failed\n"); 974f48298d3SIoana Ciornei return err; 975f48298d3SIoana Ciornei } 976f48298d3SIoana Ciornei 977f48298d3SIoana Ciornei /* First check if firmware has any address configured by bootloader */ 978f48298d3SIoana Ciornei if (!is_zero_ether_addr(mac_addr)) { 979f48298d3SIoana Ciornei memcpy(net_dev->dev_addr, mac_addr, net_dev->addr_len); 980f48298d3SIoana Ciornei } else { 981f48298d3SIoana Ciornei /* No MAC address configured, fill in net_dev->dev_addr 982f48298d3SIoana Ciornei * with a random one 983f48298d3SIoana Ciornei */ 984f48298d3SIoana Ciornei eth_hw_addr_random(net_dev); 985f48298d3SIoana Ciornei dev_dbg_once(dev, "device(s) have all-zero hwaddr, replaced with random\n"); 986f48298d3SIoana Ciornei 987f48298d3SIoana Ciornei /* Override NET_ADDR_RANDOM set by eth_hw_addr_random(); for all 988f48298d3SIoana Ciornei * practical purposes, this will be our "permanent" mac address, 989f48298d3SIoana Ciornei * at least until the next reboot. This move will also permit 990f48298d3SIoana Ciornei * register_netdevice() to properly fill up net_dev->perm_addr. 991f48298d3SIoana Ciornei */ 992f48298d3SIoana Ciornei net_dev->addr_assign_type = NET_ADDR_PERM; 993f48298d3SIoana Ciornei } 994f48298d3SIoana Ciornei 995f48298d3SIoana Ciornei return 0; 996f48298d3SIoana Ciornei } 997f48298d3SIoana Ciornei 998f48298d3SIoana Ciornei static void dpaa2_switch_free_fd(const struct ethsw_core *ethsw, 999f48298d3SIoana Ciornei const struct dpaa2_fd *fd) 1000f48298d3SIoana Ciornei { 1001f48298d3SIoana Ciornei struct device *dev = ethsw->dev; 1002f48298d3SIoana Ciornei unsigned char *buffer_start; 1003f48298d3SIoana Ciornei struct sk_buff **skbh, *skb; 1004f48298d3SIoana Ciornei dma_addr_t fd_addr; 1005f48298d3SIoana Ciornei 1006f48298d3SIoana Ciornei fd_addr = dpaa2_fd_get_addr(fd); 1007f48298d3SIoana Ciornei skbh = dpaa2_iova_to_virt(ethsw->iommu_domain, fd_addr); 1008f48298d3SIoana Ciornei 1009f48298d3SIoana Ciornei skb = *skbh; 1010f48298d3SIoana Ciornei buffer_start = (unsigned char *)skbh; 1011f48298d3SIoana Ciornei 1012f48298d3SIoana Ciornei dma_unmap_single(dev, fd_addr, 1013f48298d3SIoana Ciornei skb_tail_pointer(skb) - buffer_start, 1014f48298d3SIoana Ciornei DMA_TO_DEVICE); 1015f48298d3SIoana Ciornei 1016f48298d3SIoana Ciornei /* Move on with skb release */ 1017f48298d3SIoana Ciornei dev_kfree_skb(skb); 1018f48298d3SIoana Ciornei } 1019f48298d3SIoana Ciornei 1020f48298d3SIoana Ciornei static int dpaa2_switch_build_single_fd(struct ethsw_core *ethsw, 1021f48298d3SIoana Ciornei struct sk_buff *skb, 1022f48298d3SIoana Ciornei struct dpaa2_fd *fd) 1023f48298d3SIoana Ciornei { 1024f48298d3SIoana Ciornei struct device *dev = ethsw->dev; 1025f48298d3SIoana Ciornei struct sk_buff **skbh; 1026f48298d3SIoana Ciornei dma_addr_t addr; 1027f48298d3SIoana Ciornei u8 *buff_start; 1028f48298d3SIoana Ciornei void *hwa; 1029f48298d3SIoana Ciornei 1030f48298d3SIoana Ciornei buff_start = PTR_ALIGN(skb->data - DPAA2_SWITCH_TX_DATA_OFFSET - 1031f48298d3SIoana Ciornei DPAA2_SWITCH_TX_BUF_ALIGN, 1032f48298d3SIoana Ciornei DPAA2_SWITCH_TX_BUF_ALIGN); 1033f48298d3SIoana Ciornei 1034f48298d3SIoana Ciornei /* Clear FAS to have consistent values for TX confirmation. It is 1035f48298d3SIoana Ciornei * located in the first 8 bytes of the buffer's hardware annotation 1036f48298d3SIoana Ciornei * area 1037f48298d3SIoana Ciornei */ 1038f48298d3SIoana Ciornei hwa = buff_start + DPAA2_SWITCH_SWA_SIZE; 1039f48298d3SIoana Ciornei memset(hwa, 0, 8); 1040f48298d3SIoana Ciornei 1041f48298d3SIoana Ciornei /* Store a backpointer to the skb at the beginning of the buffer 1042f48298d3SIoana Ciornei * (in the private data area) such that we can release it 1043f48298d3SIoana Ciornei * on Tx confirm 1044f48298d3SIoana Ciornei */ 1045f48298d3SIoana Ciornei skbh = (struct sk_buff **)buff_start; 1046f48298d3SIoana Ciornei *skbh = skb; 1047f48298d3SIoana Ciornei 1048f48298d3SIoana Ciornei addr = dma_map_single(dev, buff_start, 1049f48298d3SIoana Ciornei skb_tail_pointer(skb) - buff_start, 1050f48298d3SIoana Ciornei DMA_TO_DEVICE); 1051f48298d3SIoana Ciornei if (unlikely(dma_mapping_error(dev, addr))) 1052f48298d3SIoana Ciornei return -ENOMEM; 1053f48298d3SIoana Ciornei 1054f48298d3SIoana Ciornei /* Setup the FD fields */ 1055f48298d3SIoana Ciornei memset(fd, 0, sizeof(*fd)); 1056f48298d3SIoana Ciornei 1057f48298d3SIoana Ciornei dpaa2_fd_set_addr(fd, addr); 1058f48298d3SIoana Ciornei dpaa2_fd_set_offset(fd, (u16)(skb->data - buff_start)); 1059f48298d3SIoana Ciornei dpaa2_fd_set_len(fd, skb->len); 1060f48298d3SIoana Ciornei dpaa2_fd_set_format(fd, dpaa2_fd_single); 1061f48298d3SIoana Ciornei 1062f48298d3SIoana Ciornei return 0; 1063f48298d3SIoana Ciornei } 1064f48298d3SIoana Ciornei 1065f48298d3SIoana Ciornei static netdev_tx_t dpaa2_switch_port_tx(struct sk_buff *skb, 1066f48298d3SIoana Ciornei struct net_device *net_dev) 1067f48298d3SIoana Ciornei { 1068f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(net_dev); 1069f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 1070f48298d3SIoana Ciornei int retries = DPAA2_SWITCH_SWP_BUSY_RETRIES; 1071f48298d3SIoana Ciornei struct dpaa2_fd fd; 1072f48298d3SIoana Ciornei int err; 1073f48298d3SIoana Ciornei 1074f48298d3SIoana Ciornei if (unlikely(skb_headroom(skb) < DPAA2_SWITCH_NEEDED_HEADROOM)) { 1075f48298d3SIoana Ciornei struct sk_buff *ns; 1076f48298d3SIoana Ciornei 1077f48298d3SIoana Ciornei ns = skb_realloc_headroom(skb, DPAA2_SWITCH_NEEDED_HEADROOM); 1078f48298d3SIoana Ciornei if (unlikely(!ns)) { 1079f48298d3SIoana Ciornei net_err_ratelimited("%s: Error reallocating skb headroom\n", net_dev->name); 1080f48298d3SIoana Ciornei goto err_free_skb; 1081f48298d3SIoana Ciornei } 1082f48298d3SIoana Ciornei dev_consume_skb_any(skb); 1083f48298d3SIoana Ciornei skb = ns; 1084f48298d3SIoana Ciornei } 1085f48298d3SIoana Ciornei 1086f48298d3SIoana Ciornei /* We'll be holding a back-reference to the skb until Tx confirmation */ 1087f48298d3SIoana Ciornei skb = skb_unshare(skb, GFP_ATOMIC); 1088f48298d3SIoana Ciornei if (unlikely(!skb)) { 1089f48298d3SIoana Ciornei /* skb_unshare() has already freed the skb */ 1090f48298d3SIoana Ciornei net_err_ratelimited("%s: Error copying the socket buffer\n", net_dev->name); 1091f48298d3SIoana Ciornei goto err_exit; 1092f48298d3SIoana Ciornei } 1093f48298d3SIoana Ciornei 1094f48298d3SIoana Ciornei /* At this stage, we do not support non-linear skbs so just try to 1095f48298d3SIoana Ciornei * linearize the skb and if that's not working, just drop the packet. 1096f48298d3SIoana Ciornei */ 1097f48298d3SIoana Ciornei err = skb_linearize(skb); 1098f48298d3SIoana Ciornei if (err) { 1099f48298d3SIoana Ciornei net_err_ratelimited("%s: skb_linearize error (%d)!\n", net_dev->name, err); 1100f48298d3SIoana Ciornei goto err_free_skb; 1101f48298d3SIoana Ciornei } 1102f48298d3SIoana Ciornei 1103f48298d3SIoana Ciornei err = dpaa2_switch_build_single_fd(ethsw, skb, &fd); 1104f48298d3SIoana Ciornei if (unlikely(err)) { 1105f48298d3SIoana Ciornei net_err_ratelimited("%s: ethsw_build_*_fd() %d\n", net_dev->name, err); 1106f48298d3SIoana Ciornei goto err_free_skb; 1107f48298d3SIoana Ciornei } 1108f48298d3SIoana Ciornei 1109f48298d3SIoana Ciornei do { 1110f48298d3SIoana Ciornei err = dpaa2_io_service_enqueue_qd(NULL, 1111f48298d3SIoana Ciornei port_priv->tx_qdid, 1112f48298d3SIoana Ciornei 8, 0, &fd); 1113f48298d3SIoana Ciornei retries--; 1114f48298d3SIoana Ciornei } while (err == -EBUSY && retries); 1115f48298d3SIoana Ciornei 1116f48298d3SIoana Ciornei if (unlikely(err < 0)) { 1117f48298d3SIoana Ciornei dpaa2_switch_free_fd(ethsw, &fd); 1118f48298d3SIoana Ciornei goto err_exit; 1119f48298d3SIoana Ciornei } 1120f48298d3SIoana Ciornei 1121f48298d3SIoana Ciornei return NETDEV_TX_OK; 1122f48298d3SIoana Ciornei 1123f48298d3SIoana Ciornei err_free_skb: 1124f48298d3SIoana Ciornei dev_kfree_skb(skb); 1125f48298d3SIoana Ciornei err_exit: 1126f48298d3SIoana Ciornei return NETDEV_TX_OK; 1127f48298d3SIoana Ciornei } 1128f48298d3SIoana Ciornei 11291110318dSIoana Ciornei static int 11301110318dSIoana Ciornei dpaa2_switch_setup_tc_cls_flower(struct dpaa2_switch_acl_tbl *acl_tbl, 11311110318dSIoana Ciornei struct flow_cls_offload *f) 11321110318dSIoana Ciornei { 11331110318dSIoana Ciornei switch (f->command) { 11341110318dSIoana Ciornei case FLOW_CLS_REPLACE: 11351110318dSIoana Ciornei return dpaa2_switch_cls_flower_replace(acl_tbl, f); 11361110318dSIoana Ciornei case FLOW_CLS_DESTROY: 11371110318dSIoana Ciornei return dpaa2_switch_cls_flower_destroy(acl_tbl, f); 11381110318dSIoana Ciornei default: 11391110318dSIoana Ciornei return -EOPNOTSUPP; 11401110318dSIoana Ciornei } 11411110318dSIoana Ciornei } 11421110318dSIoana Ciornei 11434ba28c1aSIoana Ciornei static int 11444ba28c1aSIoana Ciornei dpaa2_switch_setup_tc_cls_matchall(struct dpaa2_switch_acl_tbl *acl_tbl, 11454ba28c1aSIoana Ciornei struct tc_cls_matchall_offload *f) 11464ba28c1aSIoana Ciornei { 11474ba28c1aSIoana Ciornei switch (f->command) { 11484ba28c1aSIoana Ciornei case TC_CLSMATCHALL_REPLACE: 11494ba28c1aSIoana Ciornei return dpaa2_switch_cls_matchall_replace(acl_tbl, f); 11504ba28c1aSIoana Ciornei case TC_CLSMATCHALL_DESTROY: 11514ba28c1aSIoana Ciornei return dpaa2_switch_cls_matchall_destroy(acl_tbl, f); 11524ba28c1aSIoana Ciornei default: 11534ba28c1aSIoana Ciornei return -EOPNOTSUPP; 11544ba28c1aSIoana Ciornei } 11554ba28c1aSIoana Ciornei } 11564ba28c1aSIoana Ciornei 11571110318dSIoana Ciornei static int dpaa2_switch_port_setup_tc_block_cb_ig(enum tc_setup_type type, 11581110318dSIoana Ciornei void *type_data, 11591110318dSIoana Ciornei void *cb_priv) 11601110318dSIoana Ciornei { 11611110318dSIoana Ciornei switch (type) { 11621110318dSIoana Ciornei case TC_SETUP_CLSFLOWER: 11631110318dSIoana Ciornei return dpaa2_switch_setup_tc_cls_flower(cb_priv, type_data); 11644ba28c1aSIoana Ciornei case TC_SETUP_CLSMATCHALL: 11654ba28c1aSIoana Ciornei return dpaa2_switch_setup_tc_cls_matchall(cb_priv, type_data); 11661110318dSIoana Ciornei default: 11671110318dSIoana Ciornei return -EOPNOTSUPP; 11681110318dSIoana Ciornei } 11691110318dSIoana Ciornei } 11701110318dSIoana Ciornei 11711110318dSIoana Ciornei static LIST_HEAD(dpaa2_switch_block_cb_list); 11721110318dSIoana Ciornei 11731110318dSIoana Ciornei static int dpaa2_switch_port_acl_tbl_bind(struct ethsw_port_priv *port_priv, 11741110318dSIoana Ciornei struct dpaa2_switch_acl_tbl *acl_tbl) 11751110318dSIoana Ciornei { 11761110318dSIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 11771110318dSIoana Ciornei struct net_device *netdev = port_priv->netdev; 11781110318dSIoana Ciornei struct dpsw_acl_if_cfg acl_if_cfg; 11791110318dSIoana Ciornei int err; 11801110318dSIoana Ciornei 11811110318dSIoana Ciornei if (port_priv->acl_tbl) 11821110318dSIoana Ciornei return -EINVAL; 11831110318dSIoana Ciornei 11841110318dSIoana Ciornei acl_if_cfg.if_id[0] = port_priv->idx; 11851110318dSIoana Ciornei acl_if_cfg.num_ifs = 1; 11861110318dSIoana Ciornei err = dpsw_acl_add_if(ethsw->mc_io, 0, ethsw->dpsw_handle, 11871110318dSIoana Ciornei acl_tbl->id, &acl_if_cfg); 11881110318dSIoana Ciornei if (err) { 11891110318dSIoana Ciornei netdev_err(netdev, "dpsw_acl_add_if err %d\n", err); 11901110318dSIoana Ciornei return err; 11911110318dSIoana Ciornei } 11921110318dSIoana Ciornei 11931110318dSIoana Ciornei acl_tbl->ports |= BIT(port_priv->idx); 11941110318dSIoana Ciornei port_priv->acl_tbl = acl_tbl; 11951110318dSIoana Ciornei 11961110318dSIoana Ciornei return 0; 11971110318dSIoana Ciornei } 11981110318dSIoana Ciornei 11991110318dSIoana Ciornei static int 12001110318dSIoana Ciornei dpaa2_switch_port_acl_tbl_unbind(struct ethsw_port_priv *port_priv, 12011110318dSIoana Ciornei struct dpaa2_switch_acl_tbl *acl_tbl) 12021110318dSIoana Ciornei { 12031110318dSIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 12041110318dSIoana Ciornei struct net_device *netdev = port_priv->netdev; 12051110318dSIoana Ciornei struct dpsw_acl_if_cfg acl_if_cfg; 12061110318dSIoana Ciornei int err; 12071110318dSIoana Ciornei 12081110318dSIoana Ciornei if (port_priv->acl_tbl != acl_tbl) 12091110318dSIoana Ciornei return -EINVAL; 12101110318dSIoana Ciornei 12111110318dSIoana Ciornei acl_if_cfg.if_id[0] = port_priv->idx; 12121110318dSIoana Ciornei acl_if_cfg.num_ifs = 1; 12131110318dSIoana Ciornei err = dpsw_acl_remove_if(ethsw->mc_io, 0, ethsw->dpsw_handle, 12141110318dSIoana Ciornei acl_tbl->id, &acl_if_cfg); 12151110318dSIoana Ciornei if (err) { 12161110318dSIoana Ciornei netdev_err(netdev, "dpsw_acl_add_if err %d\n", err); 12171110318dSIoana Ciornei return err; 12181110318dSIoana Ciornei } 12191110318dSIoana Ciornei 12201110318dSIoana Ciornei acl_tbl->ports &= ~BIT(port_priv->idx); 12211110318dSIoana Ciornei port_priv->acl_tbl = NULL; 12221110318dSIoana Ciornei return 0; 12231110318dSIoana Ciornei } 12241110318dSIoana Ciornei 12251110318dSIoana Ciornei static int dpaa2_switch_port_block_bind(struct ethsw_port_priv *port_priv, 12261110318dSIoana Ciornei struct dpaa2_switch_acl_tbl *acl_tbl) 12271110318dSIoana Ciornei { 12281110318dSIoana Ciornei struct dpaa2_switch_acl_tbl *old_acl_tbl = port_priv->acl_tbl; 12291110318dSIoana Ciornei int err; 12301110318dSIoana Ciornei 12311110318dSIoana Ciornei /* If the port is already bound to this ACL table then do nothing. This 12321110318dSIoana Ciornei * can happen when this port is the first one to join a tc block 12331110318dSIoana Ciornei */ 12341110318dSIoana Ciornei if (port_priv->acl_tbl == acl_tbl) 12351110318dSIoana Ciornei return 0; 12361110318dSIoana Ciornei 12371110318dSIoana Ciornei err = dpaa2_switch_port_acl_tbl_unbind(port_priv, old_acl_tbl); 12381110318dSIoana Ciornei if (err) 12391110318dSIoana Ciornei return err; 12401110318dSIoana Ciornei 12411110318dSIoana Ciornei /* Mark the previous ACL table as being unused if this was the last 12421110318dSIoana Ciornei * port that was using it. 12431110318dSIoana Ciornei */ 12441110318dSIoana Ciornei if (old_acl_tbl->ports == 0) 12451110318dSIoana Ciornei old_acl_tbl->in_use = false; 12461110318dSIoana Ciornei 12471110318dSIoana Ciornei return dpaa2_switch_port_acl_tbl_bind(port_priv, acl_tbl); 12481110318dSIoana Ciornei } 12491110318dSIoana Ciornei 12501110318dSIoana Ciornei static int dpaa2_switch_port_block_unbind(struct ethsw_port_priv *port_priv, 12511110318dSIoana Ciornei struct dpaa2_switch_acl_tbl *acl_tbl) 12521110318dSIoana Ciornei { 12531110318dSIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 12541110318dSIoana Ciornei struct dpaa2_switch_acl_tbl *new_acl_tbl; 12551110318dSIoana Ciornei int err; 12561110318dSIoana Ciornei 12571110318dSIoana Ciornei /* We are the last port that leaves a block (an ACL table). 12581110318dSIoana Ciornei * We'll continue to use this table. 12591110318dSIoana Ciornei */ 12601110318dSIoana Ciornei if (acl_tbl->ports == BIT(port_priv->idx)) 12611110318dSIoana Ciornei return 0; 12621110318dSIoana Ciornei 12631110318dSIoana Ciornei err = dpaa2_switch_port_acl_tbl_unbind(port_priv, acl_tbl); 12641110318dSIoana Ciornei if (err) 12651110318dSIoana Ciornei return err; 12661110318dSIoana Ciornei 12671110318dSIoana Ciornei if (acl_tbl->ports == 0) 12681110318dSIoana Ciornei acl_tbl->in_use = false; 12691110318dSIoana Ciornei 12701110318dSIoana Ciornei new_acl_tbl = dpaa2_switch_acl_tbl_get_unused(ethsw); 12711110318dSIoana Ciornei new_acl_tbl->in_use = true; 12721110318dSIoana Ciornei return dpaa2_switch_port_acl_tbl_bind(port_priv, new_acl_tbl); 12731110318dSIoana Ciornei } 12741110318dSIoana Ciornei 12751110318dSIoana Ciornei static int dpaa2_switch_setup_tc_block_bind(struct net_device *netdev, 12761110318dSIoana Ciornei struct flow_block_offload *f) 12771110318dSIoana Ciornei { 12781110318dSIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 12791110318dSIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 12801110318dSIoana Ciornei struct dpaa2_switch_acl_tbl *acl_tbl; 12811110318dSIoana Ciornei struct flow_block_cb *block_cb; 12821110318dSIoana Ciornei bool register_block = false; 12831110318dSIoana Ciornei int err; 12841110318dSIoana Ciornei 12851110318dSIoana Ciornei block_cb = flow_block_cb_lookup(f->block, 12861110318dSIoana Ciornei dpaa2_switch_port_setup_tc_block_cb_ig, 12871110318dSIoana Ciornei ethsw); 12881110318dSIoana Ciornei 12891110318dSIoana Ciornei if (!block_cb) { 12901110318dSIoana Ciornei /* If the ACL table is not already known, then this port must 12911110318dSIoana Ciornei * be the first to join it. In this case, we can just continue 12921110318dSIoana Ciornei * to use our private table 12931110318dSIoana Ciornei */ 12941110318dSIoana Ciornei acl_tbl = port_priv->acl_tbl; 12951110318dSIoana Ciornei 12961110318dSIoana Ciornei block_cb = flow_block_cb_alloc(dpaa2_switch_port_setup_tc_block_cb_ig, 12971110318dSIoana Ciornei ethsw, acl_tbl, NULL); 12981110318dSIoana Ciornei if (IS_ERR(block_cb)) 12991110318dSIoana Ciornei return PTR_ERR(block_cb); 13001110318dSIoana Ciornei 13011110318dSIoana Ciornei register_block = true; 13021110318dSIoana Ciornei } else { 13031110318dSIoana Ciornei acl_tbl = flow_block_cb_priv(block_cb); 13041110318dSIoana Ciornei } 13051110318dSIoana Ciornei 13061110318dSIoana Ciornei flow_block_cb_incref(block_cb); 13071110318dSIoana Ciornei err = dpaa2_switch_port_block_bind(port_priv, acl_tbl); 13081110318dSIoana Ciornei if (err) 13091110318dSIoana Ciornei goto err_block_bind; 13101110318dSIoana Ciornei 13111110318dSIoana Ciornei if (register_block) { 13121110318dSIoana Ciornei flow_block_cb_add(block_cb, f); 13131110318dSIoana Ciornei list_add_tail(&block_cb->driver_list, 13141110318dSIoana Ciornei &dpaa2_switch_block_cb_list); 13151110318dSIoana Ciornei } 13161110318dSIoana Ciornei 13171110318dSIoana Ciornei return 0; 13181110318dSIoana Ciornei 13191110318dSIoana Ciornei err_block_bind: 13201110318dSIoana Ciornei if (!flow_block_cb_decref(block_cb)) 13211110318dSIoana Ciornei flow_block_cb_free(block_cb); 13221110318dSIoana Ciornei return err; 13231110318dSIoana Ciornei } 13241110318dSIoana Ciornei 13251110318dSIoana Ciornei static void dpaa2_switch_setup_tc_block_unbind(struct net_device *netdev, 13261110318dSIoana Ciornei struct flow_block_offload *f) 13271110318dSIoana Ciornei { 13281110318dSIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 13291110318dSIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 13301110318dSIoana Ciornei struct dpaa2_switch_acl_tbl *acl_tbl; 13311110318dSIoana Ciornei struct flow_block_cb *block_cb; 13321110318dSIoana Ciornei int err; 13331110318dSIoana Ciornei 13341110318dSIoana Ciornei block_cb = flow_block_cb_lookup(f->block, 13351110318dSIoana Ciornei dpaa2_switch_port_setup_tc_block_cb_ig, 13361110318dSIoana Ciornei ethsw); 13371110318dSIoana Ciornei if (!block_cb) 13381110318dSIoana Ciornei return; 13391110318dSIoana Ciornei 13401110318dSIoana Ciornei acl_tbl = flow_block_cb_priv(block_cb); 13411110318dSIoana Ciornei err = dpaa2_switch_port_block_unbind(port_priv, acl_tbl); 13421110318dSIoana Ciornei if (!err && !flow_block_cb_decref(block_cb)) { 13431110318dSIoana Ciornei flow_block_cb_remove(block_cb, f); 13441110318dSIoana Ciornei list_del(&block_cb->driver_list); 13451110318dSIoana Ciornei } 13461110318dSIoana Ciornei } 13471110318dSIoana Ciornei 13481110318dSIoana Ciornei static int dpaa2_switch_setup_tc_block(struct net_device *netdev, 13491110318dSIoana Ciornei struct flow_block_offload *f) 13501110318dSIoana Ciornei { 13511110318dSIoana Ciornei if (f->binder_type != FLOW_BLOCK_BINDER_TYPE_CLSACT_INGRESS) 13521110318dSIoana Ciornei return -EOPNOTSUPP; 13531110318dSIoana Ciornei 13541110318dSIoana Ciornei f->driver_block_list = &dpaa2_switch_block_cb_list; 13551110318dSIoana Ciornei 13561110318dSIoana Ciornei switch (f->command) { 13571110318dSIoana Ciornei case FLOW_BLOCK_BIND: 13581110318dSIoana Ciornei return dpaa2_switch_setup_tc_block_bind(netdev, f); 13591110318dSIoana Ciornei case FLOW_BLOCK_UNBIND: 13601110318dSIoana Ciornei dpaa2_switch_setup_tc_block_unbind(netdev, f); 13611110318dSIoana Ciornei return 0; 13621110318dSIoana Ciornei default: 13631110318dSIoana Ciornei return -EOPNOTSUPP; 13641110318dSIoana Ciornei } 13651110318dSIoana Ciornei } 13661110318dSIoana Ciornei 13671110318dSIoana Ciornei static int dpaa2_switch_port_setup_tc(struct net_device *netdev, 13681110318dSIoana Ciornei enum tc_setup_type type, 13691110318dSIoana Ciornei void *type_data) 13701110318dSIoana Ciornei { 13711110318dSIoana Ciornei switch (type) { 13721110318dSIoana Ciornei case TC_SETUP_BLOCK: { 13731110318dSIoana Ciornei return dpaa2_switch_setup_tc_block(netdev, type_data); 13741110318dSIoana Ciornei } 13751110318dSIoana Ciornei default: 13761110318dSIoana Ciornei return -EOPNOTSUPP; 13771110318dSIoana Ciornei } 13781110318dSIoana Ciornei 13791110318dSIoana Ciornei return 0; 13801110318dSIoana Ciornei } 13811110318dSIoana Ciornei 1382f48298d3SIoana Ciornei static const struct net_device_ops dpaa2_switch_port_ops = { 1383f48298d3SIoana Ciornei .ndo_open = dpaa2_switch_port_open, 1384f48298d3SIoana Ciornei .ndo_stop = dpaa2_switch_port_stop, 1385f48298d3SIoana Ciornei 1386f48298d3SIoana Ciornei .ndo_set_mac_address = eth_mac_addr, 1387f48298d3SIoana Ciornei .ndo_get_stats64 = dpaa2_switch_port_get_stats, 1388f48298d3SIoana Ciornei .ndo_change_mtu = dpaa2_switch_port_change_mtu, 1389f48298d3SIoana Ciornei .ndo_has_offload_stats = dpaa2_switch_port_has_offload_stats, 1390f48298d3SIoana Ciornei .ndo_get_offload_stats = dpaa2_switch_port_get_offload_stats, 1391f48298d3SIoana Ciornei .ndo_fdb_dump = dpaa2_switch_port_fdb_dump, 1392f48298d3SIoana Ciornei .ndo_vlan_rx_add_vid = dpaa2_switch_port_vlan_add, 1393f48298d3SIoana Ciornei .ndo_vlan_rx_kill_vid = dpaa2_switch_port_vlan_kill, 1394f48298d3SIoana Ciornei 1395f48298d3SIoana Ciornei .ndo_start_xmit = dpaa2_switch_port_tx, 1396f48298d3SIoana Ciornei .ndo_get_port_parent_id = dpaa2_switch_port_parent_id, 1397f48298d3SIoana Ciornei .ndo_get_phys_port_name = dpaa2_switch_port_get_phys_name, 13981110318dSIoana Ciornei .ndo_setup_tc = dpaa2_switch_port_setup_tc, 1399f48298d3SIoana Ciornei }; 1400f48298d3SIoana Ciornei 1401f48298d3SIoana Ciornei bool dpaa2_switch_port_dev_check(const struct net_device *netdev) 1402f48298d3SIoana Ciornei { 1403f48298d3SIoana Ciornei return netdev->netdev_ops == &dpaa2_switch_port_ops; 1404f48298d3SIoana Ciornei } 1405f48298d3SIoana Ciornei 1406f48298d3SIoana Ciornei static void dpaa2_switch_links_state_update(struct ethsw_core *ethsw) 1407f48298d3SIoana Ciornei { 1408f48298d3SIoana Ciornei int i; 1409f48298d3SIoana Ciornei 1410f48298d3SIoana Ciornei for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 1411f48298d3SIoana Ciornei dpaa2_switch_port_carrier_state_sync(ethsw->ports[i]->netdev); 1412f48298d3SIoana Ciornei dpaa2_switch_port_set_mac_addr(ethsw->ports[i]); 1413f48298d3SIoana Ciornei } 1414f48298d3SIoana Ciornei } 1415f48298d3SIoana Ciornei 1416f48298d3SIoana Ciornei static irqreturn_t dpaa2_switch_irq0_handler_thread(int irq_num, void *arg) 1417f48298d3SIoana Ciornei { 1418f48298d3SIoana Ciornei struct device *dev = (struct device *)arg; 1419f48298d3SIoana Ciornei struct ethsw_core *ethsw = dev_get_drvdata(dev); 1420f48298d3SIoana Ciornei 1421f48298d3SIoana Ciornei /* Mask the events and the if_id reserved bits to be cleared on read */ 1422f48298d3SIoana Ciornei u32 status = DPSW_IRQ_EVENT_LINK_CHANGED | 0xFFFF0000; 1423f48298d3SIoana Ciornei int err; 1424f48298d3SIoana Ciornei 1425f48298d3SIoana Ciornei err = dpsw_get_irq_status(ethsw->mc_io, 0, ethsw->dpsw_handle, 1426f48298d3SIoana Ciornei DPSW_IRQ_INDEX_IF, &status); 1427f48298d3SIoana Ciornei if (err) { 1428f48298d3SIoana Ciornei dev_err(dev, "Can't get irq status (err %d)\n", err); 1429f48298d3SIoana Ciornei 1430f48298d3SIoana Ciornei err = dpsw_clear_irq_status(ethsw->mc_io, 0, ethsw->dpsw_handle, 1431f48298d3SIoana Ciornei DPSW_IRQ_INDEX_IF, 0xFFFFFFFF); 1432f48298d3SIoana Ciornei if (err) 1433f48298d3SIoana Ciornei dev_err(dev, "Can't clear irq status (err %d)\n", err); 1434f48298d3SIoana Ciornei goto out; 1435f48298d3SIoana Ciornei } 1436f48298d3SIoana Ciornei 1437f48298d3SIoana Ciornei if (status & DPSW_IRQ_EVENT_LINK_CHANGED) 1438f48298d3SIoana Ciornei dpaa2_switch_links_state_update(ethsw); 1439f48298d3SIoana Ciornei 1440f48298d3SIoana Ciornei out: 1441f48298d3SIoana Ciornei return IRQ_HANDLED; 1442f48298d3SIoana Ciornei } 1443f48298d3SIoana Ciornei 1444f48298d3SIoana Ciornei static int dpaa2_switch_setup_irqs(struct fsl_mc_device *sw_dev) 1445f48298d3SIoana Ciornei { 1446f48298d3SIoana Ciornei struct device *dev = &sw_dev->dev; 1447f48298d3SIoana Ciornei struct ethsw_core *ethsw = dev_get_drvdata(dev); 1448f48298d3SIoana Ciornei u32 mask = DPSW_IRQ_EVENT_LINK_CHANGED; 1449f48298d3SIoana Ciornei struct fsl_mc_device_irq *irq; 1450f48298d3SIoana Ciornei int err; 1451f48298d3SIoana Ciornei 1452f48298d3SIoana Ciornei err = fsl_mc_allocate_irqs(sw_dev); 1453f48298d3SIoana Ciornei if (err) { 1454f48298d3SIoana Ciornei dev_err(dev, "MC irqs allocation failed\n"); 1455f48298d3SIoana Ciornei return err; 1456f48298d3SIoana Ciornei } 1457f48298d3SIoana Ciornei 1458f48298d3SIoana Ciornei if (WARN_ON(sw_dev->obj_desc.irq_count != DPSW_IRQ_NUM)) { 1459f48298d3SIoana Ciornei err = -EINVAL; 1460f48298d3SIoana Ciornei goto free_irq; 1461f48298d3SIoana Ciornei } 1462f48298d3SIoana Ciornei 1463f48298d3SIoana Ciornei err = dpsw_set_irq_enable(ethsw->mc_io, 0, ethsw->dpsw_handle, 1464f48298d3SIoana Ciornei DPSW_IRQ_INDEX_IF, 0); 1465f48298d3SIoana Ciornei if (err) { 1466f48298d3SIoana Ciornei dev_err(dev, "dpsw_set_irq_enable err %d\n", err); 1467f48298d3SIoana Ciornei goto free_irq; 1468f48298d3SIoana Ciornei } 1469f48298d3SIoana Ciornei 1470f48298d3SIoana Ciornei irq = sw_dev->irqs[DPSW_IRQ_INDEX_IF]; 1471f48298d3SIoana Ciornei 1472f48298d3SIoana Ciornei err = devm_request_threaded_irq(dev, irq->msi_desc->irq, 1473f48298d3SIoana Ciornei NULL, 1474f48298d3SIoana Ciornei dpaa2_switch_irq0_handler_thread, 1475f48298d3SIoana Ciornei IRQF_NO_SUSPEND | IRQF_ONESHOT, 1476f48298d3SIoana Ciornei dev_name(dev), dev); 1477f48298d3SIoana Ciornei if (err) { 1478f48298d3SIoana Ciornei dev_err(dev, "devm_request_threaded_irq(): %d\n", err); 1479f48298d3SIoana Ciornei goto free_irq; 1480f48298d3SIoana Ciornei } 1481f48298d3SIoana Ciornei 1482f48298d3SIoana Ciornei err = dpsw_set_irq_mask(ethsw->mc_io, 0, ethsw->dpsw_handle, 1483f48298d3SIoana Ciornei DPSW_IRQ_INDEX_IF, mask); 1484f48298d3SIoana Ciornei if (err) { 1485f48298d3SIoana Ciornei dev_err(dev, "dpsw_set_irq_mask(): %d\n", err); 1486f48298d3SIoana Ciornei goto free_devm_irq; 1487f48298d3SIoana Ciornei } 1488f48298d3SIoana Ciornei 1489f48298d3SIoana Ciornei err = dpsw_set_irq_enable(ethsw->mc_io, 0, ethsw->dpsw_handle, 1490f48298d3SIoana Ciornei DPSW_IRQ_INDEX_IF, 1); 1491f48298d3SIoana Ciornei if (err) { 1492f48298d3SIoana Ciornei dev_err(dev, "dpsw_set_irq_enable(): %d\n", err); 1493f48298d3SIoana Ciornei goto free_devm_irq; 1494f48298d3SIoana Ciornei } 1495f48298d3SIoana Ciornei 1496f48298d3SIoana Ciornei return 0; 1497f48298d3SIoana Ciornei 1498f48298d3SIoana Ciornei free_devm_irq: 1499f48298d3SIoana Ciornei devm_free_irq(dev, irq->msi_desc->irq, dev); 1500f48298d3SIoana Ciornei free_irq: 1501f48298d3SIoana Ciornei fsl_mc_free_irqs(sw_dev); 1502f48298d3SIoana Ciornei return err; 1503f48298d3SIoana Ciornei } 1504f48298d3SIoana Ciornei 1505f48298d3SIoana Ciornei static void dpaa2_switch_teardown_irqs(struct fsl_mc_device *sw_dev) 1506f48298d3SIoana Ciornei { 1507f48298d3SIoana Ciornei struct device *dev = &sw_dev->dev; 1508f48298d3SIoana Ciornei struct ethsw_core *ethsw = dev_get_drvdata(dev); 1509f48298d3SIoana Ciornei int err; 1510f48298d3SIoana Ciornei 1511f48298d3SIoana Ciornei err = dpsw_set_irq_enable(ethsw->mc_io, 0, ethsw->dpsw_handle, 1512f48298d3SIoana Ciornei DPSW_IRQ_INDEX_IF, 0); 1513f48298d3SIoana Ciornei if (err) 1514f48298d3SIoana Ciornei dev_err(dev, "dpsw_set_irq_enable err %d\n", err); 1515f48298d3SIoana Ciornei 1516f48298d3SIoana Ciornei fsl_mc_free_irqs(sw_dev); 1517f48298d3SIoana Ciornei } 1518f48298d3SIoana Ciornei 15191e7cbabfSIoana Ciornei static int dpaa2_switch_port_set_learning(struct ethsw_port_priv *port_priv, bool enable) 15201e7cbabfSIoana Ciornei { 15211e7cbabfSIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 15221e7cbabfSIoana Ciornei enum dpsw_learning_mode learn_mode; 15231e7cbabfSIoana Ciornei int err; 15241e7cbabfSIoana Ciornei 15251e7cbabfSIoana Ciornei if (enable) 15261e7cbabfSIoana Ciornei learn_mode = DPSW_LEARNING_MODE_HW; 15271e7cbabfSIoana Ciornei else 15281e7cbabfSIoana Ciornei learn_mode = DPSW_LEARNING_MODE_DIS; 15291e7cbabfSIoana Ciornei 15301e7cbabfSIoana Ciornei err = dpsw_if_set_learning_mode(ethsw->mc_io, 0, ethsw->dpsw_handle, 15311e7cbabfSIoana Ciornei port_priv->idx, learn_mode); 15321e7cbabfSIoana Ciornei if (err) 15331e7cbabfSIoana Ciornei netdev_err(port_priv->netdev, "dpsw_if_set_learning_mode err %d\n", err); 15341e7cbabfSIoana Ciornei 15351e7cbabfSIoana Ciornei if (!enable) 15361e7cbabfSIoana Ciornei dpaa2_switch_port_fast_age(port_priv); 15371e7cbabfSIoana Ciornei 15381e7cbabfSIoana Ciornei return err; 15391e7cbabfSIoana Ciornei } 15401e7cbabfSIoana Ciornei 1541bc96781aSIoana Ciornei static int dpaa2_switch_port_attr_stp_state_set(struct net_device *netdev, 1542bc96781aSIoana Ciornei u8 state) 1543bc96781aSIoana Ciornei { 1544bc96781aSIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1545bc96781aSIoana Ciornei int err; 1546bc96781aSIoana Ciornei 1547bc96781aSIoana Ciornei err = dpaa2_switch_port_set_stp_state(port_priv, state); 1548bc96781aSIoana Ciornei if (err) 1549bc96781aSIoana Ciornei return err; 1550bc96781aSIoana Ciornei 1551bc96781aSIoana Ciornei switch (state) { 1552bc96781aSIoana Ciornei case BR_STATE_DISABLED: 1553bc96781aSIoana Ciornei case BR_STATE_BLOCKING: 1554bc96781aSIoana Ciornei case BR_STATE_LISTENING: 1555bc96781aSIoana Ciornei err = dpaa2_switch_port_set_learning(port_priv, false); 1556bc96781aSIoana Ciornei break; 1557bc96781aSIoana Ciornei case BR_STATE_LEARNING: 1558bc96781aSIoana Ciornei case BR_STATE_FORWARDING: 1559bc96781aSIoana Ciornei err = dpaa2_switch_port_set_learning(port_priv, 1560bc96781aSIoana Ciornei port_priv->learn_ena); 1561bc96781aSIoana Ciornei break; 1562bc96781aSIoana Ciornei } 1563bc96781aSIoana Ciornei 1564bc96781aSIoana Ciornei return err; 1565bc96781aSIoana Ciornei } 1566bc96781aSIoana Ciornei 1567b54eb093SIoana Ciornei static int dpaa2_switch_port_flood(struct ethsw_port_priv *port_priv, 1568b54eb093SIoana Ciornei struct switchdev_brport_flags flags) 1569b54eb093SIoana Ciornei { 1570b54eb093SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 1571b54eb093SIoana Ciornei 1572b54eb093SIoana Ciornei if (flags.mask & BR_BCAST_FLOOD) 1573b54eb093SIoana Ciornei port_priv->bcast_flood = !!(flags.val & BR_BCAST_FLOOD); 1574b54eb093SIoana Ciornei 15756253d5e3SIoana Ciornei if (flags.mask & BR_FLOOD) 15766253d5e3SIoana Ciornei port_priv->ucast_flood = !!(flags.val & BR_FLOOD); 15776253d5e3SIoana Ciornei 1578b54eb093SIoana Ciornei return dpaa2_switch_fdb_set_egress_flood(ethsw, port_priv->fdb->fdb_id); 1579b54eb093SIoana Ciornei } 1580b54eb093SIoana Ciornei 15811e7cbabfSIoana Ciornei static int dpaa2_switch_port_pre_bridge_flags(struct net_device *netdev, 15821e7cbabfSIoana Ciornei struct switchdev_brport_flags flags, 15831e7cbabfSIoana Ciornei struct netlink_ext_ack *extack) 15841e7cbabfSIoana Ciornei { 15856253d5e3SIoana Ciornei if (flags.mask & ~(BR_LEARNING | BR_BCAST_FLOOD | BR_FLOOD | 15866253d5e3SIoana Ciornei BR_MCAST_FLOOD)) 15871e7cbabfSIoana Ciornei return -EINVAL; 15881e7cbabfSIoana Ciornei 15896253d5e3SIoana Ciornei if (flags.mask & (BR_FLOOD | BR_MCAST_FLOOD)) { 15906253d5e3SIoana Ciornei bool multicast = !!(flags.val & BR_MCAST_FLOOD); 15916253d5e3SIoana Ciornei bool unicast = !!(flags.val & BR_FLOOD); 15926253d5e3SIoana Ciornei 15936253d5e3SIoana Ciornei if (unicast != multicast) { 15946253d5e3SIoana Ciornei NL_SET_ERR_MSG_MOD(extack, 15956253d5e3SIoana Ciornei "Cannot configure multicast flooding independently of unicast"); 15966253d5e3SIoana Ciornei return -EINVAL; 15976253d5e3SIoana Ciornei } 15986253d5e3SIoana Ciornei } 15996253d5e3SIoana Ciornei 16001e7cbabfSIoana Ciornei return 0; 16011e7cbabfSIoana Ciornei } 16021e7cbabfSIoana Ciornei 16031e7cbabfSIoana Ciornei static int dpaa2_switch_port_bridge_flags(struct net_device *netdev, 16041e7cbabfSIoana Ciornei struct switchdev_brport_flags flags, 16051e7cbabfSIoana Ciornei struct netlink_ext_ack *extack) 16061e7cbabfSIoana Ciornei { 16071e7cbabfSIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 16081e7cbabfSIoana Ciornei int err; 16091e7cbabfSIoana Ciornei 16101e7cbabfSIoana Ciornei if (flags.mask & BR_LEARNING) { 16111e7cbabfSIoana Ciornei bool learn_ena = !!(flags.val & BR_LEARNING); 16121e7cbabfSIoana Ciornei 16131e7cbabfSIoana Ciornei err = dpaa2_switch_port_set_learning(port_priv, learn_ena); 16141e7cbabfSIoana Ciornei if (err) 16151e7cbabfSIoana Ciornei return err; 161662734c74SIoana Ciornei port_priv->learn_ena = learn_ena; 16171e7cbabfSIoana Ciornei } 16181e7cbabfSIoana Ciornei 16196253d5e3SIoana Ciornei if (flags.mask & (BR_BCAST_FLOOD | BR_FLOOD | BR_MCAST_FLOOD)) { 1620b54eb093SIoana Ciornei err = dpaa2_switch_port_flood(port_priv, flags); 1621b54eb093SIoana Ciornei if (err) 1622b54eb093SIoana Ciornei return err; 1623b54eb093SIoana Ciornei } 1624b54eb093SIoana Ciornei 16251e7cbabfSIoana Ciornei return 0; 16261e7cbabfSIoana Ciornei } 16271e7cbabfSIoana Ciornei 1628*69bfac96SVladimir Oltean static int dpaa2_switch_port_attr_set(struct net_device *netdev, const void *ctx, 1629f48298d3SIoana Ciornei const struct switchdev_attr *attr, 1630f48298d3SIoana Ciornei struct netlink_ext_ack *extack) 1631f48298d3SIoana Ciornei { 1632f48298d3SIoana Ciornei int err = 0; 1633f48298d3SIoana Ciornei 1634f48298d3SIoana Ciornei switch (attr->id) { 1635f48298d3SIoana Ciornei case SWITCHDEV_ATTR_ID_PORT_STP_STATE: 1636f48298d3SIoana Ciornei err = dpaa2_switch_port_attr_stp_state_set(netdev, 1637f48298d3SIoana Ciornei attr->u.stp_state); 1638f48298d3SIoana Ciornei break; 1639f48298d3SIoana Ciornei case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING: 1640f48298d3SIoana Ciornei if (!attr->u.vlan_filtering) { 1641f48298d3SIoana Ciornei NL_SET_ERR_MSG_MOD(extack, 1642f48298d3SIoana Ciornei "The DPAA2 switch does not support VLAN-unaware operation"); 1643f48298d3SIoana Ciornei return -EOPNOTSUPP; 1644f48298d3SIoana Ciornei } 1645f48298d3SIoana Ciornei break; 16461e7cbabfSIoana Ciornei case SWITCHDEV_ATTR_ID_PORT_PRE_BRIDGE_FLAGS: 16471e7cbabfSIoana Ciornei err = dpaa2_switch_port_pre_bridge_flags(netdev, attr->u.brport_flags, extack); 16481e7cbabfSIoana Ciornei break; 16491e7cbabfSIoana Ciornei case SWITCHDEV_ATTR_ID_PORT_BRIDGE_FLAGS: 16501e7cbabfSIoana Ciornei err = dpaa2_switch_port_bridge_flags(netdev, attr->u.brport_flags, extack); 16511e7cbabfSIoana Ciornei break; 1652f48298d3SIoana Ciornei default: 1653f48298d3SIoana Ciornei err = -EOPNOTSUPP; 1654f48298d3SIoana Ciornei break; 1655f48298d3SIoana Ciornei } 1656f48298d3SIoana Ciornei 1657f48298d3SIoana Ciornei return err; 1658f48298d3SIoana Ciornei } 1659f48298d3SIoana Ciornei 1660f48298d3SIoana Ciornei int dpaa2_switch_port_vlans_add(struct net_device *netdev, 1661f48298d3SIoana Ciornei const struct switchdev_obj_port_vlan *vlan) 1662f48298d3SIoana Ciornei { 1663f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1664f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 1665f48298d3SIoana Ciornei struct dpsw_attr *attr = ðsw->sw_attr; 1666f48298d3SIoana Ciornei int err = 0; 1667f48298d3SIoana Ciornei 1668f48298d3SIoana Ciornei /* Make sure that the VLAN is not already configured 1669f48298d3SIoana Ciornei * on the switch port 1670f48298d3SIoana Ciornei */ 1671f48298d3SIoana Ciornei if (port_priv->vlans[vlan->vid] & ETHSW_VLAN_MEMBER) 1672f48298d3SIoana Ciornei return -EEXIST; 1673f48298d3SIoana Ciornei 1674f48298d3SIoana Ciornei /* Check if there is space for a new VLAN */ 1675f48298d3SIoana Ciornei err = dpsw_get_attributes(ethsw->mc_io, 0, ethsw->dpsw_handle, 1676f48298d3SIoana Ciornei ðsw->sw_attr); 1677f48298d3SIoana Ciornei if (err) { 1678f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_get_attributes err %d\n", err); 1679f48298d3SIoana Ciornei return err; 1680f48298d3SIoana Ciornei } 1681f48298d3SIoana Ciornei if (attr->max_vlans - attr->num_vlans < 1) 1682f48298d3SIoana Ciornei return -ENOSPC; 1683f48298d3SIoana Ciornei 1684f48298d3SIoana Ciornei /* Check if there is space for a new VLAN */ 1685f48298d3SIoana Ciornei err = dpsw_get_attributes(ethsw->mc_io, 0, ethsw->dpsw_handle, 1686f48298d3SIoana Ciornei ðsw->sw_attr); 1687f48298d3SIoana Ciornei if (err) { 1688f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_get_attributes err %d\n", err); 1689f48298d3SIoana Ciornei return err; 1690f48298d3SIoana Ciornei } 1691f48298d3SIoana Ciornei if (attr->max_vlans - attr->num_vlans < 1) 1692f48298d3SIoana Ciornei return -ENOSPC; 1693f48298d3SIoana Ciornei 1694f48298d3SIoana Ciornei if (!port_priv->ethsw_data->vlans[vlan->vid]) { 1695f48298d3SIoana Ciornei /* this is a new VLAN */ 1696f48298d3SIoana Ciornei err = dpaa2_switch_add_vlan(port_priv, vlan->vid); 1697f48298d3SIoana Ciornei if (err) 1698f48298d3SIoana Ciornei return err; 1699f48298d3SIoana Ciornei 1700f48298d3SIoana Ciornei port_priv->ethsw_data->vlans[vlan->vid] |= ETHSW_VLAN_GLOBAL; 1701f48298d3SIoana Ciornei } 1702f48298d3SIoana Ciornei 1703f48298d3SIoana Ciornei return dpaa2_switch_port_add_vlan(port_priv, vlan->vid, vlan->flags); 1704f48298d3SIoana Ciornei } 1705f48298d3SIoana Ciornei 1706f48298d3SIoana Ciornei static int dpaa2_switch_port_lookup_address(struct net_device *netdev, int is_uc, 1707f48298d3SIoana Ciornei const unsigned char *addr) 1708f48298d3SIoana Ciornei { 1709f48298d3SIoana Ciornei struct netdev_hw_addr_list *list = (is_uc) ? &netdev->uc : &netdev->mc; 1710f48298d3SIoana Ciornei struct netdev_hw_addr *ha; 1711f48298d3SIoana Ciornei 1712f48298d3SIoana Ciornei netif_addr_lock_bh(netdev); 1713f48298d3SIoana Ciornei list_for_each_entry(ha, &list->list, list) { 1714f48298d3SIoana Ciornei if (ether_addr_equal(ha->addr, addr)) { 1715f48298d3SIoana Ciornei netif_addr_unlock_bh(netdev); 1716f48298d3SIoana Ciornei return 1; 1717f48298d3SIoana Ciornei } 1718f48298d3SIoana Ciornei } 1719f48298d3SIoana Ciornei netif_addr_unlock_bh(netdev); 1720f48298d3SIoana Ciornei return 0; 1721f48298d3SIoana Ciornei } 1722f48298d3SIoana Ciornei 1723f48298d3SIoana Ciornei static int dpaa2_switch_port_mdb_add(struct net_device *netdev, 1724f48298d3SIoana Ciornei const struct switchdev_obj_port_mdb *mdb) 1725f48298d3SIoana Ciornei { 1726f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1727f48298d3SIoana Ciornei int err; 1728f48298d3SIoana Ciornei 1729f48298d3SIoana Ciornei /* Check if address is already set on this port */ 1730f48298d3SIoana Ciornei if (dpaa2_switch_port_lookup_address(netdev, 0, mdb->addr)) 1731f48298d3SIoana Ciornei return -EEXIST; 1732f48298d3SIoana Ciornei 1733f48298d3SIoana Ciornei err = dpaa2_switch_port_fdb_add_mc(port_priv, mdb->addr); 1734f48298d3SIoana Ciornei if (err) 1735f48298d3SIoana Ciornei return err; 1736f48298d3SIoana Ciornei 1737f48298d3SIoana Ciornei err = dev_mc_add(netdev, mdb->addr); 1738f48298d3SIoana Ciornei if (err) { 1739f48298d3SIoana Ciornei netdev_err(netdev, "dev_mc_add err %d\n", err); 1740f48298d3SIoana Ciornei dpaa2_switch_port_fdb_del_mc(port_priv, mdb->addr); 1741f48298d3SIoana Ciornei } 1742f48298d3SIoana Ciornei 1743f48298d3SIoana Ciornei return err; 1744f48298d3SIoana Ciornei } 1745f48298d3SIoana Ciornei 1746f48298d3SIoana Ciornei static int dpaa2_switch_port_obj_add(struct net_device *netdev, 1747f48298d3SIoana Ciornei const struct switchdev_obj *obj) 1748f48298d3SIoana Ciornei { 1749f48298d3SIoana Ciornei int err; 1750f48298d3SIoana Ciornei 1751f48298d3SIoana Ciornei switch (obj->id) { 1752f48298d3SIoana Ciornei case SWITCHDEV_OBJ_ID_PORT_VLAN: 1753f48298d3SIoana Ciornei err = dpaa2_switch_port_vlans_add(netdev, 1754f48298d3SIoana Ciornei SWITCHDEV_OBJ_PORT_VLAN(obj)); 1755f48298d3SIoana Ciornei break; 1756f48298d3SIoana Ciornei case SWITCHDEV_OBJ_ID_PORT_MDB: 1757f48298d3SIoana Ciornei err = dpaa2_switch_port_mdb_add(netdev, 1758f48298d3SIoana Ciornei SWITCHDEV_OBJ_PORT_MDB(obj)); 1759f48298d3SIoana Ciornei break; 1760f48298d3SIoana Ciornei default: 1761f48298d3SIoana Ciornei err = -EOPNOTSUPP; 1762f48298d3SIoana Ciornei break; 1763f48298d3SIoana Ciornei } 1764f48298d3SIoana Ciornei 1765f48298d3SIoana Ciornei return err; 1766f48298d3SIoana Ciornei } 1767f48298d3SIoana Ciornei 1768f48298d3SIoana Ciornei static int dpaa2_switch_port_del_vlan(struct ethsw_port_priv *port_priv, u16 vid) 1769f48298d3SIoana Ciornei { 1770f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 1771f48298d3SIoana Ciornei struct net_device *netdev = port_priv->netdev; 1772f48298d3SIoana Ciornei struct dpsw_vlan_if_cfg vcfg; 1773f48298d3SIoana Ciornei int i, err; 1774f48298d3SIoana Ciornei 1775f48298d3SIoana Ciornei if (!port_priv->vlans[vid]) 1776f48298d3SIoana Ciornei return -ENOENT; 1777f48298d3SIoana Ciornei 1778f48298d3SIoana Ciornei if (port_priv->vlans[vid] & ETHSW_VLAN_PVID) { 1779f48298d3SIoana Ciornei /* If we are deleting the PVID of a port, use VLAN 4095 instead 1780f48298d3SIoana Ciornei * as we are sure that neither the bridge nor the 8021q module 1781f48298d3SIoana Ciornei * will use it 1782f48298d3SIoana Ciornei */ 1783f48298d3SIoana Ciornei err = dpaa2_switch_port_set_pvid(port_priv, 4095); 1784f48298d3SIoana Ciornei if (err) 1785f48298d3SIoana Ciornei return err; 1786f48298d3SIoana Ciornei } 1787f48298d3SIoana Ciornei 1788f48298d3SIoana Ciornei vcfg.num_ifs = 1; 1789f48298d3SIoana Ciornei vcfg.if_id[0] = port_priv->idx; 1790f48298d3SIoana Ciornei if (port_priv->vlans[vid] & ETHSW_VLAN_UNTAGGED) { 1791f48298d3SIoana Ciornei err = dpsw_vlan_remove_if_untagged(ethsw->mc_io, 0, 1792f48298d3SIoana Ciornei ethsw->dpsw_handle, 1793f48298d3SIoana Ciornei vid, &vcfg); 1794f48298d3SIoana Ciornei if (err) { 1795f48298d3SIoana Ciornei netdev_err(netdev, 1796f48298d3SIoana Ciornei "dpsw_vlan_remove_if_untagged err %d\n", 1797f48298d3SIoana Ciornei err); 1798f48298d3SIoana Ciornei } 1799f48298d3SIoana Ciornei port_priv->vlans[vid] &= ~ETHSW_VLAN_UNTAGGED; 1800f48298d3SIoana Ciornei } 1801f48298d3SIoana Ciornei 1802f48298d3SIoana Ciornei if (port_priv->vlans[vid] & ETHSW_VLAN_MEMBER) { 1803f48298d3SIoana Ciornei err = dpsw_vlan_remove_if(ethsw->mc_io, 0, ethsw->dpsw_handle, 1804f48298d3SIoana Ciornei vid, &vcfg); 1805f48298d3SIoana Ciornei if (err) { 1806f48298d3SIoana Ciornei netdev_err(netdev, 1807f48298d3SIoana Ciornei "dpsw_vlan_remove_if err %d\n", err); 1808f48298d3SIoana Ciornei return err; 1809f48298d3SIoana Ciornei } 1810f48298d3SIoana Ciornei port_priv->vlans[vid] &= ~ETHSW_VLAN_MEMBER; 1811f48298d3SIoana Ciornei 1812f48298d3SIoana Ciornei /* Delete VLAN from switch if it is no longer configured on 1813f48298d3SIoana Ciornei * any port 1814f48298d3SIoana Ciornei */ 1815f48298d3SIoana Ciornei for (i = 0; i < ethsw->sw_attr.num_ifs; i++) 1816f48298d3SIoana Ciornei if (ethsw->ports[i]->vlans[vid] & ETHSW_VLAN_MEMBER) 1817f48298d3SIoana Ciornei return 0; /* Found a port member in VID */ 1818f48298d3SIoana Ciornei 1819f48298d3SIoana Ciornei ethsw->vlans[vid] &= ~ETHSW_VLAN_GLOBAL; 1820f48298d3SIoana Ciornei 1821f48298d3SIoana Ciornei err = dpaa2_switch_dellink(ethsw, vid); 1822f48298d3SIoana Ciornei if (err) 1823f48298d3SIoana Ciornei return err; 1824f48298d3SIoana Ciornei } 1825f48298d3SIoana Ciornei 1826f48298d3SIoana Ciornei return 0; 1827f48298d3SIoana Ciornei } 1828f48298d3SIoana Ciornei 1829f48298d3SIoana Ciornei int dpaa2_switch_port_vlans_del(struct net_device *netdev, 1830f48298d3SIoana Ciornei const struct switchdev_obj_port_vlan *vlan) 1831f48298d3SIoana Ciornei { 1832f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1833f48298d3SIoana Ciornei 1834f48298d3SIoana Ciornei if (netif_is_bridge_master(vlan->obj.orig_dev)) 1835f48298d3SIoana Ciornei return -EOPNOTSUPP; 1836f48298d3SIoana Ciornei 1837f48298d3SIoana Ciornei return dpaa2_switch_port_del_vlan(port_priv, vlan->vid); 1838f48298d3SIoana Ciornei } 1839f48298d3SIoana Ciornei 1840f48298d3SIoana Ciornei static int dpaa2_switch_port_mdb_del(struct net_device *netdev, 1841f48298d3SIoana Ciornei const struct switchdev_obj_port_mdb *mdb) 1842f48298d3SIoana Ciornei { 1843f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1844f48298d3SIoana Ciornei int err; 1845f48298d3SIoana Ciornei 1846f48298d3SIoana Ciornei if (!dpaa2_switch_port_lookup_address(netdev, 0, mdb->addr)) 1847f48298d3SIoana Ciornei return -ENOENT; 1848f48298d3SIoana Ciornei 1849f48298d3SIoana Ciornei err = dpaa2_switch_port_fdb_del_mc(port_priv, mdb->addr); 1850f48298d3SIoana Ciornei if (err) 1851f48298d3SIoana Ciornei return err; 1852f48298d3SIoana Ciornei 1853f48298d3SIoana Ciornei err = dev_mc_del(netdev, mdb->addr); 1854f48298d3SIoana Ciornei if (err) { 1855f48298d3SIoana Ciornei netdev_err(netdev, "dev_mc_del err %d\n", err); 1856f48298d3SIoana Ciornei return err; 1857f48298d3SIoana Ciornei } 1858f48298d3SIoana Ciornei 1859f48298d3SIoana Ciornei return err; 1860f48298d3SIoana Ciornei } 1861f48298d3SIoana Ciornei 1862f48298d3SIoana Ciornei static int dpaa2_switch_port_obj_del(struct net_device *netdev, 1863f48298d3SIoana Ciornei const struct switchdev_obj *obj) 1864f48298d3SIoana Ciornei { 1865f48298d3SIoana Ciornei int err; 1866f48298d3SIoana Ciornei 1867f48298d3SIoana Ciornei switch (obj->id) { 1868f48298d3SIoana Ciornei case SWITCHDEV_OBJ_ID_PORT_VLAN: 1869f48298d3SIoana Ciornei err = dpaa2_switch_port_vlans_del(netdev, SWITCHDEV_OBJ_PORT_VLAN(obj)); 1870f48298d3SIoana Ciornei break; 1871f48298d3SIoana Ciornei case SWITCHDEV_OBJ_ID_PORT_MDB: 1872f48298d3SIoana Ciornei err = dpaa2_switch_port_mdb_del(netdev, SWITCHDEV_OBJ_PORT_MDB(obj)); 1873f48298d3SIoana Ciornei break; 1874f48298d3SIoana Ciornei default: 1875f48298d3SIoana Ciornei err = -EOPNOTSUPP; 1876f48298d3SIoana Ciornei break; 1877f48298d3SIoana Ciornei } 1878f48298d3SIoana Ciornei return err; 1879f48298d3SIoana Ciornei } 1880f48298d3SIoana Ciornei 1881f48298d3SIoana Ciornei static int dpaa2_switch_port_attr_set_event(struct net_device *netdev, 1882f48298d3SIoana Ciornei struct switchdev_notifier_port_attr_info *ptr) 1883f48298d3SIoana Ciornei { 1884f48298d3SIoana Ciornei int err; 1885f48298d3SIoana Ciornei 1886f48298d3SIoana Ciornei err = switchdev_handle_port_attr_set(netdev, ptr, 1887f48298d3SIoana Ciornei dpaa2_switch_port_dev_check, 1888f48298d3SIoana Ciornei dpaa2_switch_port_attr_set); 1889f48298d3SIoana Ciornei return notifier_from_errno(err); 1890f48298d3SIoana Ciornei } 1891f48298d3SIoana Ciornei 1892f48298d3SIoana Ciornei static int dpaa2_switch_port_bridge_join(struct net_device *netdev, 1893f48298d3SIoana Ciornei struct net_device *upper_dev) 1894f48298d3SIoana Ciornei { 1895f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1896f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 1897f48298d3SIoana Ciornei struct ethsw_port_priv *other_port_priv; 1898f48298d3SIoana Ciornei struct net_device *other_dev; 1899f48298d3SIoana Ciornei struct list_head *iter; 19001e7cbabfSIoana Ciornei bool learn_ena; 1901f48298d3SIoana Ciornei int err; 1902f48298d3SIoana Ciornei 1903f48298d3SIoana Ciornei netdev_for_each_lower_dev(upper_dev, other_dev, iter) { 1904f48298d3SIoana Ciornei if (!dpaa2_switch_port_dev_check(other_dev)) 1905f48298d3SIoana Ciornei continue; 1906f48298d3SIoana Ciornei 1907f48298d3SIoana Ciornei other_port_priv = netdev_priv(other_dev); 1908f48298d3SIoana Ciornei if (other_port_priv->ethsw_data != port_priv->ethsw_data) { 1909f48298d3SIoana Ciornei netdev_err(netdev, 1910f48298d3SIoana Ciornei "Interface from a different DPSW is in the bridge already!\n"); 1911f48298d3SIoana Ciornei return -EINVAL; 1912f48298d3SIoana Ciornei } 1913f48298d3SIoana Ciornei } 1914f48298d3SIoana Ciornei 1915f48298d3SIoana Ciornei /* Delete the previously manually installed VLAN 1 */ 1916f48298d3SIoana Ciornei err = dpaa2_switch_port_del_vlan(port_priv, 1); 1917f48298d3SIoana Ciornei if (err) 1918f48298d3SIoana Ciornei return err; 1919f48298d3SIoana Ciornei 1920f48298d3SIoana Ciornei dpaa2_switch_port_set_fdb(port_priv, upper_dev); 1921f48298d3SIoana Ciornei 19221e7cbabfSIoana Ciornei /* Inherit the initial bridge port learning state */ 19231e7cbabfSIoana Ciornei learn_ena = br_port_flag_is_set(netdev, BR_LEARNING); 19241e7cbabfSIoana Ciornei err = dpaa2_switch_port_set_learning(port_priv, learn_ena); 192562734c74SIoana Ciornei port_priv->learn_ena = learn_ena; 19261e7cbabfSIoana Ciornei 1927f48298d3SIoana Ciornei /* Setup the egress flood policy (broadcast, unknown unicast) */ 1928f48298d3SIoana Ciornei err = dpaa2_switch_fdb_set_egress_flood(ethsw, port_priv->fdb->fdb_id); 1929f48298d3SIoana Ciornei if (err) 1930f48298d3SIoana Ciornei goto err_egress_flood; 1931f48298d3SIoana Ciornei 1932f48298d3SIoana Ciornei return 0; 1933f48298d3SIoana Ciornei 1934f48298d3SIoana Ciornei err_egress_flood: 1935f48298d3SIoana Ciornei dpaa2_switch_port_set_fdb(port_priv, NULL); 1936f48298d3SIoana Ciornei return err; 1937f48298d3SIoana Ciornei } 1938f48298d3SIoana Ciornei 1939f48298d3SIoana Ciornei static int dpaa2_switch_port_clear_rxvlan(struct net_device *vdev, int vid, void *arg) 1940f48298d3SIoana Ciornei { 1941f48298d3SIoana Ciornei __be16 vlan_proto = htons(ETH_P_8021Q); 1942f48298d3SIoana Ciornei 1943f48298d3SIoana Ciornei if (vdev) 1944f48298d3SIoana Ciornei vlan_proto = vlan_dev_vlan_proto(vdev); 1945f48298d3SIoana Ciornei 1946f48298d3SIoana Ciornei return dpaa2_switch_port_vlan_kill(arg, vlan_proto, vid); 1947f48298d3SIoana Ciornei } 1948f48298d3SIoana Ciornei 1949f48298d3SIoana Ciornei static int dpaa2_switch_port_restore_rxvlan(struct net_device *vdev, int vid, void *arg) 1950f48298d3SIoana Ciornei { 1951f48298d3SIoana Ciornei __be16 vlan_proto = htons(ETH_P_8021Q); 1952f48298d3SIoana Ciornei 1953f48298d3SIoana Ciornei if (vdev) 1954f48298d3SIoana Ciornei vlan_proto = vlan_dev_vlan_proto(vdev); 1955f48298d3SIoana Ciornei 1956f48298d3SIoana Ciornei return dpaa2_switch_port_vlan_add(arg, vlan_proto, vid); 1957f48298d3SIoana Ciornei } 1958f48298d3SIoana Ciornei 1959f48298d3SIoana Ciornei static int dpaa2_switch_port_bridge_leave(struct net_device *netdev) 1960f48298d3SIoana Ciornei { 1961f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(netdev); 1962f48298d3SIoana Ciornei struct dpaa2_switch_fdb *old_fdb = port_priv->fdb; 1963f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 1964f48298d3SIoana Ciornei int err; 1965f48298d3SIoana Ciornei 1966f48298d3SIoana Ciornei /* First of all, fast age any learn FDB addresses on this switch port */ 1967f48298d3SIoana Ciornei dpaa2_switch_port_fast_age(port_priv); 1968f48298d3SIoana Ciornei 1969f48298d3SIoana Ciornei /* Clear all RX VLANs installed through vlan_vid_add() either as VLAN 1970f48298d3SIoana Ciornei * upper devices or otherwise from the FDB table that we are about to 1971f48298d3SIoana Ciornei * leave 1972f48298d3SIoana Ciornei */ 1973f48298d3SIoana Ciornei err = vlan_for_each(netdev, dpaa2_switch_port_clear_rxvlan, netdev); 1974f48298d3SIoana Ciornei if (err) 1975f48298d3SIoana Ciornei netdev_err(netdev, "Unable to clear RX VLANs from old FDB table, err (%d)\n", err); 1976f48298d3SIoana Ciornei 1977f48298d3SIoana Ciornei dpaa2_switch_port_set_fdb(port_priv, NULL); 1978f48298d3SIoana Ciornei 1979f48298d3SIoana Ciornei /* Restore all RX VLANs into the new FDB table that we just joined */ 1980f48298d3SIoana Ciornei err = vlan_for_each(netdev, dpaa2_switch_port_restore_rxvlan, netdev); 1981f48298d3SIoana Ciornei if (err) 1982f48298d3SIoana Ciornei netdev_err(netdev, "Unable to restore RX VLANs to the new FDB, err (%d)\n", err); 1983f48298d3SIoana Ciornei 1984b54eb093SIoana Ciornei /* Reset the flooding state to denote that this port can send any 1985b54eb093SIoana Ciornei * packet in standalone mode. With this, we are also ensuring that any 1986b54eb093SIoana Ciornei * later bridge join will have the flooding flag on. 1987b54eb093SIoana Ciornei */ 1988b54eb093SIoana Ciornei port_priv->bcast_flood = true; 19896253d5e3SIoana Ciornei port_priv->ucast_flood = true; 1990b54eb093SIoana Ciornei 1991f48298d3SIoana Ciornei /* Setup the egress flood policy (broadcast, unknown unicast). 1992f48298d3SIoana Ciornei * When the port is not under a bridge, only the CTRL interface is part 1993f48298d3SIoana Ciornei * of the flooding domain besides the actual port 1994f48298d3SIoana Ciornei */ 1995f48298d3SIoana Ciornei err = dpaa2_switch_fdb_set_egress_flood(ethsw, port_priv->fdb->fdb_id); 1996f48298d3SIoana Ciornei if (err) 1997f48298d3SIoana Ciornei return err; 1998f48298d3SIoana Ciornei 1999f48298d3SIoana Ciornei /* Recreate the egress flood domain of the FDB that we just left */ 2000f48298d3SIoana Ciornei err = dpaa2_switch_fdb_set_egress_flood(ethsw, old_fdb->fdb_id); 2001f48298d3SIoana Ciornei if (err) 2002f48298d3SIoana Ciornei return err; 2003f48298d3SIoana Ciornei 20041e7cbabfSIoana Ciornei /* No HW learning when not under a bridge */ 20051e7cbabfSIoana Ciornei err = dpaa2_switch_port_set_learning(port_priv, false); 20061e7cbabfSIoana Ciornei if (err) 20071e7cbabfSIoana Ciornei return err; 200862734c74SIoana Ciornei port_priv->learn_ena = false; 20091e7cbabfSIoana Ciornei 2010f48298d3SIoana Ciornei /* Add the VLAN 1 as PVID when not under a bridge. We need this since 2011f48298d3SIoana Ciornei * the dpaa2 switch interfaces are not capable to be VLAN unaware 2012f48298d3SIoana Ciornei */ 2013f48298d3SIoana Ciornei return dpaa2_switch_port_add_vlan(port_priv, DEFAULT_VLAN_ID, 2014f48298d3SIoana Ciornei BRIDGE_VLAN_INFO_UNTAGGED | BRIDGE_VLAN_INFO_PVID); 2015f48298d3SIoana Ciornei } 2016f48298d3SIoana Ciornei 2017f48298d3SIoana Ciornei static int dpaa2_switch_prevent_bridging_with_8021q_upper(struct net_device *netdev) 2018f48298d3SIoana Ciornei { 2019f48298d3SIoana Ciornei struct net_device *upper_dev; 2020f48298d3SIoana Ciornei struct list_head *iter; 2021f48298d3SIoana Ciornei 2022f48298d3SIoana Ciornei /* RCU read lock not necessary because we have write-side protection 2023f48298d3SIoana Ciornei * (rtnl_mutex), however a non-rcu iterator does not exist. 2024f48298d3SIoana Ciornei */ 2025f48298d3SIoana Ciornei netdev_for_each_upper_dev_rcu(netdev, upper_dev, iter) 2026f48298d3SIoana Ciornei if (is_vlan_dev(upper_dev)) 2027f48298d3SIoana Ciornei return -EOPNOTSUPP; 2028f48298d3SIoana Ciornei 2029f48298d3SIoana Ciornei return 0; 2030f48298d3SIoana Ciornei } 2031f48298d3SIoana Ciornei 2032f48298d3SIoana Ciornei static int dpaa2_switch_port_netdevice_event(struct notifier_block *nb, 2033f48298d3SIoana Ciornei unsigned long event, void *ptr) 2034f48298d3SIoana Ciornei { 2035f48298d3SIoana Ciornei struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 2036f48298d3SIoana Ciornei struct netdev_notifier_changeupper_info *info = ptr; 2037f48298d3SIoana Ciornei struct netlink_ext_ack *extack; 2038f48298d3SIoana Ciornei struct net_device *upper_dev; 2039f48298d3SIoana Ciornei int err = 0; 2040f48298d3SIoana Ciornei 2041f48298d3SIoana Ciornei if (!dpaa2_switch_port_dev_check(netdev)) 2042f48298d3SIoana Ciornei return NOTIFY_DONE; 2043f48298d3SIoana Ciornei 2044f48298d3SIoana Ciornei extack = netdev_notifier_info_to_extack(&info->info); 2045f48298d3SIoana Ciornei 2046f48298d3SIoana Ciornei switch (event) { 2047f48298d3SIoana Ciornei case NETDEV_PRECHANGEUPPER: 2048f48298d3SIoana Ciornei upper_dev = info->upper_dev; 2049f48298d3SIoana Ciornei if (!netif_is_bridge_master(upper_dev)) 2050f48298d3SIoana Ciornei break; 2051f48298d3SIoana Ciornei 2052f48298d3SIoana Ciornei if (!br_vlan_enabled(upper_dev)) { 2053f48298d3SIoana Ciornei NL_SET_ERR_MSG_MOD(extack, "Cannot join a VLAN-unaware bridge"); 2054f48298d3SIoana Ciornei err = -EOPNOTSUPP; 2055f48298d3SIoana Ciornei goto out; 2056f48298d3SIoana Ciornei } 2057f48298d3SIoana Ciornei 2058f48298d3SIoana Ciornei err = dpaa2_switch_prevent_bridging_with_8021q_upper(netdev); 2059f48298d3SIoana Ciornei if (err) { 2060f48298d3SIoana Ciornei NL_SET_ERR_MSG_MOD(extack, 2061f48298d3SIoana Ciornei "Cannot join a bridge while VLAN uppers are present"); 2062f48298d3SIoana Ciornei goto out; 2063f48298d3SIoana Ciornei } 2064f48298d3SIoana Ciornei 2065f48298d3SIoana Ciornei break; 2066f48298d3SIoana Ciornei case NETDEV_CHANGEUPPER: 2067f48298d3SIoana Ciornei upper_dev = info->upper_dev; 2068f48298d3SIoana Ciornei if (netif_is_bridge_master(upper_dev)) { 2069f48298d3SIoana Ciornei if (info->linking) 2070f48298d3SIoana Ciornei err = dpaa2_switch_port_bridge_join(netdev, upper_dev); 2071f48298d3SIoana Ciornei else 2072f48298d3SIoana Ciornei err = dpaa2_switch_port_bridge_leave(netdev); 2073f48298d3SIoana Ciornei } 2074f48298d3SIoana Ciornei break; 2075f48298d3SIoana Ciornei } 2076f48298d3SIoana Ciornei 2077f48298d3SIoana Ciornei out: 2078f48298d3SIoana Ciornei return notifier_from_errno(err); 2079f48298d3SIoana Ciornei } 2080f48298d3SIoana Ciornei 2081f48298d3SIoana Ciornei struct ethsw_switchdev_event_work { 2082f48298d3SIoana Ciornei struct work_struct work; 2083f48298d3SIoana Ciornei struct switchdev_notifier_fdb_info fdb_info; 2084f48298d3SIoana Ciornei struct net_device *dev; 2085f48298d3SIoana Ciornei unsigned long event; 2086f48298d3SIoana Ciornei }; 2087f48298d3SIoana Ciornei 2088f48298d3SIoana Ciornei static void dpaa2_switch_event_work(struct work_struct *work) 2089f48298d3SIoana Ciornei { 2090f48298d3SIoana Ciornei struct ethsw_switchdev_event_work *switchdev_work = 2091f48298d3SIoana Ciornei container_of(work, struct ethsw_switchdev_event_work, work); 2092f48298d3SIoana Ciornei struct net_device *dev = switchdev_work->dev; 2093f48298d3SIoana Ciornei struct switchdev_notifier_fdb_info *fdb_info; 2094f48298d3SIoana Ciornei int err; 2095f48298d3SIoana Ciornei 2096f48298d3SIoana Ciornei rtnl_lock(); 2097f48298d3SIoana Ciornei fdb_info = &switchdev_work->fdb_info; 2098f48298d3SIoana Ciornei 2099f48298d3SIoana Ciornei switch (switchdev_work->event) { 2100f48298d3SIoana Ciornei case SWITCHDEV_FDB_ADD_TO_DEVICE: 21012c4eca3eSVladimir Oltean if (!fdb_info->added_by_user || fdb_info->is_local) 2102f48298d3SIoana Ciornei break; 2103f48298d3SIoana Ciornei if (is_unicast_ether_addr(fdb_info->addr)) 2104f48298d3SIoana Ciornei err = dpaa2_switch_port_fdb_add_uc(netdev_priv(dev), 2105f48298d3SIoana Ciornei fdb_info->addr); 2106f48298d3SIoana Ciornei else 2107f48298d3SIoana Ciornei err = dpaa2_switch_port_fdb_add_mc(netdev_priv(dev), 2108f48298d3SIoana Ciornei fdb_info->addr); 2109f48298d3SIoana Ciornei if (err) 2110f48298d3SIoana Ciornei break; 2111f48298d3SIoana Ciornei fdb_info->offloaded = true; 2112f48298d3SIoana Ciornei call_switchdev_notifiers(SWITCHDEV_FDB_OFFLOADED, dev, 2113f48298d3SIoana Ciornei &fdb_info->info, NULL); 2114f48298d3SIoana Ciornei break; 2115f48298d3SIoana Ciornei case SWITCHDEV_FDB_DEL_TO_DEVICE: 21162c4eca3eSVladimir Oltean if (!fdb_info->added_by_user || fdb_info->is_local) 2117f48298d3SIoana Ciornei break; 2118f48298d3SIoana Ciornei if (is_unicast_ether_addr(fdb_info->addr)) 2119f48298d3SIoana Ciornei dpaa2_switch_port_fdb_del_uc(netdev_priv(dev), fdb_info->addr); 2120f48298d3SIoana Ciornei else 2121f48298d3SIoana Ciornei dpaa2_switch_port_fdb_del_mc(netdev_priv(dev), fdb_info->addr); 2122f48298d3SIoana Ciornei break; 2123f48298d3SIoana Ciornei } 2124f48298d3SIoana Ciornei 2125f48298d3SIoana Ciornei rtnl_unlock(); 2126f48298d3SIoana Ciornei kfree(switchdev_work->fdb_info.addr); 2127f48298d3SIoana Ciornei kfree(switchdev_work); 2128f48298d3SIoana Ciornei dev_put(dev); 2129f48298d3SIoana Ciornei } 2130f48298d3SIoana Ciornei 2131f48298d3SIoana Ciornei /* Called under rcu_read_lock() */ 2132f48298d3SIoana Ciornei static int dpaa2_switch_port_event(struct notifier_block *nb, 2133f48298d3SIoana Ciornei unsigned long event, void *ptr) 2134f48298d3SIoana Ciornei { 2135f48298d3SIoana Ciornei struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 2136f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv = netdev_priv(dev); 2137f48298d3SIoana Ciornei struct ethsw_switchdev_event_work *switchdev_work; 2138f48298d3SIoana Ciornei struct switchdev_notifier_fdb_info *fdb_info = ptr; 2139f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 2140f48298d3SIoana Ciornei 2141f48298d3SIoana Ciornei if (event == SWITCHDEV_PORT_ATTR_SET) 2142f48298d3SIoana Ciornei return dpaa2_switch_port_attr_set_event(dev, ptr); 2143f48298d3SIoana Ciornei 2144f48298d3SIoana Ciornei if (!dpaa2_switch_port_dev_check(dev)) 2145f48298d3SIoana Ciornei return NOTIFY_DONE; 2146f48298d3SIoana Ciornei 2147f48298d3SIoana Ciornei switchdev_work = kzalloc(sizeof(*switchdev_work), GFP_ATOMIC); 2148f48298d3SIoana Ciornei if (!switchdev_work) 2149f48298d3SIoana Ciornei return NOTIFY_BAD; 2150f48298d3SIoana Ciornei 2151f48298d3SIoana Ciornei INIT_WORK(&switchdev_work->work, dpaa2_switch_event_work); 2152f48298d3SIoana Ciornei switchdev_work->dev = dev; 2153f48298d3SIoana Ciornei switchdev_work->event = event; 2154f48298d3SIoana Ciornei 2155f48298d3SIoana Ciornei switch (event) { 2156f48298d3SIoana Ciornei case SWITCHDEV_FDB_ADD_TO_DEVICE: 2157f48298d3SIoana Ciornei case SWITCHDEV_FDB_DEL_TO_DEVICE: 2158f48298d3SIoana Ciornei memcpy(&switchdev_work->fdb_info, ptr, 2159f48298d3SIoana Ciornei sizeof(switchdev_work->fdb_info)); 2160f48298d3SIoana Ciornei switchdev_work->fdb_info.addr = kzalloc(ETH_ALEN, GFP_ATOMIC); 2161f48298d3SIoana Ciornei if (!switchdev_work->fdb_info.addr) 2162f48298d3SIoana Ciornei goto err_addr_alloc; 2163f48298d3SIoana Ciornei 2164f48298d3SIoana Ciornei ether_addr_copy((u8 *)switchdev_work->fdb_info.addr, 2165f48298d3SIoana Ciornei fdb_info->addr); 2166f48298d3SIoana Ciornei 2167f48298d3SIoana Ciornei /* Take a reference on the device to avoid being freed. */ 2168f48298d3SIoana Ciornei dev_hold(dev); 2169f48298d3SIoana Ciornei break; 2170f48298d3SIoana Ciornei default: 2171f48298d3SIoana Ciornei kfree(switchdev_work); 2172f48298d3SIoana Ciornei return NOTIFY_DONE; 2173f48298d3SIoana Ciornei } 2174f48298d3SIoana Ciornei 2175f48298d3SIoana Ciornei queue_work(ethsw->workqueue, &switchdev_work->work); 2176f48298d3SIoana Ciornei 2177f48298d3SIoana Ciornei return NOTIFY_DONE; 2178f48298d3SIoana Ciornei 2179f48298d3SIoana Ciornei err_addr_alloc: 2180f48298d3SIoana Ciornei kfree(switchdev_work); 2181f48298d3SIoana Ciornei return NOTIFY_BAD; 2182f48298d3SIoana Ciornei } 2183f48298d3SIoana Ciornei 2184f48298d3SIoana Ciornei static int dpaa2_switch_port_obj_event(unsigned long event, 2185f48298d3SIoana Ciornei struct net_device *netdev, 2186f48298d3SIoana Ciornei struct switchdev_notifier_port_obj_info *port_obj_info) 2187f48298d3SIoana Ciornei { 2188f48298d3SIoana Ciornei int err = -EOPNOTSUPP; 2189f48298d3SIoana Ciornei 2190f48298d3SIoana Ciornei if (!dpaa2_switch_port_dev_check(netdev)) 2191f48298d3SIoana Ciornei return NOTIFY_DONE; 2192f48298d3SIoana Ciornei 2193f48298d3SIoana Ciornei switch (event) { 2194f48298d3SIoana Ciornei case SWITCHDEV_PORT_OBJ_ADD: 2195f48298d3SIoana Ciornei err = dpaa2_switch_port_obj_add(netdev, port_obj_info->obj); 2196f48298d3SIoana Ciornei break; 2197f48298d3SIoana Ciornei case SWITCHDEV_PORT_OBJ_DEL: 2198f48298d3SIoana Ciornei err = dpaa2_switch_port_obj_del(netdev, port_obj_info->obj); 2199f48298d3SIoana Ciornei break; 2200f48298d3SIoana Ciornei } 2201f48298d3SIoana Ciornei 2202f48298d3SIoana Ciornei port_obj_info->handled = true; 2203f48298d3SIoana Ciornei return notifier_from_errno(err); 2204f48298d3SIoana Ciornei } 2205f48298d3SIoana Ciornei 2206f48298d3SIoana Ciornei static int dpaa2_switch_port_blocking_event(struct notifier_block *nb, 2207f48298d3SIoana Ciornei unsigned long event, void *ptr) 2208f48298d3SIoana Ciornei { 2209f48298d3SIoana Ciornei struct net_device *dev = switchdev_notifier_info_to_dev(ptr); 2210f48298d3SIoana Ciornei 2211f48298d3SIoana Ciornei switch (event) { 2212f48298d3SIoana Ciornei case SWITCHDEV_PORT_OBJ_ADD: 2213f48298d3SIoana Ciornei case SWITCHDEV_PORT_OBJ_DEL: 2214f48298d3SIoana Ciornei return dpaa2_switch_port_obj_event(event, dev, ptr); 2215f48298d3SIoana Ciornei case SWITCHDEV_PORT_ATTR_SET: 2216f48298d3SIoana Ciornei return dpaa2_switch_port_attr_set_event(dev, ptr); 2217f48298d3SIoana Ciornei } 2218f48298d3SIoana Ciornei 2219f48298d3SIoana Ciornei return NOTIFY_DONE; 2220f48298d3SIoana Ciornei } 2221f48298d3SIoana Ciornei 2222f48298d3SIoana Ciornei /* Build a linear skb based on a single-buffer frame descriptor */ 2223f48298d3SIoana Ciornei static struct sk_buff *dpaa2_switch_build_linear_skb(struct ethsw_core *ethsw, 2224f48298d3SIoana Ciornei const struct dpaa2_fd *fd) 2225f48298d3SIoana Ciornei { 2226f48298d3SIoana Ciornei u16 fd_offset = dpaa2_fd_get_offset(fd); 2227f48298d3SIoana Ciornei dma_addr_t addr = dpaa2_fd_get_addr(fd); 2228f48298d3SIoana Ciornei u32 fd_length = dpaa2_fd_get_len(fd); 2229f48298d3SIoana Ciornei struct device *dev = ethsw->dev; 2230f48298d3SIoana Ciornei struct sk_buff *skb = NULL; 2231f48298d3SIoana Ciornei void *fd_vaddr; 2232f48298d3SIoana Ciornei 2233f48298d3SIoana Ciornei fd_vaddr = dpaa2_iova_to_virt(ethsw->iommu_domain, addr); 2234f48298d3SIoana Ciornei dma_unmap_page(dev, addr, DPAA2_SWITCH_RX_BUF_SIZE, 2235f48298d3SIoana Ciornei DMA_FROM_DEVICE); 2236f48298d3SIoana Ciornei 2237f48298d3SIoana Ciornei skb = build_skb(fd_vaddr, DPAA2_SWITCH_RX_BUF_SIZE + 2238f48298d3SIoana Ciornei SKB_DATA_ALIGN(sizeof(struct skb_shared_info))); 2239f48298d3SIoana Ciornei if (unlikely(!skb)) { 2240f48298d3SIoana Ciornei dev_err(dev, "build_skb() failed\n"); 2241f48298d3SIoana Ciornei return NULL; 2242f48298d3SIoana Ciornei } 2243f48298d3SIoana Ciornei 2244f48298d3SIoana Ciornei skb_reserve(skb, fd_offset); 2245f48298d3SIoana Ciornei skb_put(skb, fd_length); 2246f48298d3SIoana Ciornei 2247f48298d3SIoana Ciornei ethsw->buf_count--; 2248f48298d3SIoana Ciornei 2249f48298d3SIoana Ciornei return skb; 2250f48298d3SIoana Ciornei } 2251f48298d3SIoana Ciornei 2252f48298d3SIoana Ciornei static void dpaa2_switch_tx_conf(struct dpaa2_switch_fq *fq, 2253f48298d3SIoana Ciornei const struct dpaa2_fd *fd) 2254f48298d3SIoana Ciornei { 2255f48298d3SIoana Ciornei dpaa2_switch_free_fd(fq->ethsw, fd); 2256f48298d3SIoana Ciornei } 2257f48298d3SIoana Ciornei 2258f48298d3SIoana Ciornei static void dpaa2_switch_rx(struct dpaa2_switch_fq *fq, 2259f48298d3SIoana Ciornei const struct dpaa2_fd *fd) 2260f48298d3SIoana Ciornei { 2261f48298d3SIoana Ciornei struct ethsw_core *ethsw = fq->ethsw; 2262f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv; 2263f48298d3SIoana Ciornei struct net_device *netdev; 2264f48298d3SIoana Ciornei struct vlan_ethhdr *hdr; 2265f48298d3SIoana Ciornei struct sk_buff *skb; 2266f48298d3SIoana Ciornei u16 vlan_tci, vid; 2267f48298d3SIoana Ciornei int if_id, err; 2268f48298d3SIoana Ciornei 2269f48298d3SIoana Ciornei /* get switch ingress interface ID */ 2270f48298d3SIoana Ciornei if_id = upper_32_bits(dpaa2_fd_get_flc(fd)) & 0x0000FFFF; 2271f48298d3SIoana Ciornei 2272f48298d3SIoana Ciornei if (if_id >= ethsw->sw_attr.num_ifs) { 2273f48298d3SIoana Ciornei dev_err(ethsw->dev, "Frame received from unknown interface!\n"); 2274f48298d3SIoana Ciornei goto err_free_fd; 2275f48298d3SIoana Ciornei } 2276f48298d3SIoana Ciornei port_priv = ethsw->ports[if_id]; 2277f48298d3SIoana Ciornei netdev = port_priv->netdev; 2278f48298d3SIoana Ciornei 2279f48298d3SIoana Ciornei /* build the SKB based on the FD received */ 2280f48298d3SIoana Ciornei if (dpaa2_fd_get_format(fd) != dpaa2_fd_single) { 2281f48298d3SIoana Ciornei if (net_ratelimit()) { 2282f48298d3SIoana Ciornei netdev_err(netdev, "Received invalid frame format\n"); 2283f48298d3SIoana Ciornei goto err_free_fd; 2284f48298d3SIoana Ciornei } 2285f48298d3SIoana Ciornei } 2286f48298d3SIoana Ciornei 2287f48298d3SIoana Ciornei skb = dpaa2_switch_build_linear_skb(ethsw, fd); 2288f48298d3SIoana Ciornei if (unlikely(!skb)) 2289f48298d3SIoana Ciornei goto err_free_fd; 2290f48298d3SIoana Ciornei 2291f48298d3SIoana Ciornei skb_reset_mac_header(skb); 2292f48298d3SIoana Ciornei 2293f48298d3SIoana Ciornei /* Remove the VLAN header if the packet that we just received has a vid 2294f48298d3SIoana Ciornei * equal to the port PVIDs. Since the dpaa2-switch can operate only in 2295f48298d3SIoana Ciornei * VLAN-aware mode and no alterations are made on the packet when it's 2296f48298d3SIoana Ciornei * redirected/mirrored to the control interface, we are sure that there 2297f48298d3SIoana Ciornei * will always be a VLAN header present. 2298f48298d3SIoana Ciornei */ 2299f48298d3SIoana Ciornei hdr = vlan_eth_hdr(skb); 2300f48298d3SIoana Ciornei vid = ntohs(hdr->h_vlan_TCI) & VLAN_VID_MASK; 2301f48298d3SIoana Ciornei if (vid == port_priv->pvid) { 2302f48298d3SIoana Ciornei err = __skb_vlan_pop(skb, &vlan_tci); 2303f48298d3SIoana Ciornei if (err) { 2304f48298d3SIoana Ciornei dev_info(ethsw->dev, "__skb_vlan_pop() returned %d", err); 2305f48298d3SIoana Ciornei goto err_free_fd; 2306f48298d3SIoana Ciornei } 2307f48298d3SIoana Ciornei } 2308f48298d3SIoana Ciornei 2309f48298d3SIoana Ciornei skb->dev = netdev; 2310f48298d3SIoana Ciornei skb->protocol = eth_type_trans(skb, skb->dev); 2311f48298d3SIoana Ciornei 2312b175dfd7SIoana Ciornei /* Setup the offload_fwd_mark only if the port is under a bridge */ 2313b175dfd7SIoana Ciornei skb->offload_fwd_mark = !!(port_priv->fdb->bridge_dev); 2314b175dfd7SIoana Ciornei 2315f48298d3SIoana Ciornei netif_receive_skb(skb); 2316f48298d3SIoana Ciornei 2317f48298d3SIoana Ciornei return; 2318f48298d3SIoana Ciornei 2319f48298d3SIoana Ciornei err_free_fd: 2320f48298d3SIoana Ciornei dpaa2_switch_free_fd(ethsw, fd); 2321f48298d3SIoana Ciornei } 2322f48298d3SIoana Ciornei 2323f48298d3SIoana Ciornei static void dpaa2_switch_detect_features(struct ethsw_core *ethsw) 2324f48298d3SIoana Ciornei { 2325f48298d3SIoana Ciornei ethsw->features = 0; 2326f48298d3SIoana Ciornei 2327f48298d3SIoana Ciornei if (ethsw->major > 8 || (ethsw->major == 8 && ethsw->minor >= 6)) 2328f48298d3SIoana Ciornei ethsw->features |= ETHSW_FEATURE_MAC_ADDR; 2329f48298d3SIoana Ciornei } 2330f48298d3SIoana Ciornei 2331f48298d3SIoana Ciornei static int dpaa2_switch_setup_fqs(struct ethsw_core *ethsw) 2332f48298d3SIoana Ciornei { 2333f48298d3SIoana Ciornei struct dpsw_ctrl_if_attr ctrl_if_attr; 2334f48298d3SIoana Ciornei struct device *dev = ethsw->dev; 2335f48298d3SIoana Ciornei int i = 0; 2336f48298d3SIoana Ciornei int err; 2337f48298d3SIoana Ciornei 2338f48298d3SIoana Ciornei err = dpsw_ctrl_if_get_attributes(ethsw->mc_io, 0, ethsw->dpsw_handle, 2339f48298d3SIoana Ciornei &ctrl_if_attr); 2340f48298d3SIoana Ciornei if (err) { 2341f48298d3SIoana Ciornei dev_err(dev, "dpsw_ctrl_if_get_attributes() = %d\n", err); 2342f48298d3SIoana Ciornei return err; 2343f48298d3SIoana Ciornei } 2344f48298d3SIoana Ciornei 2345f48298d3SIoana Ciornei ethsw->fq[i].fqid = ctrl_if_attr.rx_fqid; 2346f48298d3SIoana Ciornei ethsw->fq[i].ethsw = ethsw; 2347f48298d3SIoana Ciornei ethsw->fq[i++].type = DPSW_QUEUE_RX; 2348f48298d3SIoana Ciornei 2349f48298d3SIoana Ciornei ethsw->fq[i].fqid = ctrl_if_attr.tx_err_conf_fqid; 2350f48298d3SIoana Ciornei ethsw->fq[i].ethsw = ethsw; 2351f48298d3SIoana Ciornei ethsw->fq[i++].type = DPSW_QUEUE_TX_ERR_CONF; 2352f48298d3SIoana Ciornei 2353f48298d3SIoana Ciornei return 0; 2354f48298d3SIoana Ciornei } 2355f48298d3SIoana Ciornei 2356f48298d3SIoana Ciornei /* Free buffers acquired from the buffer pool or which were meant to 2357f48298d3SIoana Ciornei * be released in the pool 2358f48298d3SIoana Ciornei */ 2359f48298d3SIoana Ciornei static void dpaa2_switch_free_bufs(struct ethsw_core *ethsw, u64 *buf_array, int count) 2360f48298d3SIoana Ciornei { 2361f48298d3SIoana Ciornei struct device *dev = ethsw->dev; 2362f48298d3SIoana Ciornei void *vaddr; 2363f48298d3SIoana Ciornei int i; 2364f48298d3SIoana Ciornei 2365f48298d3SIoana Ciornei for (i = 0; i < count; i++) { 2366f48298d3SIoana Ciornei vaddr = dpaa2_iova_to_virt(ethsw->iommu_domain, buf_array[i]); 2367f48298d3SIoana Ciornei dma_unmap_page(dev, buf_array[i], DPAA2_SWITCH_RX_BUF_SIZE, 2368f48298d3SIoana Ciornei DMA_FROM_DEVICE); 2369f48298d3SIoana Ciornei free_pages((unsigned long)vaddr, 0); 2370f48298d3SIoana Ciornei } 2371f48298d3SIoana Ciornei } 2372f48298d3SIoana Ciornei 2373f48298d3SIoana Ciornei /* Perform a single release command to add buffers 2374f48298d3SIoana Ciornei * to the specified buffer pool 2375f48298d3SIoana Ciornei */ 2376f48298d3SIoana Ciornei static int dpaa2_switch_add_bufs(struct ethsw_core *ethsw, u16 bpid) 2377f48298d3SIoana Ciornei { 2378f48298d3SIoana Ciornei struct device *dev = ethsw->dev; 2379f48298d3SIoana Ciornei u64 buf_array[BUFS_PER_CMD]; 2380f48298d3SIoana Ciornei struct page *page; 2381f48298d3SIoana Ciornei int retries = 0; 2382f48298d3SIoana Ciornei dma_addr_t addr; 2383f48298d3SIoana Ciornei int err; 2384f48298d3SIoana Ciornei int i; 2385f48298d3SIoana Ciornei 2386f48298d3SIoana Ciornei for (i = 0; i < BUFS_PER_CMD; i++) { 2387f48298d3SIoana Ciornei /* Allocate one page for each Rx buffer. WRIOP sees 2388f48298d3SIoana Ciornei * the entire page except for a tailroom reserved for 2389f48298d3SIoana Ciornei * skb shared info 2390f48298d3SIoana Ciornei */ 2391f48298d3SIoana Ciornei page = dev_alloc_pages(0); 2392f48298d3SIoana Ciornei if (!page) { 2393f48298d3SIoana Ciornei dev_err(dev, "buffer allocation failed\n"); 2394f48298d3SIoana Ciornei goto err_alloc; 2395f48298d3SIoana Ciornei } 2396f48298d3SIoana Ciornei 2397f48298d3SIoana Ciornei addr = dma_map_page(dev, page, 0, DPAA2_SWITCH_RX_BUF_SIZE, 2398f48298d3SIoana Ciornei DMA_FROM_DEVICE); 2399f48298d3SIoana Ciornei if (dma_mapping_error(dev, addr)) { 2400f48298d3SIoana Ciornei dev_err(dev, "dma_map_single() failed\n"); 2401f48298d3SIoana Ciornei goto err_map; 2402f48298d3SIoana Ciornei } 2403f48298d3SIoana Ciornei buf_array[i] = addr; 2404f48298d3SIoana Ciornei } 2405f48298d3SIoana Ciornei 2406f48298d3SIoana Ciornei release_bufs: 2407f48298d3SIoana Ciornei /* In case the portal is busy, retry until successful or 2408f48298d3SIoana Ciornei * max retries hit. 2409f48298d3SIoana Ciornei */ 2410f48298d3SIoana Ciornei while ((err = dpaa2_io_service_release(NULL, bpid, 2411f48298d3SIoana Ciornei buf_array, i)) == -EBUSY) { 2412f48298d3SIoana Ciornei if (retries++ >= DPAA2_SWITCH_SWP_BUSY_RETRIES) 2413f48298d3SIoana Ciornei break; 2414f48298d3SIoana Ciornei 2415f48298d3SIoana Ciornei cpu_relax(); 2416f48298d3SIoana Ciornei } 2417f48298d3SIoana Ciornei 2418f48298d3SIoana Ciornei /* If release command failed, clean up and bail out. */ 2419f48298d3SIoana Ciornei if (err) { 2420f48298d3SIoana Ciornei dpaa2_switch_free_bufs(ethsw, buf_array, i); 2421f48298d3SIoana Ciornei return 0; 2422f48298d3SIoana Ciornei } 2423f48298d3SIoana Ciornei 2424f48298d3SIoana Ciornei return i; 2425f48298d3SIoana Ciornei 2426f48298d3SIoana Ciornei err_map: 2427f48298d3SIoana Ciornei __free_pages(page, 0); 2428f48298d3SIoana Ciornei err_alloc: 2429f48298d3SIoana Ciornei /* If we managed to allocate at least some buffers, 2430f48298d3SIoana Ciornei * release them to hardware 2431f48298d3SIoana Ciornei */ 2432f48298d3SIoana Ciornei if (i) 2433f48298d3SIoana Ciornei goto release_bufs; 2434f48298d3SIoana Ciornei 2435f48298d3SIoana Ciornei return 0; 2436f48298d3SIoana Ciornei } 2437f48298d3SIoana Ciornei 2438f48298d3SIoana Ciornei static int dpaa2_switch_refill_bp(struct ethsw_core *ethsw) 2439f48298d3SIoana Ciornei { 2440f48298d3SIoana Ciornei int *count = ðsw->buf_count; 2441f48298d3SIoana Ciornei int new_count; 2442f48298d3SIoana Ciornei int err = 0; 2443f48298d3SIoana Ciornei 2444f48298d3SIoana Ciornei if (unlikely(*count < DPAA2_ETHSW_REFILL_THRESH)) { 2445f48298d3SIoana Ciornei do { 2446f48298d3SIoana Ciornei new_count = dpaa2_switch_add_bufs(ethsw, ethsw->bpid); 2447f48298d3SIoana Ciornei if (unlikely(!new_count)) { 2448f48298d3SIoana Ciornei /* Out of memory; abort for now, we'll 2449f48298d3SIoana Ciornei * try later on 2450f48298d3SIoana Ciornei */ 2451f48298d3SIoana Ciornei break; 2452f48298d3SIoana Ciornei } 2453f48298d3SIoana Ciornei *count += new_count; 2454f48298d3SIoana Ciornei } while (*count < DPAA2_ETHSW_NUM_BUFS); 2455f48298d3SIoana Ciornei 2456f48298d3SIoana Ciornei if (unlikely(*count < DPAA2_ETHSW_NUM_BUFS)) 2457f48298d3SIoana Ciornei err = -ENOMEM; 2458f48298d3SIoana Ciornei } 2459f48298d3SIoana Ciornei 2460f48298d3SIoana Ciornei return err; 2461f48298d3SIoana Ciornei } 2462f48298d3SIoana Ciornei 2463f48298d3SIoana Ciornei static int dpaa2_switch_seed_bp(struct ethsw_core *ethsw) 2464f48298d3SIoana Ciornei { 2465f48298d3SIoana Ciornei int *count, i; 2466f48298d3SIoana Ciornei 2467f48298d3SIoana Ciornei for (i = 0; i < DPAA2_ETHSW_NUM_BUFS; i += BUFS_PER_CMD) { 2468f48298d3SIoana Ciornei count = ðsw->buf_count; 2469f48298d3SIoana Ciornei *count += dpaa2_switch_add_bufs(ethsw, ethsw->bpid); 2470f48298d3SIoana Ciornei 2471f48298d3SIoana Ciornei if (unlikely(*count < BUFS_PER_CMD)) 2472f48298d3SIoana Ciornei return -ENOMEM; 2473f48298d3SIoana Ciornei } 2474f48298d3SIoana Ciornei 2475f48298d3SIoana Ciornei return 0; 2476f48298d3SIoana Ciornei } 2477f48298d3SIoana Ciornei 2478f48298d3SIoana Ciornei static void dpaa2_switch_drain_bp(struct ethsw_core *ethsw) 2479f48298d3SIoana Ciornei { 2480f48298d3SIoana Ciornei u64 buf_array[BUFS_PER_CMD]; 2481f48298d3SIoana Ciornei int ret; 2482f48298d3SIoana Ciornei 2483f48298d3SIoana Ciornei do { 2484f48298d3SIoana Ciornei ret = dpaa2_io_service_acquire(NULL, ethsw->bpid, 2485f48298d3SIoana Ciornei buf_array, BUFS_PER_CMD); 2486f48298d3SIoana Ciornei if (ret < 0) { 2487f48298d3SIoana Ciornei dev_err(ethsw->dev, 2488f48298d3SIoana Ciornei "dpaa2_io_service_acquire() = %d\n", ret); 2489f48298d3SIoana Ciornei return; 2490f48298d3SIoana Ciornei } 2491f48298d3SIoana Ciornei dpaa2_switch_free_bufs(ethsw, buf_array, ret); 2492f48298d3SIoana Ciornei 2493f48298d3SIoana Ciornei } while (ret); 2494f48298d3SIoana Ciornei } 2495f48298d3SIoana Ciornei 2496f48298d3SIoana Ciornei static int dpaa2_switch_setup_dpbp(struct ethsw_core *ethsw) 2497f48298d3SIoana Ciornei { 2498f48298d3SIoana Ciornei struct dpsw_ctrl_if_pools_cfg dpsw_ctrl_if_pools_cfg = { 0 }; 2499f48298d3SIoana Ciornei struct device *dev = ethsw->dev; 2500f48298d3SIoana Ciornei struct fsl_mc_device *dpbp_dev; 2501f48298d3SIoana Ciornei struct dpbp_attr dpbp_attrs; 2502f48298d3SIoana Ciornei int err; 2503f48298d3SIoana Ciornei 2504f48298d3SIoana Ciornei err = fsl_mc_object_allocate(to_fsl_mc_device(dev), FSL_MC_POOL_DPBP, 2505f48298d3SIoana Ciornei &dpbp_dev); 2506f48298d3SIoana Ciornei if (err) { 2507f48298d3SIoana Ciornei if (err == -ENXIO) 2508f48298d3SIoana Ciornei err = -EPROBE_DEFER; 2509f48298d3SIoana Ciornei else 2510f48298d3SIoana Ciornei dev_err(dev, "DPBP device allocation failed\n"); 2511f48298d3SIoana Ciornei return err; 2512f48298d3SIoana Ciornei } 2513f48298d3SIoana Ciornei ethsw->dpbp_dev = dpbp_dev; 2514f48298d3SIoana Ciornei 2515f48298d3SIoana Ciornei err = dpbp_open(ethsw->mc_io, 0, dpbp_dev->obj_desc.id, 2516f48298d3SIoana Ciornei &dpbp_dev->mc_handle); 2517f48298d3SIoana Ciornei if (err) { 2518f48298d3SIoana Ciornei dev_err(dev, "dpbp_open() failed\n"); 2519f48298d3SIoana Ciornei goto err_open; 2520f48298d3SIoana Ciornei } 2521f48298d3SIoana Ciornei 2522f48298d3SIoana Ciornei err = dpbp_reset(ethsw->mc_io, 0, dpbp_dev->mc_handle); 2523f48298d3SIoana Ciornei if (err) { 2524f48298d3SIoana Ciornei dev_err(dev, "dpbp_reset() failed\n"); 2525f48298d3SIoana Ciornei goto err_reset; 2526f48298d3SIoana Ciornei } 2527f48298d3SIoana Ciornei 2528f48298d3SIoana Ciornei err = dpbp_enable(ethsw->mc_io, 0, dpbp_dev->mc_handle); 2529f48298d3SIoana Ciornei if (err) { 2530f48298d3SIoana Ciornei dev_err(dev, "dpbp_enable() failed\n"); 2531f48298d3SIoana Ciornei goto err_enable; 2532f48298d3SIoana Ciornei } 2533f48298d3SIoana Ciornei 2534f48298d3SIoana Ciornei err = dpbp_get_attributes(ethsw->mc_io, 0, dpbp_dev->mc_handle, 2535f48298d3SIoana Ciornei &dpbp_attrs); 2536f48298d3SIoana Ciornei if (err) { 2537f48298d3SIoana Ciornei dev_err(dev, "dpbp_get_attributes() failed\n"); 2538f48298d3SIoana Ciornei goto err_get_attr; 2539f48298d3SIoana Ciornei } 2540f48298d3SIoana Ciornei 2541f48298d3SIoana Ciornei dpsw_ctrl_if_pools_cfg.num_dpbp = 1; 2542f48298d3SIoana Ciornei dpsw_ctrl_if_pools_cfg.pools[0].dpbp_id = dpbp_attrs.id; 2543f48298d3SIoana Ciornei dpsw_ctrl_if_pools_cfg.pools[0].buffer_size = DPAA2_SWITCH_RX_BUF_SIZE; 2544f48298d3SIoana Ciornei dpsw_ctrl_if_pools_cfg.pools[0].backup_pool = 0; 2545f48298d3SIoana Ciornei 2546f48298d3SIoana Ciornei err = dpsw_ctrl_if_set_pools(ethsw->mc_io, 0, ethsw->dpsw_handle, 2547f48298d3SIoana Ciornei &dpsw_ctrl_if_pools_cfg); 2548f48298d3SIoana Ciornei if (err) { 2549f48298d3SIoana Ciornei dev_err(dev, "dpsw_ctrl_if_set_pools() failed\n"); 2550f48298d3SIoana Ciornei goto err_get_attr; 2551f48298d3SIoana Ciornei } 2552f48298d3SIoana Ciornei ethsw->bpid = dpbp_attrs.id; 2553f48298d3SIoana Ciornei 2554f48298d3SIoana Ciornei return 0; 2555f48298d3SIoana Ciornei 2556f48298d3SIoana Ciornei err_get_attr: 2557f48298d3SIoana Ciornei dpbp_disable(ethsw->mc_io, 0, dpbp_dev->mc_handle); 2558f48298d3SIoana Ciornei err_enable: 2559f48298d3SIoana Ciornei err_reset: 2560f48298d3SIoana Ciornei dpbp_close(ethsw->mc_io, 0, dpbp_dev->mc_handle); 2561f48298d3SIoana Ciornei err_open: 2562f48298d3SIoana Ciornei fsl_mc_object_free(dpbp_dev); 2563f48298d3SIoana Ciornei return err; 2564f48298d3SIoana Ciornei } 2565f48298d3SIoana Ciornei 2566f48298d3SIoana Ciornei static void dpaa2_switch_free_dpbp(struct ethsw_core *ethsw) 2567f48298d3SIoana Ciornei { 2568f48298d3SIoana Ciornei dpbp_disable(ethsw->mc_io, 0, ethsw->dpbp_dev->mc_handle); 2569f48298d3SIoana Ciornei dpbp_close(ethsw->mc_io, 0, ethsw->dpbp_dev->mc_handle); 2570f48298d3SIoana Ciornei fsl_mc_object_free(ethsw->dpbp_dev); 2571f48298d3SIoana Ciornei } 2572f48298d3SIoana Ciornei 2573f48298d3SIoana Ciornei static int dpaa2_switch_alloc_rings(struct ethsw_core *ethsw) 2574f48298d3SIoana Ciornei { 2575f48298d3SIoana Ciornei int i; 2576f48298d3SIoana Ciornei 2577f48298d3SIoana Ciornei for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) { 2578f48298d3SIoana Ciornei ethsw->fq[i].store = 2579f48298d3SIoana Ciornei dpaa2_io_store_create(DPAA2_SWITCH_STORE_SIZE, 2580f48298d3SIoana Ciornei ethsw->dev); 2581f48298d3SIoana Ciornei if (!ethsw->fq[i].store) { 2582f48298d3SIoana Ciornei dev_err(ethsw->dev, "dpaa2_io_store_create failed\n"); 2583f48298d3SIoana Ciornei while (--i >= 0) 2584f48298d3SIoana Ciornei dpaa2_io_store_destroy(ethsw->fq[i].store); 2585f48298d3SIoana Ciornei return -ENOMEM; 2586f48298d3SIoana Ciornei } 2587f48298d3SIoana Ciornei } 2588f48298d3SIoana Ciornei 2589f48298d3SIoana Ciornei return 0; 2590f48298d3SIoana Ciornei } 2591f48298d3SIoana Ciornei 2592f48298d3SIoana Ciornei static void dpaa2_switch_destroy_rings(struct ethsw_core *ethsw) 2593f48298d3SIoana Ciornei { 2594f48298d3SIoana Ciornei int i; 2595f48298d3SIoana Ciornei 2596f48298d3SIoana Ciornei for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) 2597f48298d3SIoana Ciornei dpaa2_io_store_destroy(ethsw->fq[i].store); 2598f48298d3SIoana Ciornei } 2599f48298d3SIoana Ciornei 2600f48298d3SIoana Ciornei static int dpaa2_switch_pull_fq(struct dpaa2_switch_fq *fq) 2601f48298d3SIoana Ciornei { 2602f48298d3SIoana Ciornei int err, retries = 0; 2603f48298d3SIoana Ciornei 2604f48298d3SIoana Ciornei /* Try to pull from the FQ while the portal is busy and we didn't hit 2605f48298d3SIoana Ciornei * the maximum number fo retries 2606f48298d3SIoana Ciornei */ 2607f48298d3SIoana Ciornei do { 2608f48298d3SIoana Ciornei err = dpaa2_io_service_pull_fq(NULL, fq->fqid, fq->store); 2609f48298d3SIoana Ciornei cpu_relax(); 2610f48298d3SIoana Ciornei } while (err == -EBUSY && retries++ < DPAA2_SWITCH_SWP_BUSY_RETRIES); 2611f48298d3SIoana Ciornei 2612f48298d3SIoana Ciornei if (unlikely(err)) 2613f48298d3SIoana Ciornei dev_err(fq->ethsw->dev, "dpaa2_io_service_pull err %d", err); 2614f48298d3SIoana Ciornei 2615f48298d3SIoana Ciornei return err; 2616f48298d3SIoana Ciornei } 2617f48298d3SIoana Ciornei 2618f48298d3SIoana Ciornei /* Consume all frames pull-dequeued into the store */ 2619f48298d3SIoana Ciornei static int dpaa2_switch_store_consume(struct dpaa2_switch_fq *fq) 2620f48298d3SIoana Ciornei { 2621f48298d3SIoana Ciornei struct ethsw_core *ethsw = fq->ethsw; 2622f48298d3SIoana Ciornei int cleaned = 0, is_last; 2623f48298d3SIoana Ciornei struct dpaa2_dq *dq; 2624f48298d3SIoana Ciornei int retries = 0; 2625f48298d3SIoana Ciornei 2626f48298d3SIoana Ciornei do { 2627f48298d3SIoana Ciornei /* Get the next available FD from the store */ 2628f48298d3SIoana Ciornei dq = dpaa2_io_store_next(fq->store, &is_last); 2629f48298d3SIoana Ciornei if (unlikely(!dq)) { 2630f48298d3SIoana Ciornei if (retries++ >= DPAA2_SWITCH_SWP_BUSY_RETRIES) { 2631f48298d3SIoana Ciornei dev_err_once(ethsw->dev, 2632f48298d3SIoana Ciornei "No valid dequeue response\n"); 2633f48298d3SIoana Ciornei return -ETIMEDOUT; 2634f48298d3SIoana Ciornei } 2635f48298d3SIoana Ciornei continue; 2636f48298d3SIoana Ciornei } 2637f48298d3SIoana Ciornei 2638f48298d3SIoana Ciornei if (fq->type == DPSW_QUEUE_RX) 2639f48298d3SIoana Ciornei dpaa2_switch_rx(fq, dpaa2_dq_fd(dq)); 2640f48298d3SIoana Ciornei else 2641f48298d3SIoana Ciornei dpaa2_switch_tx_conf(fq, dpaa2_dq_fd(dq)); 2642f48298d3SIoana Ciornei cleaned++; 2643f48298d3SIoana Ciornei 2644f48298d3SIoana Ciornei } while (!is_last); 2645f48298d3SIoana Ciornei 2646f48298d3SIoana Ciornei return cleaned; 2647f48298d3SIoana Ciornei } 2648f48298d3SIoana Ciornei 2649f48298d3SIoana Ciornei /* NAPI poll routine */ 2650f48298d3SIoana Ciornei static int dpaa2_switch_poll(struct napi_struct *napi, int budget) 2651f48298d3SIoana Ciornei { 2652f48298d3SIoana Ciornei int err, cleaned = 0, store_cleaned, work_done; 2653f48298d3SIoana Ciornei struct dpaa2_switch_fq *fq; 2654f48298d3SIoana Ciornei int retries = 0; 2655f48298d3SIoana Ciornei 2656f48298d3SIoana Ciornei fq = container_of(napi, struct dpaa2_switch_fq, napi); 2657f48298d3SIoana Ciornei 2658f48298d3SIoana Ciornei do { 2659f48298d3SIoana Ciornei err = dpaa2_switch_pull_fq(fq); 2660f48298d3SIoana Ciornei if (unlikely(err)) 2661f48298d3SIoana Ciornei break; 2662f48298d3SIoana Ciornei 2663f48298d3SIoana Ciornei /* Refill pool if appropriate */ 2664f48298d3SIoana Ciornei dpaa2_switch_refill_bp(fq->ethsw); 2665f48298d3SIoana Ciornei 2666f48298d3SIoana Ciornei store_cleaned = dpaa2_switch_store_consume(fq); 2667f48298d3SIoana Ciornei cleaned += store_cleaned; 2668f48298d3SIoana Ciornei 2669f48298d3SIoana Ciornei if (cleaned >= budget) { 2670f48298d3SIoana Ciornei work_done = budget; 2671f48298d3SIoana Ciornei goto out; 2672f48298d3SIoana Ciornei } 2673f48298d3SIoana Ciornei 2674f48298d3SIoana Ciornei } while (store_cleaned); 2675f48298d3SIoana Ciornei 2676f48298d3SIoana Ciornei /* We didn't consume the entire budget, so finish napi and re-enable 2677f48298d3SIoana Ciornei * data availability notifications 2678f48298d3SIoana Ciornei */ 2679f48298d3SIoana Ciornei napi_complete_done(napi, cleaned); 2680f48298d3SIoana Ciornei do { 2681f48298d3SIoana Ciornei err = dpaa2_io_service_rearm(NULL, &fq->nctx); 2682f48298d3SIoana Ciornei cpu_relax(); 2683f48298d3SIoana Ciornei } while (err == -EBUSY && retries++ < DPAA2_SWITCH_SWP_BUSY_RETRIES); 2684f48298d3SIoana Ciornei 2685f48298d3SIoana Ciornei work_done = max(cleaned, 1); 2686f48298d3SIoana Ciornei out: 2687f48298d3SIoana Ciornei 2688f48298d3SIoana Ciornei return work_done; 2689f48298d3SIoana Ciornei } 2690f48298d3SIoana Ciornei 2691f48298d3SIoana Ciornei static void dpaa2_switch_fqdan_cb(struct dpaa2_io_notification_ctx *nctx) 2692f48298d3SIoana Ciornei { 2693f48298d3SIoana Ciornei struct dpaa2_switch_fq *fq; 2694f48298d3SIoana Ciornei 2695f48298d3SIoana Ciornei fq = container_of(nctx, struct dpaa2_switch_fq, nctx); 2696f48298d3SIoana Ciornei 2697f48298d3SIoana Ciornei napi_schedule(&fq->napi); 2698f48298d3SIoana Ciornei } 2699f48298d3SIoana Ciornei 2700f48298d3SIoana Ciornei static int dpaa2_switch_setup_dpio(struct ethsw_core *ethsw) 2701f48298d3SIoana Ciornei { 2702f48298d3SIoana Ciornei struct dpsw_ctrl_if_queue_cfg queue_cfg; 2703f48298d3SIoana Ciornei struct dpaa2_io_notification_ctx *nctx; 2704f48298d3SIoana Ciornei int err, i, j; 2705f48298d3SIoana Ciornei 2706f48298d3SIoana Ciornei for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) { 2707f48298d3SIoana Ciornei nctx = ðsw->fq[i].nctx; 2708f48298d3SIoana Ciornei 2709f48298d3SIoana Ciornei /* Register a new software context for the FQID. 2710f48298d3SIoana Ciornei * By using NULL as the first parameter, we specify that we do 2711f48298d3SIoana Ciornei * not care on which cpu are interrupts received for this queue 2712f48298d3SIoana Ciornei */ 2713f48298d3SIoana Ciornei nctx->is_cdan = 0; 2714f48298d3SIoana Ciornei nctx->id = ethsw->fq[i].fqid; 2715f48298d3SIoana Ciornei nctx->desired_cpu = DPAA2_IO_ANY_CPU; 2716f48298d3SIoana Ciornei nctx->cb = dpaa2_switch_fqdan_cb; 2717f48298d3SIoana Ciornei err = dpaa2_io_service_register(NULL, nctx, ethsw->dev); 2718f48298d3SIoana Ciornei if (err) { 2719f48298d3SIoana Ciornei err = -EPROBE_DEFER; 2720f48298d3SIoana Ciornei goto err_register; 2721f48298d3SIoana Ciornei } 2722f48298d3SIoana Ciornei 2723f48298d3SIoana Ciornei queue_cfg.options = DPSW_CTRL_IF_QUEUE_OPT_DEST | 2724f48298d3SIoana Ciornei DPSW_CTRL_IF_QUEUE_OPT_USER_CTX; 2725f48298d3SIoana Ciornei queue_cfg.dest_cfg.dest_type = DPSW_CTRL_IF_DEST_DPIO; 2726f48298d3SIoana Ciornei queue_cfg.dest_cfg.dest_id = nctx->dpio_id; 2727f48298d3SIoana Ciornei queue_cfg.dest_cfg.priority = 0; 2728f48298d3SIoana Ciornei queue_cfg.user_ctx = nctx->qman64; 2729f48298d3SIoana Ciornei 2730f48298d3SIoana Ciornei err = dpsw_ctrl_if_set_queue(ethsw->mc_io, 0, 2731f48298d3SIoana Ciornei ethsw->dpsw_handle, 2732f48298d3SIoana Ciornei ethsw->fq[i].type, 2733f48298d3SIoana Ciornei &queue_cfg); 2734f48298d3SIoana Ciornei if (err) 2735f48298d3SIoana Ciornei goto err_set_queue; 2736f48298d3SIoana Ciornei } 2737f48298d3SIoana Ciornei 2738f48298d3SIoana Ciornei return 0; 2739f48298d3SIoana Ciornei 2740f48298d3SIoana Ciornei err_set_queue: 2741f48298d3SIoana Ciornei dpaa2_io_service_deregister(NULL, nctx, ethsw->dev); 2742f48298d3SIoana Ciornei err_register: 2743f48298d3SIoana Ciornei for (j = 0; j < i; j++) 2744f48298d3SIoana Ciornei dpaa2_io_service_deregister(NULL, ðsw->fq[j].nctx, 2745f48298d3SIoana Ciornei ethsw->dev); 2746f48298d3SIoana Ciornei 2747f48298d3SIoana Ciornei return err; 2748f48298d3SIoana Ciornei } 2749f48298d3SIoana Ciornei 2750f48298d3SIoana Ciornei static void dpaa2_switch_free_dpio(struct ethsw_core *ethsw) 2751f48298d3SIoana Ciornei { 2752f48298d3SIoana Ciornei int i; 2753f48298d3SIoana Ciornei 2754f48298d3SIoana Ciornei for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) 2755f48298d3SIoana Ciornei dpaa2_io_service_deregister(NULL, ðsw->fq[i].nctx, 2756f48298d3SIoana Ciornei ethsw->dev); 2757f48298d3SIoana Ciornei } 2758f48298d3SIoana Ciornei 2759f48298d3SIoana Ciornei static int dpaa2_switch_ctrl_if_setup(struct ethsw_core *ethsw) 2760f48298d3SIoana Ciornei { 2761f48298d3SIoana Ciornei int err; 2762f48298d3SIoana Ciornei 2763f48298d3SIoana Ciornei /* setup FQs for Rx and Tx Conf */ 2764f48298d3SIoana Ciornei err = dpaa2_switch_setup_fqs(ethsw); 2765f48298d3SIoana Ciornei if (err) 2766f48298d3SIoana Ciornei return err; 2767f48298d3SIoana Ciornei 2768f48298d3SIoana Ciornei /* setup the buffer pool needed on the Rx path */ 2769f48298d3SIoana Ciornei err = dpaa2_switch_setup_dpbp(ethsw); 2770f48298d3SIoana Ciornei if (err) 2771f48298d3SIoana Ciornei return err; 2772f48298d3SIoana Ciornei 2773f48298d3SIoana Ciornei err = dpaa2_switch_seed_bp(ethsw); 2774f48298d3SIoana Ciornei if (err) 2775f48298d3SIoana Ciornei goto err_free_dpbp; 2776f48298d3SIoana Ciornei 2777f48298d3SIoana Ciornei err = dpaa2_switch_alloc_rings(ethsw); 2778f48298d3SIoana Ciornei if (err) 2779f48298d3SIoana Ciornei goto err_drain_dpbp; 2780f48298d3SIoana Ciornei 2781f48298d3SIoana Ciornei err = dpaa2_switch_setup_dpio(ethsw); 2782f48298d3SIoana Ciornei if (err) 2783f48298d3SIoana Ciornei goto err_destroy_rings; 2784f48298d3SIoana Ciornei 2785f48298d3SIoana Ciornei err = dpsw_ctrl_if_enable(ethsw->mc_io, 0, ethsw->dpsw_handle); 2786f48298d3SIoana Ciornei if (err) { 2787f48298d3SIoana Ciornei dev_err(ethsw->dev, "dpsw_ctrl_if_enable err %d\n", err); 2788f48298d3SIoana Ciornei goto err_deregister_dpio; 2789f48298d3SIoana Ciornei } 2790f48298d3SIoana Ciornei 2791f48298d3SIoana Ciornei return 0; 2792f48298d3SIoana Ciornei 2793f48298d3SIoana Ciornei err_deregister_dpio: 2794f48298d3SIoana Ciornei dpaa2_switch_free_dpio(ethsw); 2795f48298d3SIoana Ciornei err_destroy_rings: 2796f48298d3SIoana Ciornei dpaa2_switch_destroy_rings(ethsw); 2797f48298d3SIoana Ciornei err_drain_dpbp: 2798f48298d3SIoana Ciornei dpaa2_switch_drain_bp(ethsw); 2799f48298d3SIoana Ciornei err_free_dpbp: 2800f48298d3SIoana Ciornei dpaa2_switch_free_dpbp(ethsw); 2801f48298d3SIoana Ciornei 2802f48298d3SIoana Ciornei return err; 2803f48298d3SIoana Ciornei } 2804f48298d3SIoana Ciornei 2805f48298d3SIoana Ciornei static int dpaa2_switch_init(struct fsl_mc_device *sw_dev) 2806f48298d3SIoana Ciornei { 2807f48298d3SIoana Ciornei struct device *dev = &sw_dev->dev; 2808f48298d3SIoana Ciornei struct ethsw_core *ethsw = dev_get_drvdata(dev); 2809f48298d3SIoana Ciornei struct dpsw_vlan_if_cfg vcfg = {0}; 2810f48298d3SIoana Ciornei struct dpsw_tci_cfg tci_cfg = {0}; 2811f48298d3SIoana Ciornei struct dpsw_stp_cfg stp_cfg; 2812f48298d3SIoana Ciornei int err; 2813f48298d3SIoana Ciornei u16 i; 2814f48298d3SIoana Ciornei 2815f48298d3SIoana Ciornei ethsw->dev_id = sw_dev->obj_desc.id; 2816f48298d3SIoana Ciornei 2817f48298d3SIoana Ciornei err = dpsw_open(ethsw->mc_io, 0, ethsw->dev_id, ðsw->dpsw_handle); 2818f48298d3SIoana Ciornei if (err) { 2819f48298d3SIoana Ciornei dev_err(dev, "dpsw_open err %d\n", err); 2820f48298d3SIoana Ciornei return err; 2821f48298d3SIoana Ciornei } 2822f48298d3SIoana Ciornei 2823f48298d3SIoana Ciornei err = dpsw_get_attributes(ethsw->mc_io, 0, ethsw->dpsw_handle, 2824f48298d3SIoana Ciornei ðsw->sw_attr); 2825f48298d3SIoana Ciornei if (err) { 2826f48298d3SIoana Ciornei dev_err(dev, "dpsw_get_attributes err %d\n", err); 2827f48298d3SIoana Ciornei goto err_close; 2828f48298d3SIoana Ciornei } 2829f48298d3SIoana Ciornei 2830f48298d3SIoana Ciornei err = dpsw_get_api_version(ethsw->mc_io, 0, 2831f48298d3SIoana Ciornei ðsw->major, 2832f48298d3SIoana Ciornei ðsw->minor); 2833f48298d3SIoana Ciornei if (err) { 2834f48298d3SIoana Ciornei dev_err(dev, "dpsw_get_api_version err %d\n", err); 2835f48298d3SIoana Ciornei goto err_close; 2836f48298d3SIoana Ciornei } 2837f48298d3SIoana Ciornei 2838f48298d3SIoana Ciornei /* Minimum supported DPSW version check */ 2839f48298d3SIoana Ciornei if (ethsw->major < DPSW_MIN_VER_MAJOR || 2840f48298d3SIoana Ciornei (ethsw->major == DPSW_MIN_VER_MAJOR && 2841f48298d3SIoana Ciornei ethsw->minor < DPSW_MIN_VER_MINOR)) { 2842f48298d3SIoana Ciornei dev_err(dev, "DPSW version %d:%d not supported. Use firmware 10.28.0 or greater.\n", 2843f48298d3SIoana Ciornei ethsw->major, ethsw->minor); 2844f48298d3SIoana Ciornei err = -EOPNOTSUPP; 2845f48298d3SIoana Ciornei goto err_close; 2846f48298d3SIoana Ciornei } 2847f48298d3SIoana Ciornei 2848f48298d3SIoana Ciornei if (!dpaa2_switch_supports_cpu_traffic(ethsw)) { 2849f48298d3SIoana Ciornei err = -EOPNOTSUPP; 2850f48298d3SIoana Ciornei goto err_close; 2851f48298d3SIoana Ciornei } 2852f48298d3SIoana Ciornei 2853f48298d3SIoana Ciornei dpaa2_switch_detect_features(ethsw); 2854f48298d3SIoana Ciornei 2855f48298d3SIoana Ciornei err = dpsw_reset(ethsw->mc_io, 0, ethsw->dpsw_handle); 2856f48298d3SIoana Ciornei if (err) { 2857f48298d3SIoana Ciornei dev_err(dev, "dpsw_reset err %d\n", err); 2858f48298d3SIoana Ciornei goto err_close; 2859f48298d3SIoana Ciornei } 2860f48298d3SIoana Ciornei 2861f48298d3SIoana Ciornei stp_cfg.vlan_id = DEFAULT_VLAN_ID; 2862f48298d3SIoana Ciornei stp_cfg.state = DPSW_STP_STATE_FORWARDING; 2863f48298d3SIoana Ciornei 2864f48298d3SIoana Ciornei for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 2865f48298d3SIoana Ciornei err = dpsw_if_disable(ethsw->mc_io, 0, ethsw->dpsw_handle, i); 2866f48298d3SIoana Ciornei if (err) { 2867f48298d3SIoana Ciornei dev_err(dev, "dpsw_if_disable err %d\n", err); 2868f48298d3SIoana Ciornei goto err_close; 2869f48298d3SIoana Ciornei } 2870f48298d3SIoana Ciornei 2871f48298d3SIoana Ciornei err = dpsw_if_set_stp(ethsw->mc_io, 0, ethsw->dpsw_handle, i, 2872f48298d3SIoana Ciornei &stp_cfg); 2873f48298d3SIoana Ciornei if (err) { 2874f48298d3SIoana Ciornei dev_err(dev, "dpsw_if_set_stp err %d for port %d\n", 2875f48298d3SIoana Ciornei err, i); 2876f48298d3SIoana Ciornei goto err_close; 2877f48298d3SIoana Ciornei } 2878f48298d3SIoana Ciornei 2879f48298d3SIoana Ciornei /* Switch starts with all ports configured to VLAN 1. Need to 2880f48298d3SIoana Ciornei * remove this setting to allow configuration at bridge join 2881f48298d3SIoana Ciornei */ 2882f48298d3SIoana Ciornei vcfg.num_ifs = 1; 2883f48298d3SIoana Ciornei vcfg.if_id[0] = i; 2884f48298d3SIoana Ciornei err = dpsw_vlan_remove_if_untagged(ethsw->mc_io, 0, ethsw->dpsw_handle, 2885f48298d3SIoana Ciornei DEFAULT_VLAN_ID, &vcfg); 2886f48298d3SIoana Ciornei if (err) { 2887f48298d3SIoana Ciornei dev_err(dev, "dpsw_vlan_remove_if_untagged err %d\n", 2888f48298d3SIoana Ciornei err); 2889f48298d3SIoana Ciornei goto err_close; 2890f48298d3SIoana Ciornei } 2891f48298d3SIoana Ciornei 2892f48298d3SIoana Ciornei tci_cfg.vlan_id = 4095; 2893f48298d3SIoana Ciornei err = dpsw_if_set_tci(ethsw->mc_io, 0, ethsw->dpsw_handle, i, &tci_cfg); 2894f48298d3SIoana Ciornei if (err) { 2895f48298d3SIoana Ciornei dev_err(dev, "dpsw_if_set_tci err %d\n", err); 2896f48298d3SIoana Ciornei goto err_close; 2897f48298d3SIoana Ciornei } 2898f48298d3SIoana Ciornei 2899f48298d3SIoana Ciornei err = dpsw_vlan_remove_if(ethsw->mc_io, 0, ethsw->dpsw_handle, 2900f48298d3SIoana Ciornei DEFAULT_VLAN_ID, &vcfg); 2901f48298d3SIoana Ciornei if (err) { 2902f48298d3SIoana Ciornei dev_err(dev, "dpsw_vlan_remove_if err %d\n", err); 2903f48298d3SIoana Ciornei goto err_close; 2904f48298d3SIoana Ciornei } 2905f48298d3SIoana Ciornei } 2906f48298d3SIoana Ciornei 2907f48298d3SIoana Ciornei err = dpsw_vlan_remove(ethsw->mc_io, 0, ethsw->dpsw_handle, DEFAULT_VLAN_ID); 2908f48298d3SIoana Ciornei if (err) { 2909f48298d3SIoana Ciornei dev_err(dev, "dpsw_vlan_remove err %d\n", err); 2910f48298d3SIoana Ciornei goto err_close; 2911f48298d3SIoana Ciornei } 2912f48298d3SIoana Ciornei 2913f48298d3SIoana Ciornei ethsw->workqueue = alloc_ordered_workqueue("%s_%d_ordered", 2914f48298d3SIoana Ciornei WQ_MEM_RECLAIM, "ethsw", 2915f48298d3SIoana Ciornei ethsw->sw_attr.id); 2916f48298d3SIoana Ciornei if (!ethsw->workqueue) { 2917f48298d3SIoana Ciornei err = -ENOMEM; 2918f48298d3SIoana Ciornei goto err_close; 2919f48298d3SIoana Ciornei } 2920f48298d3SIoana Ciornei 2921f48298d3SIoana Ciornei err = dpsw_fdb_remove(ethsw->mc_io, 0, ethsw->dpsw_handle, 0); 2922f48298d3SIoana Ciornei if (err) 2923f48298d3SIoana Ciornei goto err_destroy_ordered_workqueue; 2924f48298d3SIoana Ciornei 2925f48298d3SIoana Ciornei err = dpaa2_switch_ctrl_if_setup(ethsw); 2926f48298d3SIoana Ciornei if (err) 2927f48298d3SIoana Ciornei goto err_destroy_ordered_workqueue; 2928f48298d3SIoana Ciornei 2929f48298d3SIoana Ciornei return 0; 2930f48298d3SIoana Ciornei 2931f48298d3SIoana Ciornei err_destroy_ordered_workqueue: 2932f48298d3SIoana Ciornei destroy_workqueue(ethsw->workqueue); 2933f48298d3SIoana Ciornei 2934f48298d3SIoana Ciornei err_close: 2935f48298d3SIoana Ciornei dpsw_close(ethsw->mc_io, 0, ethsw->dpsw_handle); 2936f48298d3SIoana Ciornei return err; 2937f48298d3SIoana Ciornei } 2938f48298d3SIoana Ciornei 29391a64ed12SIoana Ciornei /* Add an ACL to redirect frames with specific destination MAC address to 29401a64ed12SIoana Ciornei * control interface 29411a64ed12SIoana Ciornei */ 29421a64ed12SIoana Ciornei static int dpaa2_switch_port_trap_mac_addr(struct ethsw_port_priv *port_priv, 29431a64ed12SIoana Ciornei const char *mac) 29441a64ed12SIoana Ciornei { 294516617954SIoana Ciornei struct dpaa2_switch_acl_entry acl_entry = {0}; 29461a64ed12SIoana Ciornei 29471a64ed12SIoana Ciornei /* Match on the destination MAC address */ 294816617954SIoana Ciornei ether_addr_copy(acl_entry.key.match.l2_dest_mac, mac); 294916617954SIoana Ciornei eth_broadcast_addr(acl_entry.key.mask.l2_dest_mac); 29501a64ed12SIoana Ciornei 295116617954SIoana Ciornei /* Trap to CPU */ 295216617954SIoana Ciornei acl_entry.cfg.precedence = 0; 295316617954SIoana Ciornei acl_entry.cfg.result.action = DPSW_ACL_ACTION_REDIRECT_TO_CTRL_IF; 29541a64ed12SIoana Ciornei 295516617954SIoana Ciornei return dpaa2_switch_acl_entry_add(port_priv->acl_tbl, &acl_entry); 29561a64ed12SIoana Ciornei } 29571a64ed12SIoana Ciornei 2958f48298d3SIoana Ciornei static int dpaa2_switch_port_init(struct ethsw_port_priv *port_priv, u16 port) 2959f48298d3SIoana Ciornei { 29601a64ed12SIoana Ciornei const char stpa[ETH_ALEN] = {0x01, 0x80, 0xc2, 0x00, 0x00, 0x00}; 2961f48298d3SIoana Ciornei struct switchdev_obj_port_vlan vlan = { 2962f48298d3SIoana Ciornei .obj.id = SWITCHDEV_OBJ_ID_PORT_VLAN, 2963f48298d3SIoana Ciornei .vid = DEFAULT_VLAN_ID, 2964f48298d3SIoana Ciornei .flags = BRIDGE_VLAN_INFO_UNTAGGED | BRIDGE_VLAN_INFO_PVID, 2965f48298d3SIoana Ciornei }; 2966f48298d3SIoana Ciornei struct net_device *netdev = port_priv->netdev; 2967f48298d3SIoana Ciornei struct ethsw_core *ethsw = port_priv->ethsw_data; 29681b0f14b6SIoana Ciornei struct dpaa2_switch_acl_tbl *acl_tbl; 2969f48298d3SIoana Ciornei struct dpsw_fdb_cfg fdb_cfg = {0}; 2970f48298d3SIoana Ciornei struct dpsw_if_attr dpsw_if_attr; 297190f07102SIoana Ciornei struct dpaa2_switch_fdb *fdb; 297290f07102SIoana Ciornei struct dpsw_acl_cfg acl_cfg; 29731b0f14b6SIoana Ciornei u16 fdb_id, acl_tbl_id; 2974f48298d3SIoana Ciornei int err; 2975f48298d3SIoana Ciornei 2976f48298d3SIoana Ciornei /* Get the Tx queue for this specific port */ 2977f48298d3SIoana Ciornei err = dpsw_if_get_attributes(ethsw->mc_io, 0, ethsw->dpsw_handle, 2978f48298d3SIoana Ciornei port_priv->idx, &dpsw_if_attr); 2979f48298d3SIoana Ciornei if (err) { 2980f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_if_get_attributes err %d\n", err); 2981f48298d3SIoana Ciornei return err; 2982f48298d3SIoana Ciornei } 2983f48298d3SIoana Ciornei port_priv->tx_qdid = dpsw_if_attr.qdid; 2984f48298d3SIoana Ciornei 2985f48298d3SIoana Ciornei /* Create a FDB table for this particular switch port */ 2986f48298d3SIoana Ciornei fdb_cfg.num_fdb_entries = ethsw->sw_attr.max_fdb_entries / ethsw->sw_attr.num_ifs; 2987f48298d3SIoana Ciornei err = dpsw_fdb_add(ethsw->mc_io, 0, ethsw->dpsw_handle, 2988f48298d3SIoana Ciornei &fdb_id, &fdb_cfg); 2989f48298d3SIoana Ciornei if (err) { 2990f48298d3SIoana Ciornei netdev_err(netdev, "dpsw_fdb_add err %d\n", err); 2991f48298d3SIoana Ciornei return err; 2992f48298d3SIoana Ciornei } 2993f48298d3SIoana Ciornei 2994f48298d3SIoana Ciornei /* Find an unused dpaa2_switch_fdb structure and use it */ 2995f48298d3SIoana Ciornei fdb = dpaa2_switch_fdb_get_unused(ethsw); 2996f48298d3SIoana Ciornei fdb->fdb_id = fdb_id; 2997f48298d3SIoana Ciornei fdb->in_use = true; 2998f48298d3SIoana Ciornei fdb->bridge_dev = NULL; 2999f48298d3SIoana Ciornei port_priv->fdb = fdb; 3000f48298d3SIoana Ciornei 3001f48298d3SIoana Ciornei /* We need to add VLAN 1 as the PVID on this port until it is under a 3002f48298d3SIoana Ciornei * bridge since the DPAA2 switch is not able to handle the traffic in a 3003f48298d3SIoana Ciornei * VLAN unaware fashion 3004f48298d3SIoana Ciornei */ 3005f48298d3SIoana Ciornei err = dpaa2_switch_port_vlans_add(netdev, &vlan); 3006f48298d3SIoana Ciornei if (err) 3007f48298d3SIoana Ciornei return err; 3008f48298d3SIoana Ciornei 3009f48298d3SIoana Ciornei /* Setup the egress flooding domains (broadcast, unknown unicast */ 3010f48298d3SIoana Ciornei err = dpaa2_switch_fdb_set_egress_flood(ethsw, port_priv->fdb->fdb_id); 3011f48298d3SIoana Ciornei if (err) 3012f48298d3SIoana Ciornei return err; 3013f48298d3SIoana Ciornei 301490f07102SIoana Ciornei /* Create an ACL table to be used by this switch port */ 301590f07102SIoana Ciornei acl_cfg.max_entries = DPAA2_ETHSW_PORT_MAX_ACL_ENTRIES; 301690f07102SIoana Ciornei err = dpsw_acl_add(ethsw->mc_io, 0, ethsw->dpsw_handle, 30171b0f14b6SIoana Ciornei &acl_tbl_id, &acl_cfg); 301890f07102SIoana Ciornei if (err) { 301990f07102SIoana Ciornei netdev_err(netdev, "dpsw_acl_add err %d\n", err); 302090f07102SIoana Ciornei return err; 302190f07102SIoana Ciornei } 302290f07102SIoana Ciornei 30231b0f14b6SIoana Ciornei acl_tbl = dpaa2_switch_acl_tbl_get_unused(ethsw); 30241110318dSIoana Ciornei acl_tbl->ethsw = ethsw; 30251b0f14b6SIoana Ciornei acl_tbl->id = acl_tbl_id; 30261b0f14b6SIoana Ciornei acl_tbl->in_use = true; 30271b0f14b6SIoana Ciornei acl_tbl->num_rules = 0; 30281110318dSIoana Ciornei INIT_LIST_HEAD(&acl_tbl->entries); 30291110318dSIoana Ciornei 30301110318dSIoana Ciornei err = dpaa2_switch_port_acl_tbl_bind(port_priv, acl_tbl); 30311110318dSIoana Ciornei if (err) 30321110318dSIoana Ciornei return err; 30331b0f14b6SIoana Ciornei 30341a64ed12SIoana Ciornei err = dpaa2_switch_port_trap_mac_addr(port_priv, stpa); 30351a64ed12SIoana Ciornei if (err) 30361a64ed12SIoana Ciornei return err; 30371a64ed12SIoana Ciornei 3038f48298d3SIoana Ciornei return err; 3039f48298d3SIoana Ciornei } 3040f48298d3SIoana Ciornei 3041f48298d3SIoana Ciornei static void dpaa2_switch_takedown(struct fsl_mc_device *sw_dev) 3042f48298d3SIoana Ciornei { 3043f48298d3SIoana Ciornei struct device *dev = &sw_dev->dev; 3044f48298d3SIoana Ciornei struct ethsw_core *ethsw = dev_get_drvdata(dev); 3045f48298d3SIoana Ciornei int err; 3046f48298d3SIoana Ciornei 3047f48298d3SIoana Ciornei err = dpsw_close(ethsw->mc_io, 0, ethsw->dpsw_handle); 3048f48298d3SIoana Ciornei if (err) 3049f48298d3SIoana Ciornei dev_warn(dev, "dpsw_close err %d\n", err); 3050f48298d3SIoana Ciornei } 3051f48298d3SIoana Ciornei 3052f48298d3SIoana Ciornei static void dpaa2_switch_ctrl_if_teardown(struct ethsw_core *ethsw) 3053f48298d3SIoana Ciornei { 3054f48298d3SIoana Ciornei dpsw_ctrl_if_disable(ethsw->mc_io, 0, ethsw->dpsw_handle); 3055f48298d3SIoana Ciornei dpaa2_switch_free_dpio(ethsw); 3056f48298d3SIoana Ciornei dpaa2_switch_destroy_rings(ethsw); 3057f48298d3SIoana Ciornei dpaa2_switch_drain_bp(ethsw); 3058f48298d3SIoana Ciornei dpaa2_switch_free_dpbp(ethsw); 3059f48298d3SIoana Ciornei } 3060f48298d3SIoana Ciornei 3061f48298d3SIoana Ciornei static int dpaa2_switch_remove(struct fsl_mc_device *sw_dev) 3062f48298d3SIoana Ciornei { 3063f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv; 3064f48298d3SIoana Ciornei struct ethsw_core *ethsw; 3065f48298d3SIoana Ciornei struct device *dev; 3066f48298d3SIoana Ciornei int i; 3067f48298d3SIoana Ciornei 3068f48298d3SIoana Ciornei dev = &sw_dev->dev; 3069f48298d3SIoana Ciornei ethsw = dev_get_drvdata(dev); 3070f48298d3SIoana Ciornei 3071f48298d3SIoana Ciornei dpaa2_switch_ctrl_if_teardown(ethsw); 3072f48298d3SIoana Ciornei 3073f48298d3SIoana Ciornei dpaa2_switch_teardown_irqs(sw_dev); 3074f48298d3SIoana Ciornei 3075f48298d3SIoana Ciornei dpsw_disable(ethsw->mc_io, 0, ethsw->dpsw_handle); 3076f48298d3SIoana Ciornei 3077f48298d3SIoana Ciornei for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 3078f48298d3SIoana Ciornei port_priv = ethsw->ports[i]; 3079f48298d3SIoana Ciornei unregister_netdev(port_priv->netdev); 3080f48298d3SIoana Ciornei free_netdev(port_priv->netdev); 3081f48298d3SIoana Ciornei } 3082f48298d3SIoana Ciornei 3083f48298d3SIoana Ciornei kfree(ethsw->fdbs); 30841b0f14b6SIoana Ciornei kfree(ethsw->acls); 3085f48298d3SIoana Ciornei kfree(ethsw->ports); 3086f48298d3SIoana Ciornei 3087f48298d3SIoana Ciornei dpaa2_switch_takedown(sw_dev); 3088f48298d3SIoana Ciornei 3089f48298d3SIoana Ciornei destroy_workqueue(ethsw->workqueue); 3090f48298d3SIoana Ciornei 3091f48298d3SIoana Ciornei fsl_mc_portal_free(ethsw->mc_io); 3092f48298d3SIoana Ciornei 3093f48298d3SIoana Ciornei kfree(ethsw); 3094f48298d3SIoana Ciornei 3095f48298d3SIoana Ciornei dev_set_drvdata(dev, NULL); 3096f48298d3SIoana Ciornei 3097f48298d3SIoana Ciornei return 0; 3098f48298d3SIoana Ciornei } 3099f48298d3SIoana Ciornei 3100f48298d3SIoana Ciornei static int dpaa2_switch_probe_port(struct ethsw_core *ethsw, 3101f48298d3SIoana Ciornei u16 port_idx) 3102f48298d3SIoana Ciornei { 3103f48298d3SIoana Ciornei struct ethsw_port_priv *port_priv; 3104f48298d3SIoana Ciornei struct device *dev = ethsw->dev; 3105f48298d3SIoana Ciornei struct net_device *port_netdev; 3106f48298d3SIoana Ciornei int err; 3107f48298d3SIoana Ciornei 3108f48298d3SIoana Ciornei port_netdev = alloc_etherdev(sizeof(struct ethsw_port_priv)); 3109f48298d3SIoana Ciornei if (!port_netdev) { 3110f48298d3SIoana Ciornei dev_err(dev, "alloc_etherdev error\n"); 3111f48298d3SIoana Ciornei return -ENOMEM; 3112f48298d3SIoana Ciornei } 3113f48298d3SIoana Ciornei 3114f48298d3SIoana Ciornei port_priv = netdev_priv(port_netdev); 3115f48298d3SIoana Ciornei port_priv->netdev = port_netdev; 3116f48298d3SIoana Ciornei port_priv->ethsw_data = ethsw; 3117f48298d3SIoana Ciornei 3118f48298d3SIoana Ciornei port_priv->idx = port_idx; 3119f48298d3SIoana Ciornei port_priv->stp_state = BR_STATE_FORWARDING; 3120f48298d3SIoana Ciornei 3121f48298d3SIoana Ciornei SET_NETDEV_DEV(port_netdev, dev); 3122f48298d3SIoana Ciornei port_netdev->netdev_ops = &dpaa2_switch_port_ops; 3123f48298d3SIoana Ciornei port_netdev->ethtool_ops = &dpaa2_switch_port_ethtool_ops; 3124f48298d3SIoana Ciornei 3125f48298d3SIoana Ciornei port_netdev->needed_headroom = DPAA2_SWITCH_NEEDED_HEADROOM; 3126f48298d3SIoana Ciornei 3127b54eb093SIoana Ciornei port_priv->bcast_flood = true; 31286253d5e3SIoana Ciornei port_priv->ucast_flood = true; 3129b54eb093SIoana Ciornei 3130f48298d3SIoana Ciornei /* Set MTU limits */ 3131f48298d3SIoana Ciornei port_netdev->min_mtu = ETH_MIN_MTU; 3132f48298d3SIoana Ciornei port_netdev->max_mtu = ETHSW_MAX_FRAME_LENGTH; 3133f48298d3SIoana Ciornei 3134f48298d3SIoana Ciornei /* Populate the private port structure so that later calls to 3135f48298d3SIoana Ciornei * dpaa2_switch_port_init() can use it. 3136f48298d3SIoana Ciornei */ 3137f48298d3SIoana Ciornei ethsw->ports[port_idx] = port_priv; 3138f48298d3SIoana Ciornei 3139f48298d3SIoana Ciornei /* The DPAA2 switch's ingress path depends on the VLAN table, 3140f48298d3SIoana Ciornei * thus we are not able to disable VLAN filtering. 3141f48298d3SIoana Ciornei */ 31421110318dSIoana Ciornei port_netdev->features = NETIF_F_HW_VLAN_CTAG_FILTER | 31431110318dSIoana Ciornei NETIF_F_HW_VLAN_STAG_FILTER | 31441110318dSIoana Ciornei NETIF_F_HW_TC; 3145f48298d3SIoana Ciornei 3146f48298d3SIoana Ciornei err = dpaa2_switch_port_init(port_priv, port_idx); 3147f48298d3SIoana Ciornei if (err) 3148f48298d3SIoana Ciornei goto err_port_probe; 3149f48298d3SIoana Ciornei 3150f48298d3SIoana Ciornei err = dpaa2_switch_port_set_mac_addr(port_priv); 3151f48298d3SIoana Ciornei if (err) 3152f48298d3SIoana Ciornei goto err_port_probe; 3153f48298d3SIoana Ciornei 31541e7cbabfSIoana Ciornei err = dpaa2_switch_port_set_learning(port_priv, false); 31551e7cbabfSIoana Ciornei if (err) 31561e7cbabfSIoana Ciornei goto err_port_probe; 315762734c74SIoana Ciornei port_priv->learn_ena = false; 31581e7cbabfSIoana Ciornei 3159f48298d3SIoana Ciornei return 0; 3160f48298d3SIoana Ciornei 3161f48298d3SIoana Ciornei err_port_probe: 3162f48298d3SIoana Ciornei free_netdev(port_netdev); 3163f48298d3SIoana Ciornei ethsw->ports[port_idx] = NULL; 3164f48298d3SIoana Ciornei 3165f48298d3SIoana Ciornei return err; 3166f48298d3SIoana Ciornei } 3167f48298d3SIoana Ciornei 3168f48298d3SIoana Ciornei static int dpaa2_switch_probe(struct fsl_mc_device *sw_dev) 3169f48298d3SIoana Ciornei { 3170f48298d3SIoana Ciornei struct device *dev = &sw_dev->dev; 3171f48298d3SIoana Ciornei struct ethsw_core *ethsw; 3172f48298d3SIoana Ciornei int i, err; 3173f48298d3SIoana Ciornei 3174f48298d3SIoana Ciornei /* Allocate switch core*/ 3175f48298d3SIoana Ciornei ethsw = kzalloc(sizeof(*ethsw), GFP_KERNEL); 3176f48298d3SIoana Ciornei 3177f48298d3SIoana Ciornei if (!ethsw) 3178f48298d3SIoana Ciornei return -ENOMEM; 3179f48298d3SIoana Ciornei 3180f48298d3SIoana Ciornei ethsw->dev = dev; 3181f48298d3SIoana Ciornei ethsw->iommu_domain = iommu_get_domain_for_dev(dev); 3182f48298d3SIoana Ciornei dev_set_drvdata(dev, ethsw); 3183f48298d3SIoana Ciornei 3184f48298d3SIoana Ciornei err = fsl_mc_portal_allocate(sw_dev, FSL_MC_IO_ATOMIC_CONTEXT_PORTAL, 3185f48298d3SIoana Ciornei ðsw->mc_io); 3186f48298d3SIoana Ciornei if (err) { 3187f48298d3SIoana Ciornei if (err == -ENXIO) 3188f48298d3SIoana Ciornei err = -EPROBE_DEFER; 3189f48298d3SIoana Ciornei else 3190f48298d3SIoana Ciornei dev_err(dev, "fsl_mc_portal_allocate err %d\n", err); 3191f48298d3SIoana Ciornei goto err_free_drvdata; 3192f48298d3SIoana Ciornei } 3193f48298d3SIoana Ciornei 3194f48298d3SIoana Ciornei err = dpaa2_switch_init(sw_dev); 3195f48298d3SIoana Ciornei if (err) 3196f48298d3SIoana Ciornei goto err_free_cmdport; 3197f48298d3SIoana Ciornei 3198f48298d3SIoana Ciornei ethsw->ports = kcalloc(ethsw->sw_attr.num_ifs, sizeof(*ethsw->ports), 3199f48298d3SIoana Ciornei GFP_KERNEL); 3200f48298d3SIoana Ciornei if (!(ethsw->ports)) { 3201f48298d3SIoana Ciornei err = -ENOMEM; 3202f48298d3SIoana Ciornei goto err_takedown; 3203f48298d3SIoana Ciornei } 3204f48298d3SIoana Ciornei 3205f48298d3SIoana Ciornei ethsw->fdbs = kcalloc(ethsw->sw_attr.num_ifs, sizeof(*ethsw->fdbs), 3206f48298d3SIoana Ciornei GFP_KERNEL); 3207f48298d3SIoana Ciornei if (!ethsw->fdbs) { 3208f48298d3SIoana Ciornei err = -ENOMEM; 3209f48298d3SIoana Ciornei goto err_free_ports; 3210f48298d3SIoana Ciornei } 3211f48298d3SIoana Ciornei 32121b0f14b6SIoana Ciornei ethsw->acls = kcalloc(ethsw->sw_attr.num_ifs, sizeof(*ethsw->acls), 32131b0f14b6SIoana Ciornei GFP_KERNEL); 32141b0f14b6SIoana Ciornei if (!ethsw->acls) { 32151b0f14b6SIoana Ciornei err = -ENOMEM; 32161b0f14b6SIoana Ciornei goto err_free_fdbs; 32171b0f14b6SIoana Ciornei } 32181b0f14b6SIoana Ciornei 3219f48298d3SIoana Ciornei for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 3220f48298d3SIoana Ciornei err = dpaa2_switch_probe_port(ethsw, i); 3221f48298d3SIoana Ciornei if (err) 3222f48298d3SIoana Ciornei goto err_free_netdev; 3223f48298d3SIoana Ciornei } 3224f48298d3SIoana Ciornei 3225f48298d3SIoana Ciornei /* Add a NAPI instance for each of the Rx queues. The first port's 3226f48298d3SIoana Ciornei * net_device will be associated with the instances since we do not have 3227f48298d3SIoana Ciornei * different queues for each switch ports. 3228f48298d3SIoana Ciornei */ 3229f48298d3SIoana Ciornei for (i = 0; i < DPAA2_SWITCH_RX_NUM_FQS; i++) 3230f48298d3SIoana Ciornei netif_napi_add(ethsw->ports[0]->netdev, 3231f48298d3SIoana Ciornei ðsw->fq[i].napi, dpaa2_switch_poll, 3232f48298d3SIoana Ciornei NAPI_POLL_WEIGHT); 3233f48298d3SIoana Ciornei 3234f48298d3SIoana Ciornei err = dpsw_enable(ethsw->mc_io, 0, ethsw->dpsw_handle); 3235f48298d3SIoana Ciornei if (err) { 3236f48298d3SIoana Ciornei dev_err(ethsw->dev, "dpsw_enable err %d\n", err); 3237f48298d3SIoana Ciornei goto err_free_netdev; 3238f48298d3SIoana Ciornei } 3239f48298d3SIoana Ciornei 3240f48298d3SIoana Ciornei /* Setup IRQs */ 3241f48298d3SIoana Ciornei err = dpaa2_switch_setup_irqs(sw_dev); 3242f48298d3SIoana Ciornei if (err) 3243f48298d3SIoana Ciornei goto err_stop; 3244f48298d3SIoana Ciornei 3245f48298d3SIoana Ciornei /* Register the netdev only when the entire setup is done and the 3246f48298d3SIoana Ciornei * switch port interfaces are ready to receive traffic 3247f48298d3SIoana Ciornei */ 3248f48298d3SIoana Ciornei for (i = 0; i < ethsw->sw_attr.num_ifs; i++) { 3249f48298d3SIoana Ciornei err = register_netdev(ethsw->ports[i]->netdev); 3250f48298d3SIoana Ciornei if (err < 0) { 3251f48298d3SIoana Ciornei dev_err(dev, "register_netdev error %d\n", err); 3252f48298d3SIoana Ciornei goto err_unregister_ports; 3253f48298d3SIoana Ciornei } 3254f48298d3SIoana Ciornei } 3255f48298d3SIoana Ciornei 3256f48298d3SIoana Ciornei return 0; 3257f48298d3SIoana Ciornei 3258f48298d3SIoana Ciornei err_unregister_ports: 3259f48298d3SIoana Ciornei for (i--; i >= 0; i--) 3260f48298d3SIoana Ciornei unregister_netdev(ethsw->ports[i]->netdev); 3261f48298d3SIoana Ciornei dpaa2_switch_teardown_irqs(sw_dev); 3262f48298d3SIoana Ciornei err_stop: 3263f48298d3SIoana Ciornei dpsw_disable(ethsw->mc_io, 0, ethsw->dpsw_handle); 3264f48298d3SIoana Ciornei err_free_netdev: 3265f48298d3SIoana Ciornei for (i--; i >= 0; i--) 3266f48298d3SIoana Ciornei free_netdev(ethsw->ports[i]->netdev); 32671b0f14b6SIoana Ciornei kfree(ethsw->acls); 32681b0f14b6SIoana Ciornei err_free_fdbs: 3269f48298d3SIoana Ciornei kfree(ethsw->fdbs); 3270f48298d3SIoana Ciornei err_free_ports: 3271f48298d3SIoana Ciornei kfree(ethsw->ports); 3272f48298d3SIoana Ciornei 3273f48298d3SIoana Ciornei err_takedown: 3274f48298d3SIoana Ciornei dpaa2_switch_takedown(sw_dev); 3275f48298d3SIoana Ciornei 3276f48298d3SIoana Ciornei err_free_cmdport: 3277f48298d3SIoana Ciornei fsl_mc_portal_free(ethsw->mc_io); 3278f48298d3SIoana Ciornei 3279f48298d3SIoana Ciornei err_free_drvdata: 3280f48298d3SIoana Ciornei kfree(ethsw); 3281f48298d3SIoana Ciornei dev_set_drvdata(dev, NULL); 3282f48298d3SIoana Ciornei 3283f48298d3SIoana Ciornei return err; 3284f48298d3SIoana Ciornei } 3285f48298d3SIoana Ciornei 3286f48298d3SIoana Ciornei static const struct fsl_mc_device_id dpaa2_switch_match_id_table[] = { 3287f48298d3SIoana Ciornei { 3288f48298d3SIoana Ciornei .vendor = FSL_MC_VENDOR_FREESCALE, 3289f48298d3SIoana Ciornei .obj_type = "dpsw", 3290f48298d3SIoana Ciornei }, 3291f48298d3SIoana Ciornei { .vendor = 0x0 } 3292f48298d3SIoana Ciornei }; 3293f48298d3SIoana Ciornei MODULE_DEVICE_TABLE(fslmc, dpaa2_switch_match_id_table); 3294f48298d3SIoana Ciornei 3295f48298d3SIoana Ciornei static struct fsl_mc_driver dpaa2_switch_drv = { 3296f48298d3SIoana Ciornei .driver = { 3297f48298d3SIoana Ciornei .name = KBUILD_MODNAME, 3298f48298d3SIoana Ciornei .owner = THIS_MODULE, 3299f48298d3SIoana Ciornei }, 3300f48298d3SIoana Ciornei .probe = dpaa2_switch_probe, 3301f48298d3SIoana Ciornei .remove = dpaa2_switch_remove, 3302f48298d3SIoana Ciornei .match_id_table = dpaa2_switch_match_id_table 3303f48298d3SIoana Ciornei }; 3304f48298d3SIoana Ciornei 3305f48298d3SIoana Ciornei static struct notifier_block dpaa2_switch_port_nb __read_mostly = { 3306f48298d3SIoana Ciornei .notifier_call = dpaa2_switch_port_netdevice_event, 3307f48298d3SIoana Ciornei }; 3308f48298d3SIoana Ciornei 3309f48298d3SIoana Ciornei static struct notifier_block dpaa2_switch_port_switchdev_nb = { 3310f48298d3SIoana Ciornei .notifier_call = dpaa2_switch_port_event, 3311f48298d3SIoana Ciornei }; 3312f48298d3SIoana Ciornei 3313f48298d3SIoana Ciornei static struct notifier_block dpaa2_switch_port_switchdev_blocking_nb = { 3314f48298d3SIoana Ciornei .notifier_call = dpaa2_switch_port_blocking_event, 3315f48298d3SIoana Ciornei }; 3316f48298d3SIoana Ciornei 3317f48298d3SIoana Ciornei static int dpaa2_switch_register_notifiers(void) 3318f48298d3SIoana Ciornei { 3319f48298d3SIoana Ciornei int err; 3320f48298d3SIoana Ciornei 3321f48298d3SIoana Ciornei err = register_netdevice_notifier(&dpaa2_switch_port_nb); 3322f48298d3SIoana Ciornei if (err) { 3323f48298d3SIoana Ciornei pr_err("dpaa2-switch: failed to register net_device notifier (%d)\n", err); 3324f48298d3SIoana Ciornei return err; 3325f48298d3SIoana Ciornei } 3326f48298d3SIoana Ciornei 3327f48298d3SIoana Ciornei err = register_switchdev_notifier(&dpaa2_switch_port_switchdev_nb); 3328f48298d3SIoana Ciornei if (err) { 3329f48298d3SIoana Ciornei pr_err("dpaa2-switch: failed to register switchdev notifier (%d)\n", err); 3330f48298d3SIoana Ciornei goto err_switchdev_nb; 3331f48298d3SIoana Ciornei } 3332f48298d3SIoana Ciornei 3333f48298d3SIoana Ciornei err = register_switchdev_blocking_notifier(&dpaa2_switch_port_switchdev_blocking_nb); 3334f48298d3SIoana Ciornei if (err) { 3335f48298d3SIoana Ciornei pr_err("dpaa2-switch: failed to register switchdev blocking notifier (%d)\n", err); 3336f48298d3SIoana Ciornei goto err_switchdev_blocking_nb; 3337f48298d3SIoana Ciornei } 3338f48298d3SIoana Ciornei 3339f48298d3SIoana Ciornei return 0; 3340f48298d3SIoana Ciornei 3341f48298d3SIoana Ciornei err_switchdev_blocking_nb: 3342f48298d3SIoana Ciornei unregister_switchdev_notifier(&dpaa2_switch_port_switchdev_nb); 3343f48298d3SIoana Ciornei err_switchdev_nb: 3344f48298d3SIoana Ciornei unregister_netdevice_notifier(&dpaa2_switch_port_nb); 3345f48298d3SIoana Ciornei 3346f48298d3SIoana Ciornei return err; 3347f48298d3SIoana Ciornei } 3348f48298d3SIoana Ciornei 3349f48298d3SIoana Ciornei static void dpaa2_switch_unregister_notifiers(void) 3350f48298d3SIoana Ciornei { 3351f48298d3SIoana Ciornei int err; 3352f48298d3SIoana Ciornei 3353f48298d3SIoana Ciornei err = unregister_switchdev_blocking_notifier(&dpaa2_switch_port_switchdev_blocking_nb); 3354f48298d3SIoana Ciornei if (err) 3355f48298d3SIoana Ciornei pr_err("dpaa2-switch: failed to unregister switchdev blocking notifier (%d)\n", 3356f48298d3SIoana Ciornei err); 3357f48298d3SIoana Ciornei 3358f48298d3SIoana Ciornei err = unregister_switchdev_notifier(&dpaa2_switch_port_switchdev_nb); 3359f48298d3SIoana Ciornei if (err) 3360f48298d3SIoana Ciornei pr_err("dpaa2-switch: failed to unregister switchdev notifier (%d)\n", err); 3361f48298d3SIoana Ciornei 3362f48298d3SIoana Ciornei err = unregister_netdevice_notifier(&dpaa2_switch_port_nb); 3363f48298d3SIoana Ciornei if (err) 3364f48298d3SIoana Ciornei pr_err("dpaa2-switch: failed to unregister net_device notifier (%d)\n", err); 3365f48298d3SIoana Ciornei } 3366f48298d3SIoana Ciornei 3367f48298d3SIoana Ciornei static int __init dpaa2_switch_driver_init(void) 3368f48298d3SIoana Ciornei { 3369f48298d3SIoana Ciornei int err; 3370f48298d3SIoana Ciornei 3371f48298d3SIoana Ciornei err = fsl_mc_driver_register(&dpaa2_switch_drv); 3372f48298d3SIoana Ciornei if (err) 3373f48298d3SIoana Ciornei return err; 3374f48298d3SIoana Ciornei 3375f48298d3SIoana Ciornei err = dpaa2_switch_register_notifiers(); 3376f48298d3SIoana Ciornei if (err) { 3377f48298d3SIoana Ciornei fsl_mc_driver_unregister(&dpaa2_switch_drv); 3378f48298d3SIoana Ciornei return err; 3379f48298d3SIoana Ciornei } 3380f48298d3SIoana Ciornei 3381f48298d3SIoana Ciornei return 0; 3382f48298d3SIoana Ciornei } 3383f48298d3SIoana Ciornei 3384f48298d3SIoana Ciornei static void __exit dpaa2_switch_driver_exit(void) 3385f48298d3SIoana Ciornei { 3386f48298d3SIoana Ciornei dpaa2_switch_unregister_notifiers(); 3387f48298d3SIoana Ciornei fsl_mc_driver_unregister(&dpaa2_switch_drv); 3388f48298d3SIoana Ciornei } 3389f48298d3SIoana Ciornei 3390f48298d3SIoana Ciornei module_init(dpaa2_switch_driver_init); 3391f48298d3SIoana Ciornei module_exit(dpaa2_switch_driver_exit); 3392f48298d3SIoana Ciornei 3393f48298d3SIoana Ciornei MODULE_LICENSE("GPL v2"); 3394f48298d3SIoana Ciornei MODULE_DESCRIPTION("DPAA2 Ethernet Switch Driver"); 3395