}
 EXPORT_SYMBOL(b53_phylink_mac_link_up);
 
-int b53_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering)
+int b53_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering,
+                      struct netlink_ext_ack *extack)
 {
        struct b53_device *dev = ds->priv;
 
 
                             struct phy_device *phydev,
                             int speed, int duplex,
                             bool tx_pause, bool rx_pause);
-int b53_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering);
+int b53_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering,
+                      struct netlink_ext_ack *extack);
 int b53_vlan_add(struct dsa_switch *ds, int port,
                 const struct switchdev_obj_port_vlan *vlan,
                 struct netlink_ext_ack *extack);
 
 }
 
 static int dsa_loop_port_vlan_filtering(struct dsa_switch *ds, int port,
-                                       bool vlan_filtering)
+                                       bool vlan_filtering,
+                                       struct netlink_ext_ack *extack)
 {
        dev_dbg(ds->dev, "%s: port: %d, vlan_filtering: %d\n",
                __func__, port, vlan_filtering);
 
 }
 
 static int hellcreek_vlan_filtering(struct dsa_switch *ds, int port,
-                                   bool vlan_filtering)
+                                   bool vlan_filtering,
+                                   struct netlink_ext_ack *extack)
 {
        struct hellcreek *hellcreek = ds->priv;
 
 
 }
 
 static int gswip_port_vlan_filtering(struct dsa_switch *ds, int port,
-                                    bool vlan_filtering)
+                                    bool vlan_filtering,
+                                    struct netlink_ext_ack *extack)
 {
        struct net_device *bridge = dsa_to_port(ds, port)->bridge_dev;
        struct gswip_priv *priv = ds->priv;
 
        /* Do not allow changing the VLAN filtering options while in bridge */
-       if (bridge && !!(priv->port_vlan_filter & BIT(port)) != vlan_filtering)
+       if (bridge && !!(priv->port_vlan_filter & BIT(port)) != vlan_filtering) {
+               NL_SET_ERR_MSG_MOD(extack,
+                                  "Dynamic toggling of vlan_filtering not supported");
                return -EIO;
+       }
 
        if (vlan_filtering) {
                /* Use port based VLAN tag */
        /* disable port fetch/store dma on all ports */
        for (i = 0; i < priv->hw_info->max_ports; i++) {
                gswip_port_disable(ds, i);
-               gswip_port_vlan_filtering(ds, i, false);
+               gswip_port_vlan_filtering(ds, i, false, NULL);
        }
 
        /* enable Switch */
 
 }
 
 static int ksz8795_port_vlan_filtering(struct dsa_switch *ds, int port,
-                                      bool flag)
+                                      bool flag,
+                                      struct netlink_ext_ack *extack)
 {
        struct ksz_device *dev = ds->priv;
 
 
 }
 
 static int ksz9477_port_vlan_filtering(struct dsa_switch *ds, int port,
-                                      bool flag)
+                                      bool flag,
+                                      struct netlink_ext_ack *extack)
 {
        struct ksz_device *dev = ds->priv;
 
 
 }
 
 static int
