static void br_ip4_multicast_leave_group(struct net_bridge *br,
                                         struct net_bridge_port *port,
                                         __be32 group,
-                                        __u16 vid);
+                                        __u16 vid,
+                                        const unsigned char *src);
+
 #if IS_ENABLED(CONFIG_IPV6)
 static void br_ip6_multicast_leave_group(struct net_bridge *br,
                                         struct net_bridge_port *port,
                                         const struct in6_addr *group,
-                                        __u16 vid);
+                                        __u16 vid, const unsigned char *src);
 #endif
 unsigned int br_mdb_rehash_seq;
 
                        struct net_bridge_port *port,
                        struct br_ip *group,
                        struct net_bridge_port_group __rcu *next,
-                       unsigned char flags)
+                       unsigned char flags,
+                       const unsigned char *src)
 {
        struct net_bridge_port_group *p;
 
        hlist_add_head(&p->mglist, &port->mglist);
        setup_timer(&p->timer, br_multicast_port_group_expired,
                    (unsigned long)p);
+
+       if (src)
+               memcpy(p->eth_addr, src, ETH_ALEN);
+       else
+               memset(p->eth_addr, 0xff, ETH_ALEN);
+
        return p;
 }
 
+static bool br_port_group_equal(struct net_bridge_port_group *p,
+                               struct net_bridge_port *port,
+                               const unsigned char *src)
+{
+       if (p->port != port)
+               return false;
+
+       if (!(port->flags & BR_MULTICAST_TO_UNICAST))
+               return true;
+
+       return ether_addr_equal(src, p->eth_addr);
+}
+
 static int br_multicast_add_group(struct net_bridge *br,
                                  struct net_bridge_port *port,
-                                 struct br_ip *group)
+                                 struct br_ip *group,
+                                 const unsigned char *src)
 {
        struct net_bridge_port_group __rcu **pp;
        struct net_bridge_port_group *p;
        for (pp = &mp->ports;
             (p = mlock_dereference(*pp, br)) != NULL;
             pp = &p->next) {
-               if (p->port == port)
+               if (br_port_group_equal(p, port, src))
                        goto found;
                if ((unsigned long)p->port < (unsigned long)port)
                        break;
        }
 
-       p = br_multicast_new_port_group(port, group, *pp, 0);
+       p = br_multicast_new_port_group(port, group, *pp, 0, src);
        if (unlikely(!p))
                goto err;
        rcu_assign_pointer(*pp, p);
 static int br_ip4_multicast_add_group(struct net_bridge *br,
                                      struct net_bridge_port *port,
                                      __be32 group,
-                                     __u16 vid)
+                                     __u16 vid,
+                                     const unsigned char *src)
 {
        struct br_ip br_group;
 
        br_group.proto = htons(ETH_P_IP);
        br_group.vid = vid;
 
-       return br_multicast_add_group(br, port, &br_group);
+       return br_multicast_add_group(br, port, &br_group, src);
 }
 
 #if IS_ENABLED(CONFIG_IPV6)
 static int br_ip6_multicast_add_group(struct net_bridge *br,
                                      struct net_bridge_port *port,
                                      const struct in6_addr *group,
-                                     __u16 vid)
+                                     __u16 vid,
+                                     const unsigned char *src)
 {
        struct br_ip br_group;
 
        br_group.proto = htons(ETH_P_IPV6);
        br_group.vid = vid;
 
-       return br_multicast_add_group(br, port, &br_group);
+       return br_multicast_add_group(br, port, &br_group, src);
 }
 #endif
 
                                         struct sk_buff *skb,
                                         u16 vid)
 {
+       const unsigned char *src;
        struct igmpv3_report *ih;
        struct igmpv3_grec *grec;
        int i;
                        continue;
                }
 
