int     (*tx_control_port)(struct wiphy *wiphy,
                                   struct net_device *dev,
                                   const u8 *buf, size_t len,
-                                  const u8 *dest, const u8 *src,
-                                  const __be16 proto,
+                                  const u8 *dest, const __be16 proto,
                                   const bool noencrypt);
 
        int     (*get_ftm_responder_stats)(struct wiphy *wiphy,
 
  *     a control port frame and as a notification that a control port frame
  *     has been received. %NL80211_ATTR_FRAME is used to specify the
  *     frame contents.  The frame is the raw EAPoL data, without ethernet or
- *     802.11 headers. An optional %NL80211_ATTR_SRC_MAC can be used to send
- *     pre-auth frames to STAs on behalf of other APs.
+ *     802.11 headers.
  *     When used as an event indication %NL80211_ATTR_CONTROL_PORT_ETHERTYPE,
  *     %NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT and %NL80211_ATTR_MAC are added
  *     indicating the protocol type of the received frame; whether the frame
  *     was received unencrypted and the MAC address of the peer respectively.
- *     %NL80211_ATTR_DST_MAC can be used to forward pre-auth frames in
- *     userspace while using AP mode.
  *
  * @NL80211_CMD_RELOAD_REGDB: Request that the regdb firmware file is reloaded.
  *
  *     %NL80211_ATTR_AKM_SUITES are default capabilities if AKM suites not
  *     advertised for a specific interface type.
  *
- * @NL80211_ATTR_SRC_MAC: MAC address used in control port over nl80211 transmit
- * @NL80211_ATTR_DST_MAC: MAC address used in control port over nl80211 receive
- *
  * @NUM_NL80211_ATTR: total number of nl80211_attrs available
  * @NL80211_ATTR_MAX: highest attribute number currently defined
  * @__NL80211_ATTR_AFTER_LAST: internal use
 
        NL80211_ATTR_IFTYPE_AKM_SUITES,
 
-       NL80211_ATTR_SRC_MAC,
-       NL80211_ATTR_DST_MAC,
-
        /* add attributes here, update the policy in nl80211.c */
 
        __NL80211_ATTR_AFTER_LAST,
  *     feature, which prevents bufferbloat by using the expected transmission
  *     time to limit the amount of data buffered in the hardware.
  *
- * @NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211_MAC_ADDRS: The driver
- *     can use src and dst MAC addresses with control port over nl80211 rx
- *     and tx operations.
- *
  * @NUM_NL80211_EXT_FEATURES: number of extended features.
  * @MAX_NL80211_EXT_FEATURES: highest extended feature index.
  */
        NL80211_EXT_FEATURE_SAE_OFFLOAD,
        NL80211_EXT_FEATURE_VLAN_OFFLOAD,
        NL80211_EXT_FEATURE_AQL,
-       NL80211_EXT_FEATURE_CONTROL_PORT_OVER_NL80211_MAC_ADDRS,
 
        /* add new features before the definition below */
        NUM_NL80211_EXT_FEATURES,
 
 void ieee80211_clear_fast_xmit(struct sta_info *sta);
 int ieee80211_tx_control_port(struct wiphy *wiphy, struct net_device *dev,
                              const u8 *buf, size_t len,
-                             const u8 *dest, const u8 *src, __be16 proto,
-                             bool unencrypted);
+                             const u8 *dest, __be16 proto, bool unencrypted);
 int ieee80211_probe_mesh_link(struct wiphy *wiphy, struct net_device *dev,
                              const u8 *buf, size_t len);
 
 
 
 int ieee80211_tx_control_port(struct wiphy *wiphy, struct net_device *dev,
                              const u8 *buf, size_t len,
-                             const u8 *dest, const u8 *src, __be16 proto,
-                             bool unencrypted)
+                             const u8 *dest, __be16 proto, bool unencrypted)
 {
        struct ieee80211_sub_if_data *sdata = IEEE80211_DEV_TO_SUB_IF(dev);
        struct ieee80211_local *local = sdata->local;
 
        [NL80211_ATTR_HE_OBSS_PD] = NLA_POLICY_NESTED(he_obss_pd_policy),
        [NL80211_ATTR_VLAN_ID] = NLA_POLICY_RANGE(NLA_U16, 1, VLAN_N_VID - 2),
        [NL80211_ATTR_HE_BSS_COLOR] = NLA_POLICY_NESTED(he_bss_color_policy),
-       [NL80211_ATTR_SRC_MAC] = NLA_POLICY_ETH_ADDR,
-       [NL80211_ATTR_DST_MAC] = NLA_POLICY_ETH_ADDR,
 };
 
 /* policy for the key attributes */
        const u8 *buf;
        size_t len;
        u8 *dest;
-       u8 src[ETH_ALEN];
        u16 proto;
        bool noencrypt;
        int err;
                goto out;
        }
 
-       /* copy src address under wdev_lock, as we may copy wdev_address */
-       if (info->attrs[NL80211_ATTR_SRC_MAC])
-               ether_addr_copy(src,
-                               nla_data(info->attrs[NL80211_ATTR_SRC_MAC]));
-       else
-               ether_addr_copy(src, wdev_address(wdev));
-
        wdev_unlock(wdev);
 
        buf = nla_data(info->attrs[NL80211_ATTR_FRAME]);
                nla_get_flag(info->attrs[NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT]);
 
        return rdev_tx_control_port(rdev, dev, buf, len,
-                                   dest, src, cpu_to_be16(proto), noencrypt);
+                                   dest, cpu_to_be16(proto), noencrypt);
 
  out:
        wdev_unlock(wdev);
        struct wireless_dev *wdev = dev->ieee80211_ptr;
        struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
        struct ethhdr *ehdr = eth_hdr(skb);