-mt7530_port_vlan_filtering(struct dsa_switch *ds, int port,
-                          bool vlan_filtering)
+mt7530_port_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering,
+                          struct netlink_ext_ack *extack)
 {
        if (vlan_filtering) {
                /* The port is being kept as VLAN-unaware port when bridge is
 
 }
 
 static int mv88e6xxx_port_vlan_filtering(struct dsa_switch *ds, int port,
-                                        bool vlan_filtering)
+                                        bool vlan_filtering,
+                                        struct netlink_ext_ack *extack)
 {
        struct mv88e6xxx_chip *chip = ds->priv;
        u16 mode = vlan_filtering ? MV88E6XXX_PORT_CTL2_8021Q_MODE_SECURE :
 
                                   flags & BRIDGE_VLAN_INFO_UNTAGGED);
 }
 
-static int felix_vlan_filtering(struct dsa_switch *ds, int port, bool enabled)
+static int felix_vlan_filtering(struct dsa_switch *ds, int port, bool enabled,
+                               struct netlink_ext_ack *extack)
 {
        struct ocelot *ocelot = ds->priv;
 
 
 }
 
 static int
-qca8k_port_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering)
+qca8k_port_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering,
+                         struct netlink_ext_ack *extack)
 {
        struct qca8k_priv *priv = ds->priv;
 
 
 int rtl8366_enable_vlan(struct realtek_smi *smi, bool enable);
 int rtl8366_reset_vlan(struct realtek_smi *smi);
 int rtl8366_init_vlan(struct realtek_smi *smi);
-int rtl8366_vlan_filtering(struct dsa_switch *ds, int port,
-                          bool vlan_filtering);
+int rtl8366_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering,
+                          struct netlink_ext_ack *extack);
 int rtl8366_vlan_add(struct dsa_switch *ds, int port,
                     const struct switchdev_obj_port_vlan *vlan,
                     struct netlink_ext_ack *extack);
 
 }
 EXPORT_SYMBOL_GPL(rtl8366_init_vlan);
 
-int rtl8366_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering)
+int rtl8366_vlan_filtering(struct dsa_switch *ds, int port, bool vlan_filtering,
+                          struct netlink_ext_ack *extack)
 {
        struct realtek_smi *smi = ds->priv;
        struct rtl8366_vlan_4k vlan4k;
 
 
 int sja1105_static_config_reload(struct sja1105_private *priv,
                                 enum sja1105_reset_reason reason);
-int sja1105_vlan_filtering(struct dsa_switch *ds, int port, bool enabled);
+int sja1105_vlan_filtering(struct dsa_switch *ds, int port, bool enabled,
+                          struct netlink_ext_ack *extack);
 void sja1105_frame_memory_partitioning(struct sja1105_private *priv);
 
 /* From sja1105_devlink.c */
 
                dp = dsa_to_port(ds, port);
                vlan_filtering = dsa_port_is_vlan_filtering(dp);
 
-               rc = sja1105_vlan_filtering(ds, port, vlan_filtering);
+               rc = sja1105_vlan_filtering(ds, port, vlan_filtering, NULL);
                if (rc)
                        break;
        }
 
  * which can only be partially reconfigured at runtime (and not the TPID).
  * So a switch reset is required.
  */
-int sja1105_vlan_filtering(struct dsa_switch *ds, int port, bool enabled)
+int sja1105_vlan_filtering(struct dsa_switch *ds, int port, bool enabled,
+                          struct netlink_ext_ack *extack)
 {
        struct sja1105_l2_lookup_params_entry *l2_lookup_params;
        struct sja1105_general_params_entry *general_params;
 
        list_for_each_entry(rule, &priv->flow_block.rules, list) {
                if (rule->type == SJA1105_RULE_VL) {
-                       dev_err(ds->dev,
-                               "Cannot change VLAN filtering with active VL rules\n");
+                       NL_SET_ERR_MSG_MOD(extack,
+                                          "Cannot change VLAN filtering with active VL rules");
                        return -EBUSY;
                }
        }
 
        rc = sja1105_static_config_reload(priv, SJA1105_VLAN_FILTERING);
        if (rc)
-               dev_err(ds->dev, "Failed to change VLAN Ethertype\n");
+               NL_SET_ERR_MSG_MOD(extack, "Failed to change VLAN Ethertype");
 
        /* Switch port identification based on 802.1Q is only passable
         * if we are not under a vlan_filtering bridge. So make sure
 
         * VLAN support
         */
        int     (*port_vlan_filtering)(struct dsa_switch *ds, int port,
-                                      bool vlan_filtering);
+                                      bool vlan_filtering,
+                                      struct netlink_ext_ack *extack);
        int     (*port_vlan_add)(struct dsa_switch *ds, int port,
                                 const struct switchdev_obj_port_vlan *vlan,
                                 struct netlink_ext_ack *extack);
 
 int dsa_port_lag_join(struct dsa_port *dp, struct net_device *lag_dev,
                      struct netdev_lag_upper_info *uinfo);
 void dsa_port_lag_leave(struct dsa_port *dp, struct net_device *lag_dev);
-int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering);
+int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
+                           struct netlink_ext_ack *extack);
 bool dsa_port_skip_vlan_configuration(struct dsa_port *dp);
 int dsa_port_ageing_time(struct dsa_port *dp, clock_t ageing_clock);
 int dsa_port_mtu_change(struct dsa_port *dp, int new_mtu,
 
 
 /* Must be called under rcu_read_lock() */
 static bool dsa_port_can_apply_vlan_filtering(struct dsa_port *dp,
-                                             bool vlan_filtering)
+                                             bool vlan_filtering,
+                                             struct netlink_ext_ack *extack)
 {
        struct dsa_switch *ds = dp->ds;
        int err, i;
                         */
                        err = br_vlan_get_info(br, vid, &br_info);
                        if (err == 0) {
-                               dev_err(ds->dev, "Must remove upper %s first\n",
-                                       upper_dev->name);
+                               NL_SET_ERR_MSG_MOD(extack,
+                                                  "Must first remove VLAN uppers having VIDs also present in bridge");
                                return false;
                        }
                }
                if (other_bridge == dp->bridge_dev)
                        continue;
                if (br_vlan_enabled(other_bridge) != vlan_filtering) {
-                       dev_err(ds->dev, "VLAN filtering is a global setting\n");
+                       NL_SET_ERR_MSG_MOD(extack,
+                                          "VLAN filtering is a global setting");
                        return false;
                }
        }
        return true;
 }
 
-int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering)
+int dsa_port_vlan_filtering(struct dsa_port *dp, bool vlan_filtering,
+                           struct netlink_ext_ack *extack)
 {
        struct dsa_switch *ds = dp->ds;
        bool apply;
         * dsa_slave_switchdev_event().
         */
        rcu_read_lock();
-       apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering);
+       apply = dsa_port_can_apply_vlan_filtering(dp, vlan_filtering, extack);
        rcu_read_unlock();
        if (!apply)
                return -EINVAL;
        if (dsa_port_is_vlan_filtering(dp) == vlan_filtering)
                return 0;
 
-       err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering);
+       err = ds->ops->port_vlan_filtering(ds, dp->index, vlan_filtering,
+                                          extack);
        if (err)
                return err;
 
 
                ret = dsa_port_set_state(dp, attr->u.stp_state);
                break;
        case SWITCHDEV_ATTR_ID_BRIDGE_VLAN_FILTERING:
-               ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering);
+               ret = dsa_port_vlan_filtering(dp, attr->u.vlan_filtering,
+                                             extack);
                break;
        case SWITCHDEV_ATTR_ID_BRIDGE_AGEING_TIME:
                ret = dsa_port_ageing_time(dp, attr->u.ageing_time);
 
 {
        bool unset_vlan_filtering = br_vlan_enabled(info->br);
        struct dsa_switch_tree *dst = ds->dst;
+       struct netlink_ext_ack extack = {0};
        int err, i;
 
        if (dst->index == info->tree_index && ds->index == info->sw_index &&
        }
        if (unset_vlan_filtering) {
                err = dsa_port_vlan_filtering(dsa_to_port(ds, info->port),
-                                             false);
+                                             false, &extack);
+               if (extack._msg)
+                       dev_err(ds->dev, "port %d: %s\n", info->port,
+                               extack._msg);
                if (err && err != EOPNOTSUPP)
                        return err;
        }