+               src = eth_hdr(skb)->h_source;
                if ((type == IGMPV3_CHANGE_TO_INCLUDE ||
                     type == IGMPV3_MODE_IS_INCLUDE) &&
                    ntohs(grec->grec_nsrcs) == 0) {
-                       br_ip4_multicast_leave_group(br, port, group, vid);
+                       br_ip4_multicast_leave_group(br, port, group, vid, src);
                } else {
-                       err = br_ip4_multicast_add_group(br, port, group, vid);
+                       err = br_ip4_multicast_add_group(br, port, group, vid,
+                                                        src);
                        if (err)
                                break;
                }
                                        struct sk_buff *skb,
                                        u16 vid)
 {
+       const unsigned char *src;
        struct icmp6hdr *icmp6h;
        struct mld2_grec *grec;
        int i;
                        continue;
                }
 
+               src = eth_hdr(skb)->h_source;
                if ((grec->grec_type == MLD2_CHANGE_TO_INCLUDE ||
                     grec->grec_type == MLD2_MODE_IS_INCLUDE) &&
                    ntohs(*nsrcs) == 0) {
                        br_ip6_multicast_leave_group(br, port, &grec->grec_mca,
-                                                    vid);
+                                                    vid, src);
                } else {
                        err = br_ip6_multicast_add_group(br, port,
-                                                        &grec->grec_mca, vid);
+                                                        &grec->grec_mca, vid,
+                                                        src);
                        if (err)
                                break;
                }
                         struct net_bridge_port *port,
                         struct br_ip *group,
                         struct bridge_mcast_other_query *other_query,
-                        struct bridge_mcast_own_query *own_query)
+                        struct bridge_mcast_own_query *own_query,
+                        const unsigned char *src)
 {
        struct net_bridge_mdb_htable *mdb;
        struct net_bridge_mdb_entry *mp;
                for (pp = &mp->ports;
                     (p = mlock_dereference(*pp, br)) != NULL;
                     pp = &p->next) {
-                       if (p->port != port)
+                       if (!br_port_group_equal(p, port, src))
                                continue;
 
                        rcu_assign_pointer(*pp, p->next);
                for (p = mlock_dereference(mp->ports, br);
                     p != NULL;
                     p = mlock_dereference(p->next, br)) {
-                       if (p->port != port)
+                       if (!br_port_group_equal(p, port, src))
                                continue;
 
                        if (!hlist_unhashed(&p->mglist) &&
 static void br_ip4_multicast_leave_group(struct net_bridge *br,
                                         struct net_bridge_port *port,
                                         __be32 group,
-                                        __u16 vid)
+                                        __u16 vid,
+                                        const unsigned char *src)
 {
        struct br_ip br_group;
        struct bridge_mcast_own_query *own_query;
        br_group.vid = vid;
 
        br_multicast_leave_group(br, port, &br_group, &br->ip4_other_query,
-                                own_query);
+                                own_query, src);
 }
 
 #if IS_ENABLED(CONFIG_IPV6)
 static void br_ip6_multicast_leave_group(struct net_bridge *br,
                                         struct net_bridge_port *port,
                                         const struct in6_addr *group,
-                                        __u16 vid)
+                                        __u16 vid,
+                                        const unsigned char *src)
 {
        struct br_ip br_group;
        struct bridge_mcast_own_query *own_query;
        br_group.vid = vid;
 
        br_multicast_leave_group(br, port, &br_group, &br->ip6_other_query,
-                                own_query);
+                                own_query, src);
 }
 #endif
 
                                 u16 vid)
 {
        struct sk_buff *skb_trimmed = NULL;
+       const unsigned char *src;
        struct igmphdr *ih;
        int err;
 
        }
 
        ih = igmp_hdr(skb);