-       const u8 *daddr = ehdr->h_dest;
-       const u8 *saddr = ehdr->h_source;
+       const u8 *addr = ehdr->h_source;
        u16 proto = be16_to_cpu(skb->protocol);
        struct sk_buff *msg;
        void *hdr;
            nla_put_u32(msg, NL80211_ATTR_IFINDEX, dev->ifindex) ||
            nla_put_u64_64bit(msg, NL80211_ATTR_WDEV, wdev_id(wdev),
                              NL80211_ATTR_PAD) ||
-           nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, saddr) ||
-           nla_put(msg, NL80211_ATTR_DST_MAC, ETH_ALEN, daddr) ||
+           nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, addr) ||
            nla_put_u16(msg, NL80211_ATTR_CONTROL_PORT_ETHERTYPE, proto) ||
            (unencrypted && nla_put_flag(msg,
                                         NL80211_ATTR_CONTROL_PORT_NO_ENCRYPT)))
 
 static inline int rdev_tx_control_port(struct cfg80211_registered_device *rdev,
                                       struct net_device *dev,
                                       const void *buf, size_t len,
-                                      const u8 *dest, const u8 *src,
-                                      __be16 proto, const bool noencrypt)
+                                      const u8 *dest, __be16 proto,
+                                      const bool noencrypt)
 {
        int ret;
        trace_rdev_tx_control_port(&rdev->wiphy, dev, buf, len,
-                                  dest, src, proto, noencrypt);
+                                  dest, proto, noencrypt);
        ret = rdev->ops->tx_control_port(&rdev->wiphy, dev, buf, len,
-                                        dest, src, proto, noencrypt);
+                                        dest, proto, noencrypt);
        trace_rdev_return_int(&rdev->wiphy, ret);
        return ret;
 }
 
 
 TRACE_EVENT(rdev_tx_control_port,
        TP_PROTO(struct wiphy *wiphy, struct net_device *netdev,
-                const u8 *buf, size_t len,
-                const u8 *dest, const u8 *src, __be16 proto,
+                const u8 *buf, size_t len, const u8 *dest, __be16 proto,
                 bool unencrypted),
-       TP_ARGS(wiphy, netdev, buf, len, dest, src, proto, unencrypted),
+       TP_ARGS(wiphy, netdev, buf, len, dest, proto, unencrypted),
        TP_STRUCT__entry(
                WIPHY_ENTRY
                NETDEV_ENTRY
                MAC_ENTRY(dest)
-               MAC_ENTRY(src)
-               __field(u16, proto)
+               __field(__be16, proto)
                __field(bool, unencrypted)
        ),
        TP_fast_assign(
                WIPHY_ASSIGN;
                NETDEV_ASSIGN;
                MAC_ASSIGN(dest, dest);
-               MAC_ASSIGN(src, src);
-               __entry->proto = be16_to_cpu(proto);
+               __entry->proto = proto;
                __entry->unencrypted = unencrypted;
        ),
-       TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", dest: " MAC_PR_FMT
-                 ", src: " MAC_PR_FMT ", proto: 0x%x, unencrypted: %s",
-                 WIPHY_PR_ARG, NETDEV_PR_ARG,
-                 MAC_PR_ARG(dest), MAC_PR_ARG(src),
-                 __entry->proto,
+       TP_printk(WIPHY_PR_FMT ", " NETDEV_PR_FMT ", " MAC_PR_FMT ","
+                 " proto: 0x%x, unencrypted: %s",
+                 WIPHY_PR_ARG, NETDEV_PR_ARG, MAC_PR_ARG(dest),
+                 be16_to_cpu(__entry->proto),
                  BOOL_TO_STR(__entry->unencrypted))
 );
 
        TP_STRUCT__entry(
                NETDEV_ENTRY
                __field(int, len)
-               MAC_ENTRY(to)
                MAC_ENTRY(from)
                __field(u16, proto)
                __field(bool, unencrypted)
        TP_fast_assign(
                NETDEV_ASSIGN;
                __entry->len = skb->len;
-               MAC_ASSIGN(to, eth_hdr(skb)->h_dest);
                MAC_ASSIGN(from, eth_hdr(skb)->h_source);
                __entry->proto = be16_to_cpu(skb->protocol);
                __entry->unencrypted = unencrypted;
        ),
-       TP_printk(NETDEV_PR_FMT ", len=%d, dest: " MAC_PR_FMT
-                 ", src: " MAC_PR_FMT ", proto: 0x%x, unencrypted: %s",
-                 NETDEV_PR_ARG, __entry->len, MAC_PR_ARG(to), MAC_PR_ARG(from),
+       TP_printk(NETDEV_PR_FMT ", len=%d, " MAC_PR_FMT ", proto: 0x%x, unencrypted: %s",
+                 NETDEV_PR_ARG, __entry->len, MAC_PR_ARG(from),
                  __entry->proto, BOOL_TO_STR(__entry->unencrypted))
 );