brcmf_dbg(CONN, "Report roaming result\n");
 
        if (profile->use_fwsup == BRCMF_PROFILE_FWSUP_1X && profile->is_ft) {
-               cfg80211_port_authorized(ndev, profile->bssid, GFP_KERNEL);
+               cfg80211_port_authorized(ndev, profile->bssid, NULL, 0, GFP_KERNEL);
                brcmf_dbg(CONN, "Report port authorized\n");
        }
 
 
  *
  * @dev: network device
  * @bssid: the BSSID of the AP
+ * @td_bitmap: transition disable policy
+ * @td_bitmap_len: Length of transition disable policy
  * @gfp: allocation flags
  *
  * This function should be called by a driver that supports 4 way handshake
  * indicate the 802.11 association.
  */
 void cfg80211_port_authorized(struct net_device *dev, const u8 *bssid,
-                             gfp_t gfp);
+                             const u8* td_bitmap, u8 td_bitmap_len, gfp_t gfp);
 
 /**
  * cfg80211_disconnected - notify cfg80211 that connection was dropped
 
  *     When used with %NL80211_CMD_FRAME_TX_STATUS, indicates the ack RX
  *     timestamp. When used with %NL80211_CMD_FRAME RX notification, indicates
  *     the incoming frame RX timestamp.
+ * @NL80211_ATTR_TD_BITMAP: Transition Disable bitmap, for subsequent
+ *     (re)associations.
  * @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_TX_HW_TIMESTAMP,
        NL80211_ATTR_RX_HW_TIMESTAMP,
+       NL80211_ATTR_TD_BITMAP,
 
        /* add attributes here, update the policy in nl80211.c */
 
 
                } ij;
                struct {
                        u8 bssid[ETH_ALEN];
+                       const u8 *td_bitmap;
+                       u8 td_bitmap_len;
                } pa;
        };
 };
                        bool wextev);
 void __cfg80211_roamed(struct wireless_dev *wdev,
                       struct cfg80211_roam_info *info);
-void __cfg80211_port_authorized(struct wireless_dev *wdev, const u8 *bssid);
+void __cfg80211_port_authorized(struct wireless_dev *wdev, const u8 *bssid,
+                               const u8 *td_bitmap, u8 td_bitmap_len);
 int cfg80211_mgd_wext_connect(struct cfg80211_registered_device *rdev,
                              struct wireless_dev *wdev);
 void cfg80211_autodisconnect_wk(struct work_struct *work);
 
 }
 
 void nl80211_send_port_authorized(struct cfg80211_registered_device *rdev,
-                                 struct net_device *netdev, const u8 *bssid)
+                                 struct net_device *netdev, const u8 *bssid,
+                                 const u8 *td_bitmap, u8 td_bitmap_len)
 {
        struct sk_buff *msg;
        void *hdr;
            nla_put(msg, NL80211_ATTR_MAC, ETH_ALEN, bssid))
                goto nla_put_failure;
 
+       if ((td_bitmap_len > 0) && td_bitmap)
+               if (nla_put(msg, NL80211_ATTR_TD_BITMAP,
+                           td_bitmap_len, td_bitmap))
+                       goto nla_put_failure;
+
        genlmsg_end(msg, hdr);
 
        genlmsg_multicast_netns(&nl80211_fam, wiphy_net(&rdev->wiphy), msg, 0,
 
                         struct net_device *netdev,
                         struct cfg80211_roam_info *info, gfp_t gfp);
 void nl80211_send_port_authorized(struct cfg80211_registered_device *rdev,
-                                 struct net_device *netdev, const u8 *bssid);
+                                 struct net_device *netdev, const u8 *bssid,
+                                 const u8 *td_bitmap, u8 td_bitmap_len);
 void nl80211_send_disconnected(struct cfg80211_registered_device *rdev,
                               struct net_device *netdev, u16 reason,
                               const u8 *ie, size_t ie_len, bool from_ap);
 
 }
 EXPORT_SYMBOL(cfg80211_roamed);
 
-void __cfg80211_port_authorized(struct wireless_dev *wdev, const u8 *bssid)
+void __cfg80211_port_authorized(struct wireless_dev *wdev, const u8 *bssid,
+                                       const u8 *td_bitmap, u8 td_bitmap_len)
 {
        ASSERT_WDEV_LOCK(wdev);
 
                return;
 
        nl80211_send_port_authorized(wiphy_to_rdev(wdev->wiphy), wdev->netdev,
-                                    bssid);
+                                    bssid, td_bitmap, td_bitmap_len);
 }
 
 void cfg80211_port_authorized(struct net_device *dev, const u8 *bssid,
-                             gfp_t gfp)
+                             const u8 *td_bitmap, u8 td_bitmap_len, gfp_t gfp)
 {
        struct wireless_dev *wdev = dev->ieee80211_ptr;
        struct cfg80211_registered_device *rdev = wiphy_to_rdev(wdev->wiphy);
        if (WARN_ON(!bssid))
                return;
 
-       ev = kzalloc(sizeof(*ev), gfp);
+       ev = kzalloc(sizeof(*ev) + td_bitmap_len, gfp);
        if (!ev)
                return;
 
        ev->type = EVENT_PORT_AUTHORIZED;
        memcpy(ev->pa.bssid, bssid, ETH_ALEN);
+       ev->pa.td_bitmap = ((u8 *)ev) + sizeof(*ev);
+       ev->pa.td_bitmap_len = td_bitmap_len;
+       memcpy((void *)ev->pa.td_bitmap, td_bitmap, td_bitmap_len);
 
        /*
         * Use the wdev event list so that if there are pending
 
                        __cfg80211_leave(wiphy_to_rdev(wdev->wiphy), wdev);
                        break;
                case EVENT_PORT_AUTHORIZED:
-                       __cfg80211_port_authorized(wdev, ev->pa.bssid);
+                       __cfg80211_port_authorized(wdev, ev->pa.bssid,
+                                                  ev->pa.td_bitmap,
+                                                  ev->pa.td_bitmap_len);
                        break;
                }
                wdev_unlock(wdev);