/* There are 8 priorities */
        for (i = 0; i < 8; ++i)
                lan_rmw(ANA_FLOODING_FLD_MULTICAST_SET(PGID_MC) |
+                       ANA_FLOODING_FLD_UNICAST_SET(PGID_UC) |
                        ANA_FLOODING_FLD_BROADCAST_SET(PGID_BC),
                        ANA_FLOODING_FLD_MULTICAST |
+                       ANA_FLOODING_FLD_UNICAST |
                        ANA_FLOODING_FLD_BROADCAST,
                        lan966x, ANA_FLOODING(i));
 
                ANA_PGID_PGID,
                lan966x, ANA_PGID(PGID_MCIPV4));
 
+       /* Unicast to all other ports */
+       lan_rmw(GENMASK(lan966x->num_phys_ports - 1, 0),
+               ANA_PGID_PGID,
+               lan966x, ANA_PGID(PGID_UC));
+
        /* Broadcast to the CPU port and to other ports */
        lan_rmw(ANA_PGID_PGID_SET(BIT(CPU_PORT) | GENMASK(lan966x->num_phys_ports - 1, 0)),
                ANA_PGID_PGID,
 
 /*      ANA:ANA:FLOODING */
 #define ANA_FLOODING(r)           __REG(TARGET_ANA, 0, 1, 29824, 0, 1, 244, 68, r, 8, 4)
 
+#define ANA_FLOODING_FLD_UNICAST                 GENMASK(17, 12)
+#define ANA_FLOODING_FLD_UNICAST_SET(x)\
+       FIELD_PREP(ANA_FLOODING_FLD_UNICAST, x)
+#define ANA_FLOODING_FLD_UNICAST_GET(x)\
+       FIELD_GET(ANA_FLOODING_FLD_UNICAST, x)
+
 #define ANA_FLOODING_FLD_BROADCAST               GENMASK(11, 6)
 #define ANA_FLOODING_FLD_BROADCAST_SET(x)\
        FIELD_PREP(ANA_FLOODING_FLD_BROADCAST, x)
 
                port->lan966x, ANA_PGID(PGID_MC));
 }
 
+static void lan966x_port_set_ucast_flood(struct lan966x_port *port,
+                                        bool enabled)
+{
+       u32 val = lan_rd(port->lan966x, ANA_PGID(PGID_UC));
+
+       val = ANA_PGID_PGID_GET(val);
+       if (enabled)
+               val |= BIT(port->chip_port);
+       else
+               val &= ~BIT(port->chip_port);
+
+       lan_rmw(ANA_PGID_PGID_SET(val),
+               ANA_PGID_PGID,
+               port->lan966x, ANA_PGID(PGID_UC));
+}
+
+static void lan966x_port_set_bcast_flood(struct lan966x_port *port,
+                                        bool enabled)
+{
+       u32 val = lan_rd(port->lan966x, ANA_PGID(PGID_BC));
+
+       val = ANA_PGID_PGID_GET(val);
+       if (enabled)
+               val |= BIT(port->chip_port);
+       else
+               val &= ~BIT(port->chip_port);
+
+       lan_rmw(ANA_PGID_PGID_SET(val),
+               ANA_PGID_PGID,
+               port->lan966x, ANA_PGID(PGID_BC));
+}
+
+static void lan966x_port_set_learning(struct lan966x_port *port, bool enabled)
+{
+       lan_rmw(ANA_PORT_CFG_LEARN_ENA_SET(enabled),
+               ANA_PORT_CFG_LEARN_ENA,
+               port->lan966x, ANA_PORT_CFG(port->chip_port));
+
+       port->learn_ena = enabled;
+}
+
 static void lan966x_port_bridge_flags(struct lan966x_port *port,
                                      struct switchdev_brport_flags flags)
 {
        if (flags.mask & BR_MCAST_FLOOD)
                lan966x_port_set_mcast_flood(port,
                                             !!(flags.val & BR_MCAST_FLOOD));
+
+       if (flags.mask & BR_FLOOD)
+               lan966x_port_set_ucast_flood(port,
+                                            !!(flags.val & BR_FLOOD));
+
+       if (flags.mask & BR_BCAST_FLOOD)
+               lan966x_port_set_bcast_flood(port,
+                                            !!(flags.val & BR_BCAST_FLOOD));
+
+       if (flags.mask & BR_LEARNING)
+               lan966x_port_set_learning(port,
+                                         !!(flags.val & BR_LEARNING));
 }
 
 static int lan966x_port_pre_bridge_flags(struct lan966x_port *port,
                                         struct switchdev_brport_flags flags)
 {
-       if (flags.mask & ~BR_MCAST_FLOOD)
+       if (flags.mask & ~(BR_MCAST_FLOOD | BR_FLOOD | BR_BCAST_FLOOD |
+                          BR_LEARNING))
                return -EINVAL;
 
        return 0;
        struct lan966x *lan966x = port->lan966x;
        bool learn_ena = false;
 
-       if (state == BR_STATE_FORWARDING || state == BR_STATE_LEARNING)
+       if ((state == BR_STATE_FORWARDING || state == BR_STATE_LEARNING) &&
+           port->learn_ena)
                learn_ena = true;
 
        if (state == BR_STATE_FORWARDING)
                                    struct net_device *bridge,
                                    struct netlink_ext_ack *extack)
 {
+       struct switchdev_brport_flags flags = {0};
        struct lan966x *lan966x = port->lan966x;
        struct net_device *dev = port->dev;
        int err;
 
        lan966x->bridge_mask |= BIT(port->chip_port);
 
+       flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
+       flags.val = flags.mask;
+       lan966x_port_bridge_flags(port, flags);
+
        return 0;
 }
 
 static void lan966x_port_bridge_leave(struct lan966x_port *port,
                                      struct net_device *bridge)
 {
+       struct switchdev_brport_flags flags = {0};
        struct lan966x *lan966x = port->lan966x;
 
+       flags.mask = BR_LEARNING | BR_FLOOD | BR_MCAST_FLOOD | BR_BCAST_FLOOD;
+       flags.val = flags.mask & ~BR_LEARNING;
+       lan966x_port_bridge_flags(port, flags);
+
        lan966x->bridge_mask &= ~BIT(port->chip_port);
 
        if (!lan966x->bridge_mask)