+       src = eth_hdr(skb)->h_source;
        BR_INPUT_SKB_CB(skb)->igmp = ih->type;
 
        switch (ih->type) {
        case IGMP_HOST_MEMBERSHIP_REPORT:
        case IGMPV2_HOST_MEMBERSHIP_REPORT:
                BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
-               err = br_ip4_multicast_add_group(br, port, ih->group, vid);
+               err = br_ip4_multicast_add_group(br, port, ih->group, vid, src);
                break;
        case IGMPV3_HOST_MEMBERSHIP_REPORT:
                err = br_ip4_multicast_igmp3_report(br, port, skb_trimmed, vid);
                err = br_ip4_multicast_query(br, port, skb_trimmed, vid);
                break;
        case IGMP_HOST_LEAVE_MESSAGE:
-               br_ip4_multicast_leave_group(br, port, ih->group, vid);
+               br_ip4_multicast_leave_group(br, port, ih->group, vid, src);
                break;
        }
 
                                 u16 vid)
 {
        struct sk_buff *skb_trimmed = NULL;
+       const unsigned char *src;
        struct mld_msg *mld;
        int err;
 
 
        switch (mld->mld_type) {
        case ICMPV6_MGM_REPORT:
+               src = eth_hdr(skb)->h_source;
                BR_INPUT_SKB_CB(skb)->mrouters_only = 1;
-               err = br_ip6_multicast_add_group(br, port, &mld->mld_mca, vid);
+               err = br_ip6_multicast_add_group(br, port, &mld->mld_mca, vid,
+                                                src);
                break;
        case ICMPV6_MLD2_REPORT:
                err = br_ip6_multicast_mld2_report(br, port, skb_trimmed, vid);
                err = br_ip6_multicast_query(br, port, skb_trimmed, vid);
                break;
        case ICMPV6_MGM_REDUCTION:
-               br_ip6_multicast_leave_group(br, port, &mld->mld_mca, vid);
+               src = eth_hdr(skb)->h_source;
+               br_ip6_multicast_leave_group(br, port, &mld->mld_mca, vid, src);
                break;
        }
 
 
                + nla_total_size(1)     /* IFLA_BRPORT_GUARD */
                + nla_total_size(1)     /* IFLA_BRPORT_PROTECT */
                + nla_total_size(1)     /* IFLA_BRPORT_FAST_LEAVE */
+               + nla_total_size(1)     /* IFLA_BRPORT_MCAST_TO_UCAST */
                + nla_total_size(1)     /* IFLA_BRPORT_LEARNING */
                + nla_total_size(1)     /* IFLA_BRPORT_UNICAST_FLOOD */
                + nla_total_size(1)     /* IFLA_BRPORT_PROXYARP */
                       !!(p->flags & BR_ROOT_BLOCK)) ||
            nla_put_u8(skb, IFLA_BRPORT_FAST_LEAVE,
                       !!(p->flags & BR_MULTICAST_FAST_LEAVE)) ||
+           nla_put_u8(skb, IFLA_BRPORT_MCAST_TO_UCAST,
+                      !!(p->flags & BR_MULTICAST_TO_UNICAST)) ||
            nla_put_u8(skb, IFLA_BRPORT_LEARNING, !!(p->flags & BR_LEARNING)) ||
            nla_put_u8(skb, IFLA_BRPORT_UNICAST_FLOOD,
                       !!(p->flags & BR_FLOOD)) ||
        [IFLA_BRPORT_PROXYARP]  = { .type = NLA_U8 },
        [IFLA_BRPORT_PROXYARP_WIFI] = { .type = NLA_U8 },
        [IFLA_BRPORT_MULTICAST_ROUTER] = { .type = NLA_U8 },
+       [IFLA_BRPORT_MCAST_TO_UCAST] = { .type = NLA_U8 },
 };
 
 /* Change the state of the port and notify spanning tree */
        br_set_port_flag(p, tb, IFLA_BRPORT_LEARNING, BR_LEARNING);
        br_set_port_flag(p, tb, IFLA_BRPORT_UNICAST_FLOOD, BR_FLOOD);
        br_set_port_flag(p, tb, IFLA_BRPORT_MCAST_FLOOD, BR_MCAST_FLOOD);
+       br_set_port_flag(p, tb, IFLA_BRPORT_MCAST_TO_UCAST, BR_MULTICAST_TO_UNICAST);
        br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP, BR_PROXYARP);
        br_set_port_flag(p, tb, IFLA_BRPORT_PROXYARP_WIFI, BR_PROXYARP_WIFI);