Merge git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6
Linus Torvalds [Thu, 26 May 2011 00:00:17 +0000 (17:00 -0700)]
* git://git.kernel.org/pub/scm/linux/kernel/git/davem/net-2.6: (89 commits)
  bonding: documentation and code cleanup for resend_igmp
  bonding: prevent deadlock on slave store with alb mode (v3)
  net: hold rtnl again in dump callbacks
  Add Fujitsu 1000base-SX PCI ID to tg3
  bnx2x: protect sequence increment with mutex
  sch_sfq: fix peek() implementation
  isdn: netjet - blacklist Digium TDM400P
  via-velocity: don't annotate MAC registers as packed
  xen: netfront: hold RTNL when updating features.
  sctp: fix memory leak of the ASCONF queue when free asoc
  net: make dev_disable_lro use physical device if passed a vlan dev (v2)
  net: move is_vlan_dev into public header file (v2)
  bug.h: Fix build with CONFIG_PRINTK disabled.
  wireless: fix fatal kernel-doc error + warning in mac80211.h
  wireless: fix cfg80211.h new kernel-doc warnings
  iwlagn: dbg_fixed_rate only used when CONFIG_MAC80211_DEBUGFS enabled
  dst: catch uninitialized metrics
  be2net: hash key for rss-config cmd not set
  bridge: initialize fake_rtable metrics
  net: fix __dst_destroy_metrics_generic()
  ...

Fix up trivial conflicts in drivers/staging/brcm80211/brcmfmac/wl_cfg80211.c

1  2 
drivers/staging/ath6kl/os/linux/cfg80211.c
drivers/staging/brcm80211/brcmfmac/wl_cfg80211.c

@@@ -172,12 -172,6 +172,12 @@@ ar6k_set_auth_type(struct ar6_softc *ar
      case NL80211_AUTHTYPE_NETWORK_EAP:
          ar->arDot11AuthMode = LEAP_AUTH;
          break;
 +
 +    case NL80211_AUTHTYPE_AUTOMATIC:
 +        ar->arDot11AuthMode = OPEN_AUTH;
 +        ar->arAutoAuthStage = AUTH_OPEN_IN_PROGRESS;
 +        break;
 +
      default:
          ar->arDot11AuthMode = OPEN_AUTH;
          AR_DEBUG_PRINTF(ATH_DEBUG_INFO,
@@@ -466,8 -460,6 +466,8 @@@ ar6k_cfg80211_connect_event(struct ar6_
      assocReqLen -= assocReqIeOffset;
      assocRespLen -= assocRespIeOffset;
  
 +    ar->arAutoAuthStage = AUTH_IDLE;
 +
      if((ADHOC_NETWORK & networkType)) {
          if(NL80211_IFTYPE_ADHOC != ar->wdev->iftype) {
              AR_DEBUG_PRINTF(ATH_DEBUG_INFO,
                             ((ADHOC_NETWORK & networkType) ? WLAN_CAPABILITY_IBSS : WLAN_CAPABILITY_ESS),
                             ((ADHOC_NETWORK & networkType) ? WLAN_CAPABILITY_IBSS : WLAN_CAPABILITY_ESS));
  
 -    if(!bss) {
 -        if (ADHOC_NETWORK & networkType) {
 +    /*
 +     * Earlier we were updating the cfg about bss by making a beacon frame
 +     * only if the entry for bss is not there. This can have some issue if
 +     * ROAM event is generated and a heavy traffic is ongoing. The ROAM
 +     * event is handled through a work queue and by the time it really gets
 +     * handled, BSS would have been aged out. So it is better to update the
 +     * cfg about BSS irrespective of its entry being present right now or
 +     * not.
 +     */
 +
 +    if (ADHOC_NETWORK & networkType) {
              /* construct 802.11 mgmt beacon */
              if(ptr_ie_buf) {
 -                *ptr_ie_buf++ = WLAN_EID_SSID;
 -                *ptr_ie_buf++ = ar->arSsidLen;
 -                memcpy(ptr_ie_buf, ar->arSsid, ar->arSsidLen);
 -                ptr_ie_buf +=ar->arSsidLen;
 +                  *ptr_ie_buf++ = WLAN_EID_SSID;
 +                  *ptr_ie_buf++ = ar->arSsidLen;
 +                  memcpy(ptr_ie_buf, ar->arSsid, ar->arSsidLen);
 +                  ptr_ie_buf +=ar->arSsidLen;
  
 -                *ptr_ie_buf++ = WLAN_EID_IBSS_PARAMS;
 -                *ptr_ie_buf++ = 2; /* length */
 -                *ptr_ie_buf++ = 0; /* ATIM window */
 -                *ptr_ie_buf++ = 0; /* ATIM window */
 +                  *ptr_ie_buf++ = WLAN_EID_IBSS_PARAMS;
 +                  *ptr_ie_buf++ = 2; /* length */
 +                  *ptr_ie_buf++ = 0; /* ATIM window */
 +                  *ptr_ie_buf++ = 0; /* ATIM window */
  
 -                /* TODO: update ibss params and include supported rates,
 -                 * DS param set, extened support rates, wmm. */
 +                  /* TODO: update ibss params and include supported rates,
 +                   * DS param set, extened support rates, wmm. */
  
 -                ie_buf_len = ptr_ie_buf - ie_buf;
 +                  ie_buf_len = ptr_ie_buf - ie_buf;
              }
  
              capability |= IEEE80211_CAPINFO_IBSS;
              if(WEP_CRYPT == ar->arPairwiseCrypto) {
 -                capability |= IEEE80211_CAPINFO_PRIVACY;
 +                  capability |= IEEE80211_CAPINFO_PRIVACY;
              }
              memcpy(source_mac, ar->arNetDev->dev_addr, ATH_MAC_LEN);
              ptr_ie_buf = ie_buf;
 -        } else {
 +    } else {
              capability = *(u16 *)(&assocInfo[beaconIeLen]);
              memcpy(source_mac, bssid, ATH_MAC_LEN);
              ptr_ie_buf = assocReqIe;
              ie_buf_len = assocReqLen;
 -        }
 +    }
  
 -        size = offsetof(struct ieee80211_mgmt, u)
 -             + sizeof(mgmt->u.beacon)
 -             + ie_buf_len;
 +    size = offsetof(struct ieee80211_mgmt, u)
 +          + sizeof(mgmt->u.beacon)
 +          + ie_buf_len;
  
 -        ieeemgmtbuf = A_MALLOC_NOWAIT(size);
 -        if(!ieeemgmtbuf) {
 +    ieeemgmtbuf = A_MALLOC_NOWAIT(size);
 +    if(!ieeemgmtbuf) {
              AR_DEBUG_PRINTF(ATH_DEBUG_ERR,
                              ("%s: ieeeMgmtbuf alloc error\n", __func__));
 +          cfg80211_put_bss(bss);
              return;
 -        }
 +    }
  
 -        A_MEMZERO(ieeemgmtbuf, size);
 -        mgmt = (struct ieee80211_mgmt *)ieeemgmtbuf;
 -        mgmt->frame_control = (IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_BEACON);
 -        memcpy(mgmt->da, bcast_mac, ATH_MAC_LEN);
 -        memcpy(mgmt->sa, source_mac, ATH_MAC_LEN);
 -        memcpy(mgmt->bssid, bssid, ATH_MAC_LEN);
 -        mgmt->u.beacon.beacon_int = beaconInterval;
 -        mgmt->u.beacon.capab_info = capability;
 -        memcpy(mgmt->u.beacon.variable, ptr_ie_buf, ie_buf_len);
 +    A_MEMZERO(ieeemgmtbuf, size);
 +    mgmt = (struct ieee80211_mgmt *)ieeemgmtbuf;
 +    mgmt->frame_control = (IEEE80211_FTYPE_MGMT | IEEE80211_STYPE_BEACON);
 +    memcpy(mgmt->da, bcast_mac, ATH_MAC_LEN);
 +    memcpy(mgmt->sa, source_mac, ATH_MAC_LEN);
 +    memcpy(mgmt->bssid, bssid, ATH_MAC_LEN);
 +    mgmt->u.beacon.beacon_int = beaconInterval;
 +    mgmt->u.beacon.capab_info = capability;
 +    memcpy(mgmt->u.beacon.variable, ptr_ie_buf, ie_buf_len);
  
 -        ibss_channel = ieee80211_get_channel(ar->wdev->wiphy, (int)channel);
 +    ibss_channel = ieee80211_get_channel(ar->wdev->wiphy, (int)channel);
  
 -      AR_DEBUG_PRINTF(ATH_DEBUG_INFO,
 -              ("%s: inform bss with bssid %pM channel %d beaconInterval %d "
 -                      "capability 0x%x\n", __func__, mgmt->bssid,
 -                      ibss_channel->hw_value, beaconInterval, capability));
 +    AR_DEBUG_PRINTF(ATH_DEBUG_INFO,
 +                  ("%s: inform bss with bssid %pM channel %d beaconInterval %d "
 +                   "capability 0x%x\n", __func__, mgmt->bssid,
 +                   ibss_channel->hw_value, beaconInterval, capability));
  
 -        bss = cfg80211_inform_bss_frame(ar->wdev->wiphy,
 -                                        ibss_channel, mgmt,
 -                                        le16_to_cpu(size),
 -                                        signal, GFP_KERNEL);
 -        A_FREE(ieeemgmtbuf);
 -        cfg80211_put_bss(bss);
 -    }
 +    bss = cfg80211_inform_bss_frame(ar->wdev->wiphy,
 +                                  ibss_channel, mgmt,
 +                                  le16_to_cpu(size),
 +                                  signal, GFP_KERNEL);
 +    kfree(ieeemgmtbuf);
 +    cfg80211_put_bss(bss);
  
      if((ADHOC_NETWORK & networkType)) {
          cfg80211_ibss_joined(ar->arNetDev, bssid, GFP_KERNEL);
                                  WLAN_STATUS_SUCCESS, GFP_KERNEL);
      } else {
          /* inform roam event to cfg80211 */
-         cfg80211_roamed(ar->arNetDev, bssid,
+       cfg80211_roamed(ar->arNetDev, ibss_channel, bssid,
                          assocReqIe, assocReqLen,
                          assocRespIe, assocRespLen,
                          GFP_KERNEL);
@@@ -642,14 -625,8 +642,14 @@@ ar6k_cfg80211_disconnect_event(struct a
                                 u8 *assocInfo, u16 protocolReasonStatus)
  {
  
 +    u16 status;
 +
      AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s: reason=%u\n", __func__, reason));
  
 +    if (ar->scan_request) {
 +      cfg80211_scan_done(ar->scan_request, true);
 +        ar->scan_request = NULL;
 +    }
      if((ADHOC_NETWORK & ar->arNetworkType)) {
          if(NL80211_IFTYPE_ADHOC != ar->wdev->iftype) {
              AR_DEBUG_PRINTF(ATH_DEBUG_INFO,
              /* connect cmd failed */
              wmi_disconnect_cmd(ar->arWmi);
          } else if (reason == DISCONNECT_CMD) {
 -            /* connection loss due to disconnect cmd or low rssi */
 -            ar->arConnectPending = false;   
 -            if (ar->smeState == SME_CONNECTING) {
 -                cfg80211_connect_result(ar->arNetDev, bssid,
 -                                        NULL, 0,
 -                                        NULL, 0,
 -                                        WLAN_STATUS_UNSPECIFIED_FAILURE,
 -                                        GFP_KERNEL);
 -            } else {
 -                cfg80211_disconnected(ar->arNetDev, reason, NULL, 0, GFP_KERNEL);
 -            }
 -            ar->smeState = SME_DISCONNECTED;
 -        }
 +              if (ar->arAutoAuthStage) {
 +                      /*
 +                       * If the current auth algorithm is open try shared
 +                       * and make autoAuthStage idle. We do not make it
 +                       * leap for now being.
 +                       */
 +                      if (ar->arDot11AuthMode == OPEN_AUTH) {
 +                              struct ar_key *key = NULL;
 +                              key = &ar->keys[ar->arDefTxKeyIndex];
 +                              if (down_interruptible(&ar->arSem)) {
 +                                      AR_DEBUG_PRINTF(ATH_DEBUG_ERR, ("%s: busy, couldn't get access\n", __func__));
 +                                      return;
 +                              }
 +
 +
 +                              ar->arDot11AuthMode = SHARED_AUTH;
 +                              ar->arAutoAuthStage = AUTH_IDLE;
 +
 +                              wmi_addKey_cmd(ar->arWmi, ar->arDefTxKeyIndex,
 +                                              ar->arPairwiseCrypto,
 +                                              GROUP_USAGE | TX_USAGE,
 +                                              key->key_len,
 +                                              NULL,
 +                                              key->key, KEY_OP_INIT_VAL, NULL,
 +                                              NO_SYNC_WMIFLAG);
 +
 +                              status = wmi_connect_cmd(ar->arWmi,
 +                                                       ar->arNetworkType,
 +                                                       ar->arDot11AuthMode,
 +                                                       ar->arAuthMode,
 +                                                       ar->arPairwiseCrypto,
 +                                                       ar->arPairwiseCryptoLen,
 +                                                       ar->arGroupCrypto,
 +                                                       ar->arGroupCryptoLen,
 +                                                       ar->arSsidLen,
 +                                                       ar->arSsid,
 +                                                       ar->arReqBssid,
 +                                                       ar->arChannelHint,
 +                                                       ar->arConnectCtrlFlags);
 +                              up(&ar->arSem);
 +
 +                      } else if (ar->arDot11AuthMode == SHARED_AUTH) {
 +                              /* should not reach here */
 +                      }
 +              } else {
 +                      ar->arConnectPending = false;
 +                      if (ar->smeState == SME_CONNECTING) {
 +                              cfg80211_connect_result(ar->arNetDev, bssid,
 +                                                      NULL, 0,
 +                                                      NULL, 0,
 +                                                      WLAN_STATUS_UNSPECIFIED_FAILURE,
 +                                                      GFP_KERNEL);
 +                      } else {
 +                              cfg80211_disconnected(ar->arNetDev,
 +                                                    reason,
 +                                                    NULL, 0,
 +                                                    GFP_KERNEL);
 +                      }
 +                      ar->smeState = SME_DISCONNECTED;
 +              }
 +      }
      } else {
 -        if (reason != DISCONNECT_CMD) {
 -            wmi_disconnect_cmd(ar->arWmi);
 -        }
 +          if (reason != DISCONNECT_CMD)
 +                  wmi_disconnect_cmd(ar->arWmi);
      }
  }
  
@@@ -799,7 -729,7 +799,7 @@@ ar6k_cfg80211_scan_node(void *arg, bss_
                                le16_to_cpu(size),
                                signal, GFP_KERNEL);
  
 -    A_FREE (ieeemgmtbuf);
 +    kfree (ieeemgmtbuf);
  }
  
  static int
@@@ -1275,10 -1205,10 +1275,10 @@@ ar6k_cfg80211_set_power_mgmt(struct wip
  
      if(pmgmt) {
          AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s: Max Perf\n", __func__));
 -        pwrMode.powerMode = MAX_PERF_POWER;
 +        pwrMode.powerMode = REC_POWER;
      } else {
          AR_DEBUG_PRINTF(ATH_DEBUG_INFO, ("%s: Rec Power\n", __func__));
 -        pwrMode.powerMode = REC_POWER;
 +        pwrMode.powerMode = MAX_PERF_POWER;
      }
  
      if(wmi_powermode_cmd(ar->arWmi, pwrMode.powerMode) != 0) {
@@@ -1461,151 -1391,6 +1461,151 @@@ u32 cipher_suites[] = 
      WLAN_CIPHER_SUITE_CCMP,
  };
  
 +bool is_rate_legacy(s32 rate)
 +{
 +      static const s32 legacy[] = { 1000, 2000, 5500, 11000,
 +                                    6000, 9000, 12000, 18000, 24000,
 +                                    36000, 48000, 54000 };
 +      u8 i;
 +
 +      for (i = 0; i < ARRAY_SIZE(legacy); i++) {
 +              if (rate == legacy[i])
 +                      return true;
 +      }
 +
 +      return false;
 +}
 +
 +bool is_rate_ht20(s32 rate, u8 *mcs, bool *sgi)
 +{
 +      static const s32 ht20[] = { 6500, 13000, 19500, 26000, 39000,
 +                                  52000, 58500, 65000, 72200 };
 +      u8 i;
 +
 +      for (i = 0; i < ARRAY_SIZE(ht20); i++) {
 +              if (rate == ht20[i]) {
 +                      if (i == ARRAY_SIZE(ht20) - 1)
 +                              /* last rate uses sgi */
 +                              *sgi = true;
 +                      else
 +                              *sgi = false;
 +
 +                      *mcs = i;
 +                      return true;
 +              }
 +      }
 +      return false;
 +}
 +
 +bool is_rate_ht40(s32 rate, u8 *mcs, bool *sgi)
 +{
 +      static const s32 ht40[] = { 13500, 27000, 40500, 54000,
 +                                  81000, 108000, 121500, 135000,
 +                                  150000 };
 +      u8 i;
 +
 +      for (i = 0; i < ARRAY_SIZE(ht40); i++) {
 +              if (rate == ht40[i]) {
 +                      if (i == ARRAY_SIZE(ht40) - 1)
 +                              /* last rate uses sgi */
 +                              *sgi = true;
 +                      else
 +                              *sgi = false;
 +
 +                      *mcs = i;
 +                      return true;
 +              }
 +      }
 +
 +      return false;
 +}
 +
 +static int ar6k_get_station(struct wiphy *wiphy, struct net_device *dev,
 +                          u8 *mac, struct station_info *sinfo)
 +{
 +      struct ar6_softc *ar = ar6k_priv(dev);
 +      long left;
 +      bool sgi;
 +      s32 rate;
 +      int ret;
 +      u8 mcs;
 +
 +      if (memcmp(mac, ar->arBssid, ETH_ALEN) != 0)
 +              return -ENOENT;
 +
 +      if (down_interruptible(&ar->arSem))
 +              return -EBUSY;
 +
 +      ar->statsUpdatePending = true;
 +
 +      ret = wmi_get_stats_cmd(ar->arWmi);
 +
 +      if (ret != 0) {
 +              up(&ar->arSem);
 +              return -EIO;
 +      }
 +
 +      left = wait_event_interruptible_timeout(arEvent,
 +                                              ar->statsUpdatePending == false,
 +                                              wmitimeout * HZ);
 +
 +      up(&ar->arSem);
 +
 +      if (left == 0)
 +              return -ETIMEDOUT;
 +      else if (left < 0)
 +              return left;
 +
 +      if (ar->arTargetStats.rx_bytes) {
 +              sinfo->rx_bytes = ar->arTargetStats.rx_bytes;
 +              sinfo->filled |= STATION_INFO_RX_BYTES;
 +              sinfo->rx_packets = ar->arTargetStats.rx_packets;
 +              sinfo->filled |= STATION_INFO_RX_PACKETS;
 +      }
 +
 +      if (ar->arTargetStats.tx_bytes) {
 +              sinfo->tx_bytes = ar->arTargetStats.tx_bytes;
 +              sinfo->filled |= STATION_INFO_TX_BYTES;
 +              sinfo->tx_packets = ar->arTargetStats.tx_packets;
 +              sinfo->filled |= STATION_INFO_TX_PACKETS;
 +      }
 +
 +      sinfo->signal = ar->arTargetStats.cs_rssi;
 +      sinfo->filled |= STATION_INFO_SIGNAL;
 +
 +      rate = ar->arTargetStats.tx_unicast_rate;
 +
 +      if (is_rate_legacy(rate)) {
 +              sinfo->txrate.legacy = rate / 100;
 +      } else if (is_rate_ht20(rate, &mcs, &sgi)) {
 +              if (sgi) {
 +                      sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
 +                      sinfo->txrate.mcs = mcs - 1;
 +              } else {
 +                      sinfo->txrate.mcs = mcs;
 +              }
 +
 +              sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
 +      } else if (is_rate_ht40(rate, &mcs, &sgi)) {
 +              if (sgi) {
 +                      sinfo->txrate.flags |= RATE_INFO_FLAGS_SHORT_GI;
 +                      sinfo->txrate.mcs = mcs - 1;
 +              } else {
 +                      sinfo->txrate.mcs = mcs;
 +              }
 +
 +              sinfo->txrate.flags |= RATE_INFO_FLAGS_40_MHZ_WIDTH;
 +              sinfo->txrate.flags |= RATE_INFO_FLAGS_MCS;
 +      } else {
 +              WARN(1, "invalid rate: %d", rate);
 +              return 0;
 +      }
 +
 +      sinfo->filled |= STATION_INFO_TX_BITRATE;
 +
 +      return 0;
 +}
 +
  static struct
  cfg80211_ops ar6k_cfg80211_ops = {
      .change_virtual_intf = ar6k_cfg80211_change_iface,
      .set_power_mgmt = ar6k_cfg80211_set_power_mgmt,
      .join_ibss = ar6k_cfg80211_join_ibss,
      .leave_ibss = ar6k_cfg80211_leave_ibss,
 +    .get_station = ar6k_get_station,
  };
  
  struct wireless_dev *
  #include <linux/firmware.h>
  #include <wl_cfg80211.h>
  
 +void sdioh_sdio_set_host_pm_flags(int flag);
 +
  static struct sdio_func *cfg80211_sdio_func;
  static struct wl_dev *wl_cfg80211_dev;
  static const u8 ether_bcast[ETH_ALEN] = {255, 255, 255, 255, 255, 255};
  
 -u32 wl_dbg_level = WL_DBG_ERR | WL_DBG_INFO;
 +u32 wl_dbg_level = WL_DBG_ERR;
  
  #define WL_4329_FW_FILE "brcm/bcm4329-fullmac-4.bin"
  #define WL_4329_NVRAM_FILE "brcm/bcm4329-fullmac-4.txt"
@@@ -182,34 -180,41 +182,34 @@@ static void wl_init_prof(struct wl_prof
  ** cfg80211 connect utilites
  */
  static s32 wl_set_wpa_version(struct net_device *dev,
 -                              struct cfg80211_connect_params *sme);
 +                      struct cfg80211_connect_params *sme);
  static s32 wl_set_auth_type(struct net_device *dev,
 -                            struct cfg80211_connect_params *sme);
 +                      struct cfg80211_connect_params *sme);
  static s32 wl_set_set_cipher(struct net_device *dev,
 -                             struct cfg80211_connect_params *sme);
 +                      struct cfg80211_connect_params *sme);
  static s32 wl_set_key_mgmt(struct net_device *dev,
 -                           struct cfg80211_connect_params *sme);
 +                      struct cfg80211_connect_params *sme);
  static s32 wl_set_set_sharedkey(struct net_device *dev,
 -                                struct cfg80211_connect_params *sme);
 +                      struct cfg80211_connect_params *sme);
  static s32 wl_get_assoc_ies(struct wl_priv *wl);
 +static void wl_clear_assoc_ies(struct wl_priv *wl);
  static void wl_ch_to_chanspec(int ch,
        struct wl_join_params *join_params, size_t *join_params_size);
  
  /*
  ** information element utilities
  */
 -static void wl_rst_ie(struct wl_priv *wl);
  static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v);
 -static s32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, u16 ie_size);
 -static s32 wl_cp_ie(struct wl_priv *wl, u8 *dst, u16 dst_size);
 -static u32 wl_get_ielen(struct wl_priv *wl);
 -
  static s32 wl_mode_to_nl80211_iftype(s32 mode);
 -
  static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
 -                                        struct device *dev);
 +                      struct device *dev);
  static void wl_free_wdev(struct wl_priv *wl);
  static s32 wl_inform_bss(struct wl_priv *wl);
  static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi);
  static s32 wl_update_bss_info(struct wl_priv *wl);
 -
  static s32 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
 -                         u8 key_idx, const u8 *mac_addr,
 -                         struct key_params *params);
 +                      u8 key_idx, const u8 *mac_addr,
 +                      struct key_params *params);
  
  /*
  ** key indianess swap utilities
@@@ -235,6 -240,7 +235,6 @@@ static void *wl_get_drvdata(struct wl_d
  ** ibss mode utilities
  */
  static bool wl_is_ibssmode(struct wl_priv *wl);
 -static bool wl_is_ibssstarter(struct wl_priv *wl);
  
  /*
  ** dongle up/down , default configuration utilities
  static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e);
  static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e);
  static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e);
 -static void wl_link_up(struct wl_priv *wl);
  static void wl_link_down(struct wl_priv *wl);
  static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
  static s32 __wl_cfg80211_up(struct wl_priv *wl);
@@@ -259,19 -266,18 +259,19 @@@ static s32 wl_dongle_up(struct net_devi
  static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode);
  static s32 wl_dongle_glom(struct net_device *ndev, u32 glom,
                            u32 dongle_align);
 -static s32 wl_dongle_roam(struct net_device *ndev, u32 roamvar,
 -                          u32 bcn_timeout);
 -static s32 wl_dongle_eventmsg(struct net_device *ndev);
 -static s32 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
 -                              s32 scan_unassoc_time);
  static s32 wl_dongle_offload(struct net_device *ndev, s32 arpoe,
                               s32 arp_ol);
  static s32 wl_pattern_atoh(s8 *src, s8 *dst);
  static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode);
  static s32 wl_update_wiphybands(struct wl_priv *wl);
  #endif                                /* !EMBEDDED_PLATFORM */
 +
 +static s32 wl_dongle_eventmsg(struct net_device *ndev);
 +static s32 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
 +                              s32 scan_unassoc_time, s32 scan_passive_time);
  static s32 wl_config_dongle(struct wl_priv *wl, bool need_lock);
 +static s32 wl_dongle_roam(struct net_device *ndev, u32 roamvar,
 +                          u32 bcn_timeout);
  
  /*
  ** iscan handler
@@@ -346,6 -352,30 +346,6 @@@ do {                                                                      
  } while (0)
  
  extern int dhd_wait_pend8021x(struct net_device *dev);
 -
 -#if (WL_DBG_LEVEL > 0)
 -#define WL_DBG_ESTR_MAX       32
 -static s8 wl_dbg_estr[][WL_DBG_ESTR_MAX] = {
 -      "SET_SSID", "JOIN", "START", "AUTH", "AUTH_IND",
 -      "DEAUTH", "DEAUTH_IND", "ASSOC", "ASSOC_IND", "REASSOC",
 -      "REASSOC_IND", "DISASSOC", "DISASSOC_IND", "QUIET_START", "QUIET_END",
 -      "BEACON_RX", "LINK", "MIC_ERROR", "NDIS_LINK", "ROAM",
 -      "TXFAIL", "PMKID_CACHE", "RETROGRADE_TSF", "PRUNE", "AUTOAUTH",
 -      "EAPOL_MSG", "SCAN_COMPLETE", "ADDTS_IND", "DELTS_IND", "BCNSENT_IND",
 -      "BCNRX_MSG", "BCNLOST_MSG", "ROAM_PREP", "PFN_NET_FOUND",
 -      "PFN_NET_LOST",
 -      "RESET_COMPLETE", "JOIN_START", "ROAM_START", "ASSOC_START",
 -      "IBSS_ASSOC",
 -      "RADIO", "PSM_WATCHDOG",
 -      "PROBREQ_MSG",
 -      "SCAN_CONFIRM_IND", "PSK_SUP", "COUNTRY_CODE_CHANGED",
 -      "EXCEEDED_MEDIUM_TIME", "ICV_ERROR",
 -      "UNICAST_DECODE_ERROR", "MULTICAST_DECODE_ERROR", "TRACE",
 -      "IF",
 -      "RSSI", "PFN_SCAN_COMPLETE", "ACTION_FRAME", "ACTION_FRAME_COMPLETE",
 -};
 -#endif                                /* WL_DBG_LEVEL */
 -
  #define CHAN2G(_channel, _freq, _flags) {                     \
        .band                   = IEEE80211_BAND_2GHZ,          \
        .center_freq            = (_freq),                      \
@@@ -574,11 -604,10 +574,11 @@@ wl_cfg80211_change_iface(struct wiphy *
        struct wl_priv *wl = wiphy_to_wl(wiphy);
        struct wireless_dev *wdev;
        s32 infra = 0;
 -      s32 ap = 0;
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        switch (type) {
        case NL80211_IFTYPE_MONITOR:
        case NL80211_IFTYPE_WDS:
                return -EOPNOTSUPP;
        case NL80211_IFTYPE_ADHOC:
                wl->conf->mode = WL_MODE_IBSS;
 +              infra = 0;
                break;
        case NL80211_IFTYPE_STATION:
                wl->conf->mode = WL_MODE_BSS;
                infra = 1;
                break;
        default:
 -              return -EINVAL;
 +              err = -EINVAL;
 +              goto done;
        }
 +
        infra = cpu_to_le32(infra);
        err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
        if (unlikely(err)) {
                WL_ERR("WLC_SET_INFRA error (%d)\n", err);
 -              return err;
 -      }
 -      err = wl_dev_ioctl(ndev, WLC_SET_AP, &ap, sizeof(ap));
 -      if (unlikely(err)) {
 -              WL_ERR("WLC_SET_AP error (%d)\n", err);
 -              return err;
 +              err = -EAGAIN;
 +      } else {
 +              wdev = ndev->ieee80211_ptr;
 +              wdev->iftype = type;
        }
  
 -      /* -EINPROGRESS: Call commit handler */
 -      return -EINPROGRESS;
 +      WL_INFO("IF Type = %s\n",
 +              (wl->conf->mode == WL_MODE_IBSS) ? "Adhoc" : "Infra");
 +
 +done:
 +      WL_TRACE("Exit\n");
 +
 +      return err;
  }
  
  static void wl_iscan_prep(struct wl_scan_params *params, struct wlc_ssid *ssid)
@@@ -713,7 -740,7 +713,7 @@@ static s32 wl_do_iscan(struct wl_priv *
        err = wl_dev_ioctl(wl_to_ndev(wl), WLC_SET_PASSIVE_SCAN,
                        &passive_scan, sizeof(passive_scan));
        if (unlikely(err)) {
 -              WL_DBG("error (%d)\n", err);
 +              WL_ERR("error (%d)\n", err);
                return err;
        }
        wl_set_mpc(ndev, 0);
@@@ -747,25 -774,26 +747,25 @@@ __wl_cfg80211_scan(struct wiphy *wiphy
                       (int)wl->status);
                return -EAGAIN;
        }
 +      if (test_bit(WL_STATUS_CONNECTING, &wl->status)) {
 +              WL_ERR("Connecting : status (%d)\n",
 +                     (int)wl->status);
 +              return -EAGAIN;
 +      }
  
        iscan_req = false;
        spec_scan = false;
 -      if (request) {          /* scan bss */
 +      if (request) {
 +              /* scan bss */
                ssids = request->ssids;
 -              if (wl->iscan_on && (!ssids || !ssids->ssid_len)) {     /* for
 -                                                       * specific scan,
 -                                                       * ssids->ssid_len has
 -                                                       * non-zero(ssid string)
 -                                                       * length.
 -                                                       * Otherwise this is 0.
 -                                                       * we do not iscan for
 -                                                       * specific scan request
 -                                                       */
 +              if (wl->iscan_on && (!ssids || !ssids->ssid_len))
                        iscan_req = true;
 -              }
 -      } else {                /* scan in ibss */
 +      } else {
 +              /* scan in ibss */
                /* we don't do iscan in ibss */
                ssids = this_ssid;
        }
 +
        wl->scan_request = request;
        set_bit(WL_STATUS_SCANNING, &wl->status);
        if (iscan_req) {
                else
                        goto scan_out;
        } else {
 -              WL_DBG("ssid \"%s\", ssid_len (%d)\n",
 +              WL_SCAN("ssid \"%s\", ssid_len (%d)\n",
                       ssids->ssid, ssids->ssid_len);
                memset(&sr->ssid, 0, sizeof(sr->ssid));
                sr->ssid.SSID_len =
                if (sr->ssid.SSID_len) {
                        memcpy(sr->ssid.SSID, ssids->ssid, sr->ssid.SSID_len);
                        sr->ssid.SSID_len = cpu_to_le32(sr->ssid.SSID_len);
 -                      WL_DBG("Specific scan ssid=\"%s\" len=%d\n",
 -                             sr->ssid.SSID, sr->ssid.SSID_len);
                        spec_scan = true;
                } else {
 -                      WL_DBG("Broadcast scan\n");
 +                      WL_SCAN("Broadcast scan\n");
                }
 -              WL_DBG("sr->ssid.SSID_len (%d)\n", sr->ssid.SSID_len);
 +
                passive_scan = wl->active_scan ? 0 : 1;
                err = wl_dev_ioctl(ndev, WLC_SET_PASSIVE_SCAN,
                                &passive_scan, sizeof(passive_scan));
@@@ -824,15 -854,13 +824,15 @@@ wl_cfg80211_scan(struct wiphy *wiphy, s
  {
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
 +
        CHECK_SYS_UP();
 +
        err = __wl_cfg80211_scan(wiphy, ndev, request, NULL);
 -      if (unlikely(err)) {
 -              WL_DBG("scan error (%d)\n", err);
 -              return err;
 -      }
 +      if (unlikely(err))
 +              WL_ERR("scan error (%d)\n", err);
  
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -847,8 -875,9 +847,8 @@@ static s32 wl_dev_intvar_set(struct net
        BUG_ON(!len);
  
        err = wl_dev_ioctl(dev, WLC_SET_VAR, buf, len);
 -      if (unlikely(err)) {
 +      if (unlikely(err))
                WL_ERR("error (%d)\n", err);
 -      }
  
        return err;
  }
@@@ -869,9 -898,9 +869,9 @@@ wl_dev_intvar_get(struct net_device *de
                        sizeof(var.buf));
        BUG_ON(!len);
        err = wl_dev_ioctl(dev, WLC_GET_VAR, &var, len);
 -      if (unlikely(err)) {
 +      if (unlikely(err))
                WL_ERR("error (%d)\n", err);
 -      }
 +
        *retval = le32_to_cpu(var.val);
  
        return err;
@@@ -882,9 -911,10 +882,9 @@@ static s32 wl_set_rts(struct net_devic
        s32 err = 0;
  
        err = wl_dev_intvar_set(dev, "rtsthresh", rts_threshold);
 -      if (unlikely(err)) {
 +      if (unlikely(err))
                WL_ERR("Error (%d)\n", err);
 -              return err;
 -      }
 +
        return err;
  }
  
@@@ -893,9 -923,10 +893,9 @@@ static s32 wl_set_frag(struct net_devic
        s32 err = 0;
  
        err = wl_dev_intvar_set(dev, "fragthresh", frag_threshold);
 -      if (unlikely(err)) {
 +      if (unlikely(err))
                WL_ERR("Error (%d)\n", err);
 -              return err;
 -      }
 +
        return err;
  }
  
@@@ -919,40 -950,37 +919,40 @@@ static s32 wl_cfg80211_set_wiphy_params
        struct net_device *ndev = wl_to_ndev(wl);
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
            (wl->conf->rts_threshold != wiphy->rts_threshold)) {
                wl->conf->rts_threshold = wiphy->rts_threshold;
                err = wl_set_rts(ndev, wl->conf->rts_threshold);
                if (!err)
 -                      return err;
 +                      goto done;
        }
        if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
            (wl->conf->frag_threshold != wiphy->frag_threshold)) {
                wl->conf->frag_threshold = wiphy->frag_threshold;
                err = wl_set_frag(ndev, wl->conf->frag_threshold);
                if (!err)
 -                      return err;
 +                      goto done;
        }
        if (changed & WIPHY_PARAM_RETRY_LONG
            && (wl->conf->retry_long != wiphy->retry_long)) {
                wl->conf->retry_long = wiphy->retry_long;
                err = wl_set_retry(ndev, wl->conf->retry_long, true);
                if (!err)
 -                      return err;
 +                      goto done;
        }
        if (changed & WIPHY_PARAM_RETRY_SHORT
            && (wl->conf->retry_short != wiphy->retry_short)) {
                wl->conf->retry_short = wiphy->retry_short;
                err = wl_set_retry(ndev, wl->conf->retry_short, false);
 -              if (!err) {
 -                      return err;
 -              }
 +              if (!err)
 +                      goto done;
        }
  
 +done:
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -961,139 -989,68 +961,139 @@@ wl_cfg80211_join_ibss(struct wiphy *wip
                      struct cfg80211_ibss_params *params)
  {
        struct wl_priv *wl = wiphy_to_wl(wiphy);
 -      struct cfg80211_bss *bss;
 -      struct ieee80211_channel *chan;
        struct wl_join_params join_params;
 -      struct cfg80211_ssid ssid;
 -      s32 scan_retry = 0;
 +      size_t join_params_size = 0;
        s32 err = 0;
 +      s32 wsec = 0;
 +      s32 bcnprd;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 -      if (params->bssid) {
 -              WL_ERR("Invalid bssid\n");
 +
 +      if (params->ssid)
 +              WL_CONN("SSID: %s\n", params->ssid);
 +      else {
 +              WL_CONN("SSID: NULL, Not supported\n");
                return -EOPNOTSUPP;
        }
 -      bss = cfg80211_get_ibss(wiphy, NULL, params->ssid, params->ssid_len);
 -      if (!bss) {
 -              memcpy(ssid.ssid, params->ssid, params->ssid_len);
 -              ssid.ssid_len = params->ssid_len;
 -              do {
 -                      if (unlikely
 -                          (__wl_cfg80211_scan(wiphy, dev, NULL, &ssid) ==
 -                           -EBUSY)) {
 -                              wl_delay(150);
 -                      } else {
 -                              break;
 -                      }
 -              } while (++scan_retry < WL_SCAN_RETRY_MAX);
 -              rtnl_unlock();  /* to allow scan_inform to paropagate
 -                                       to cfg80211 plane */
 -              schedule_timeout_interruptible(4 * HZ); /* wait 4 secons
 -                                               till scan done.... */
 -              rtnl_lock();
 -              bss = cfg80211_get_ibss(wiphy, NULL,
 -                                      params->ssid, params->ssid_len);
 +
 +      if (params->bssid)
 +              WL_CONN("BSSID: %02X %02X %02X %02X %02X %02X\n",
 +              params->bssid[0], params->bssid[1], params->bssid[2],
 +              params->bssid[3], params->bssid[4], params->bssid[5]);
 +      else
 +              WL_CONN("No BSSID specified\n");
 +
 +      if (params->channel)
 +              WL_CONN("channel: %d\n", params->channel->center_freq);
 +      else
 +              WL_CONN("no channel specified\n");
 +
 +      if (params->channel_fixed)
 +              WL_CONN("fixed channel required\n");
 +      else
 +              WL_CONN("no fixed channel required\n");
 +
 +      if (params->ie && params->ie_len)
 +              WL_CONN("ie len: %d\n", params->ie_len);
 +      else
 +              WL_CONN("no ie specified\n");
 +
 +      if (params->beacon_interval)
 +              WL_CONN("beacon interval: %d\n", params->beacon_interval);
 +      else
 +              WL_CONN("no beacon interval specified\n");
 +
 +      if (params->basic_rates)
 +              WL_CONN("basic rates: %08X\n", params->basic_rates);
 +      else
 +              WL_CONN("no basic rates specified\n");
 +
 +      if (params->privacy)
 +              WL_CONN("privacy required\n");
 +      else
 +              WL_CONN("no privacy required\n");
 +
 +      /* Configure Privacy for starter */
 +      if (params->privacy)
 +              wsec |= WEP_ENABLED;
 +
 +      err = wl_dev_intvar_set(dev, "wsec", wsec);
 +      if (unlikely(err)) {
 +              WL_ERR("wsec failed (%d)\n", err);
 +              goto done;
 +      }
 +
 +      /* Configure Beacon Interval for starter */
 +      if (params->beacon_interval)
 +              bcnprd = cpu_to_le32(params->beacon_interval);
 +      else
 +              bcnprd = cpu_to_le32(100);
 +
 +      err = wl_dev_ioctl(dev, WLC_SET_BCNPRD, &bcnprd, sizeof(bcnprd));
 +      if (unlikely(err)) {
 +              WL_ERR("WLC_SET_BCNPRD failed (%d)\n", err);
 +              goto done;
        }
 -      if (bss) {
 -              wl->ibss_starter = false;
 -              WL_DBG("Found IBSS\n");
 +
 +      /* Configure required join parameter */
 +      memset(&join_params, 0, sizeof(wl_join_params_t));
 +
 +      /* SSID */
 +      join_params.ssid.SSID_len =
 +                      (params->ssid_len > 32) ? 32 : params->ssid_len;
 +      memcpy(join_params.ssid.SSID, params->ssid, join_params.ssid.SSID_len);
 +      join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
 +      join_params_size = sizeof(join_params.ssid);
 +      wl_update_prof(wl, NULL, &join_params.ssid, WL_PROF_SSID);
 +
 +      /* BSSID */
 +      if (params->bssid) {
 +              memcpy(join_params.params.bssid, params->bssid, ETH_ALEN);
 +              join_params_size =
 +                      sizeof(join_params.ssid) + WL_ASSOC_PARAMS_FIXED_SIZE;
        } else {
 -              wl->ibss_starter = true;
 +              memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
        }
 -      chan = params->channel;
 -      if (chan)
 -              wl->channel = ieee80211_frequency_to_channel(chan->center_freq);
 -      /*
 -       ** Join with specific BSSID and cached SSID
 -       ** If SSID is zero join based on BSSID only
 -       */
 -      memset(&join_params, 0, sizeof(join_params));
 -      memcpy((void *)join_params.ssid.SSID, (void *)params->ssid,
 -             params->ssid_len);
 -      join_params.ssid.SSID_len = cpu_to_le32(params->ssid_len);
 -      if (params->bssid)
 -              memcpy(&join_params.params.bssid, params->bssid,
 -                     ETH_ALEN);
 -      else
 -              memset(&join_params.params.bssid, 0, ETH_ALEN);
 +      wl_update_prof(wl, NULL, &join_params.params.bssid, WL_PROF_BSSID);
  
 -      err = wl_dev_ioctl(dev, WLC_SET_SSID, &join_params,
 -                      sizeof(join_params));
 +      /* Channel */
 +      if (params->channel) {
 +              u32 target_channel;
 +
 +              wl->channel =
 +                      ieee80211_frequency_to_channel(
 +                              params->channel->center_freq);
 +              if (params->channel_fixed) {
 +                      /* adding chanspec */
 +                      wl_ch_to_chanspec(wl->channel,
 +                              &join_params, &join_params_size);
 +              }
 +
 +              /* set channel for starter */
 +              target_channel = cpu_to_le32(wl->channel);
 +              err = wl_dev_ioctl(dev, WLC_SET_CHANNEL,
 +                      &target_channel, sizeof(target_channel));
 +              if (unlikely(err)) {
 +                      WL_ERR("WLC_SET_CHANNEL failed (%d)\n", err);
 +                      goto done;
 +              }
 +      } else
 +              wl->channel = 0;
 +
 +      wl->ibss_starter = false;
 +
 +
 +      err = wl_dev_ioctl(dev, WLC_SET_SSID, &join_params, join_params_size);
        if (unlikely(err)) {
 -              WL_ERR("Error (%d)\n", err);
 -              return err;
 +              WL_ERR("WLC_SET_SSID failed (%d)\n", err);
 +              goto done;
        }
 +
 +      set_bit(WL_STATUS_CONNECTING, &wl->status);
 +
 +done:
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -1102,13 -1059,9 +1102,13 @@@ static s32 wl_cfg80211_leave_ibss(struc
        struct wl_priv *wl = wiphy_to_wl(wiphy);
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        wl_link_down(wl);
  
 +      WL_TRACE("Exit\n");
 +
        return err;
  }
  
@@@ -1126,7 -1079,7 +1126,7 @@@ wl_set_wpa_version(struct net_device *d
                val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
        else
                val = WPA_AUTH_DISABLED;
 -      WL_DBG("setting wpa_auth to 0x%0x\n", val);
 +      WL_CONN("setting wpa_auth to 0x%0x\n", val);
        err = wl_dev_intvar_set(dev, "wpa_auth", val);
        if (unlikely(err)) {
                WL_ERR("set wpa_auth failed (%d)\n", err);
@@@ -1148,18 -1101,18 +1148,18 @@@ wl_set_auth_type(struct net_device *dev
        switch (sme->auth_type) {
        case NL80211_AUTHTYPE_OPEN_SYSTEM:
                val = 0;
 -              WL_DBG("open system\n");
 +              WL_CONN("open system\n");
                break;
        case NL80211_AUTHTYPE_SHARED_KEY:
                val = 1;
 -              WL_DBG("shared key\n");
 +              WL_CONN("shared key\n");
                break;
        case NL80211_AUTHTYPE_AUTOMATIC:
                val = 2;
 -              WL_DBG("automatic\n");
 +              WL_CONN("automatic\n");
                break;
        case NL80211_AUTHTYPE_NETWORK_EAP:
 -              WL_DBG("network eap\n");
 +              WL_CONN("network eap\n");
        default:
                val = 2;
                WL_ERR("invalid auth type (%d)\n", sme->auth_type);
@@@ -1228,7 -1181,7 +1228,7 @@@ wl_set_set_cipher(struct net_device *de
                }
        }
  
 -      WL_DBG("pval (%d) gval (%d)\n", pval, gval);
 +      WL_CONN("pval (%d) gval (%d)\n", pval, gval);
        err = wl_dev_intvar_set(dev, "wsec", pval | gval);
        if (unlikely(err)) {
                WL_ERR("error (%d)\n", err);
@@@ -1284,7 -1237,7 +1284,7 @@@ wl_set_key_mgmt(struct net_device *dev
                        }
                }
  
 -              WL_DBG("setting wpa_auth to %d\n", val);
 +              WL_CONN("setting wpa_auth to %d\n", val);
                err = wl_dev_intvar_set(dev, "wpa_auth", val);
                if (unlikely(err)) {
                        WL_ERR("could not set wpa_auth (%d)\n", err);
@@@ -1307,10 -1260,10 +1307,10 @@@ wl_set_set_sharedkey(struct net_device 
        s32 val;
        s32 err = 0;
  
 -      WL_DBG("key len (%d)\n", sme->key_len);
 +      WL_CONN("key len (%d)\n", sme->key_len);
        if (sme->key_len) {
                sec = wl_read_prof(wl, WL_PROF_SEC);
 -              WL_DBG("wpa_versions 0x%x cipher_pairwise 0x%x\n",
 +              WL_CONN("wpa_versions 0x%x cipher_pairwise 0x%x\n",
                       sec->wpa_versions, sec->cipher_pairwise);
                if (!
                    (sec->wpa_versions & (NL80211_WPA_VERSION_1 |
                                return -EINVAL;
                        }
                        /* Set the new key/index */
 -                      WL_DBG("key length (%d) key index (%d) algo (%d)\n",
 +                      WL_CONN("key length (%d) key index (%d) algo (%d)\n",
                               key.len, key.index, key.algo);
 -                      WL_DBG("key \"%s\"\n", key.data);
 +                      WL_CONN("key \"%s\"\n", key.data);
                        swap_key_from_BE(&key);
                        err = wl_dev_ioctl(dev, WLC_SET_KEY, &key,
                                        sizeof(key));
                                return err;
                        }
                        if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
 -                              WL_DBG("set auth_type to shared key\n");
 +                              WL_CONN("set auth_type to shared key\n");
                                val = 1;        /* shared key */
                                err = wl_dev_intvar_set(dev, "auth", val);
                                if (unlikely(err)) {
@@@ -1374,24 -1327,17 +1374,24 @@@ wl_cfg80211_connect(struct wiphy *wiphy
  
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        if (unlikely(!sme->ssid)) {
                WL_ERR("Invalid ssid\n");
                return -EOPNOTSUPP;
        }
 +
        if (chan) {
 -              wl->channel = ieee80211_frequency_to_channel(chan->center_freq);
 -              WL_DBG("channel (%d), center_req (%d)\n",
 -                     wl->channel, chan->center_freq);
 -      }
 -      WL_DBG("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
 +              wl->channel =
 +                      ieee80211_frequency_to_channel(chan->center_freq);
 +              WL_CONN("channel (%d), center_req (%d)\n",
 +                      wl->channel, chan->center_freq);
 +      } else
 +              wl->channel = 0;
 +
 +      WL_INFO("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
 +
        err = wl_set_wpa_version(dev, sme);
        if (unlikely(err))
                return err;
        memcpy(&join_params.ssid.SSID, sme->ssid, join_params.ssid.SSID_len);
        join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
        wl_update_prof(wl, NULL, &join_params.ssid, WL_PROF_SSID);
 -      memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
  
 -      wl_ch_to_chanspec(wl->channel, &join_params, &join_params_size);
 -      WL_DBG("join_param_size %zu\n", join_params_size);
 +      if (sme->bssid)
 +              memcpy(join_params.params.bssid, sme->bssid, ETH_ALEN);
 +      else
 +              memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
  
        if (join_params.ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
 -              WL_DBG("ssid \"%s\", len (%d)\n",
 +              WL_CONN("ssid \"%s\", len (%d)\n",
                       join_params.ssid.SSID, join_params.ssid.SSID_len);
        }
 +
 +      wl_ch_to_chanspec(wl->channel, &join_params, &join_params_size);
        err = wl_dev_ioctl(dev, WLC_SET_SSID, &join_params, join_params_size);
        if (unlikely(err)) {
                WL_ERR("error (%d)\n", err);
        }
        set_bit(WL_STATUS_CONNECTING, &wl->status);
  
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -1453,24 -1395,24 +1453,24 @@@ wl_cfg80211_disconnect(struct wiphy *wi
  {
        struct wl_priv *wl = wiphy_to_wl(wiphy);
        scb_val_t scbval;
 -      bool act = false;
        s32 err = 0;
  
 -      WL_DBG("Reason %d\n", reason_code);
 +      WL_TRACE("Enter. Reason code = %d\n", reason_code);
        CHECK_SYS_UP();
 -      act = *(bool *) wl_read_prof(wl, WL_PROF_ACT);
 -      if (likely(act)) {
 -              scbval.val = reason_code;
 -              memcpy(&scbval.ea, &wl->bssid, ETH_ALEN);
 -              scbval.val = cpu_to_le32(scbval.val);
 -              err = wl_dev_ioctl(dev, WLC_DISASSOC, &scbval,
 -                              sizeof(scb_val_t));
 -              if (unlikely(err)) {
 -                      WL_ERR("error (%d)\n", err);
 -                      return err;
 -              }
 -      }
  
 +      clear_bit(WL_STATUS_CONNECTED, &wl->status);
 +
 +      scbval.val = reason_code;
 +      memcpy(&scbval.ea, wl_read_prof(wl, WL_PROF_BSSID), ETH_ALEN);
 +      scbval.val = cpu_to_le32(scbval.val);
 +      err = wl_dev_ioctl(dev, WLC_DISASSOC, &scbval,
 +                      sizeof(scb_val_t));
 +      if (unlikely(err))
 +              WL_ERR("error (%d)\n", err);
 +
 +      wl->link_up = false;
 +
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -1485,24 -1427,20 +1485,24 @@@ wl_cfg80211_set_tx_power(struct wiphy *
        s32 err = 0;
        s32 disable = 0;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        switch (type) {
        case NL80211_TX_POWER_AUTOMATIC:
                break;
        case NL80211_TX_POWER_LIMITED:
                if (dbm < 0) {
                        WL_ERR("TX_POWER_LIMITED - dbm is negative\n");
 -                      return -EINVAL;
 +                      err = -EINVAL;
 +                      goto done;
                }
                break;
        case NL80211_TX_POWER_FIXED:
                if (dbm < 0) {
                        WL_ERR("TX_POWER_FIXED - dbm is negative\n");
 -                      return -EINVAL;
 +                      err = -EINVAL;
 +                      goto done;
                }
                break;
        }
        disable = WL_RADIO_SW_DISABLE << 16;
        disable = cpu_to_le32(disable);
        err = wl_dev_ioctl(ndev, WLC_SET_RADIO, &disable, sizeof(disable));
 -      if (unlikely(err)) {
 +      if (unlikely(err))
                WL_ERR("WLC_SET_RADIO error (%d)\n", err);
 -              return err;
 -      }
  
        if (dbm > 0xffff)
                txpwrmw = 0xffff;
                txpwrmw = (u16) dbm;
        err = wl_dev_intvar_set(ndev, "qtxpower",
                        (s32) (bcm_mw_to_qdbm(txpwrmw)));
 -      if (unlikely(err)) {
 +      if (unlikely(err))
                WL_ERR("qtxpower error (%d)\n", err);
 -              return err;
 -      }
        wl->conf->tx_power = dbm;
  
 +done:
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -1536,20 -1476,15 +1536,20 @@@ static s32 wl_cfg80211_get_tx_power(str
        u8 result;
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        err = wl_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
        if (unlikely(err)) {
                WL_ERR("error (%d)\n", err);
 -              return err;
 +              goto done;
        }
 +
        result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
        *dbm = (s32) bcm_qdbm_to_mw(result);
  
 +done:
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -1561,16 -1496,14 +1561,16 @@@ wl_cfg80211_config_default_key(struct w
        s32 wsec;
        s32 err = 0;
  
 -      WL_DBG("key index (%d)\n", key_idx);
 +      WL_TRACE("Enter\n");
 +      WL_CONN("key index (%d)\n", key_idx);
        CHECK_SYS_UP();
  
        err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
        if (unlikely(err)) {
                WL_ERR("WLC_GET_WSEC error (%d)\n", err);
 -              return err;
 +              goto done;
        }
 +
        wsec = le32_to_cpu(wsec);
        if (wsec & WEP_ENABLED) {
                /* Just select a new current key */
                index = cpu_to_le32(index);
                err = wl_dev_ioctl(dev, WLC_SET_KEY_PRIMARY, &index,
                                sizeof(index));
 -              if (unlikely(err)) {
 +              if (unlikely(err))
                        WL_ERR("error (%d)\n", err);
 -              }
        }
 +done:
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -1615,7 -1547,7 +1615,7 @@@ wl_add_keyext(struct wiphy *wiphy, stru
                        return -EINVAL;
                }
  
 -              WL_DBG("Setting the key index %d\n", key.index);
 +              WL_CONN("Setting the key index %d\n", key.index);
                memcpy(key.data, params->key, key.len);
  
                if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
                switch (params->cipher) {
                case WLAN_CIPHER_SUITE_WEP40:
                        key.algo = CRYPTO_ALGO_WEP1;
 -                      WL_DBG("WLAN_CIPHER_SUITE_WEP40\n");
 +                      WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
                        break;
                case WLAN_CIPHER_SUITE_WEP104:
                        key.algo = CRYPTO_ALGO_WEP128;
 -                      WL_DBG("WLAN_CIPHER_SUITE_WEP104\n");
 +                      WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
                        break;
                case WLAN_CIPHER_SUITE_TKIP:
                        key.algo = CRYPTO_ALGO_TKIP;
 -                      WL_DBG("WLAN_CIPHER_SUITE_TKIP\n");
 +                      WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
                        break;
                case WLAN_CIPHER_SUITE_AES_CMAC:
                        key.algo = CRYPTO_ALGO_AES_CCM;
 -                      WL_DBG("WLAN_CIPHER_SUITE_AES_CMAC\n");
 +                      WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
                        break;
                case WLAN_CIPHER_SUITE_CCMP:
                        key.algo = CRYPTO_ALGO_AES_CCM;
 -                      WL_DBG("WLAN_CIPHER_SUITE_CCMP\n");
 +                      WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
                        break;
                default:
                        WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
@@@ -1682,16 -1614,12 +1682,16 @@@ wl_cfg80211_add_key(struct wiphy *wiphy
        s32 val;
        s32 wsec;
        s32 err = 0;
 +      u8 keybuf[8];
  
 -      WL_DBG("key index (%d)\n", key_idx);
 +      WL_TRACE("Enter\n");
 +      WL_CONN("key index (%d)\n", key_idx);
        CHECK_SYS_UP();
  
 -      if (mac_addr)
 +      if (mac_addr) {
 +              WL_TRACE("Exit");
                return wl_add_keyext(wiphy, dev, key_idx, mac_addr, params);
 +      }
        memset(&key, 0, sizeof(key));
  
        key.len = (u32) params->key_len;
  
        if (unlikely(key.len > sizeof(key.data))) {
                WL_ERR("Too long key length (%u)\n", key.len);
 -              return -EINVAL;
 +              err = -EINVAL;
 +              goto done;
        }
        memcpy(key.data, params->key, key.len);
  
        switch (params->cipher) {
        case WLAN_CIPHER_SUITE_WEP40:
                key.algo = CRYPTO_ALGO_WEP1;
 -              WL_DBG("WLAN_CIPHER_SUITE_WEP40\n");
 +              WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
                break;
        case WLAN_CIPHER_SUITE_WEP104:
                key.algo = CRYPTO_ALGO_WEP128;
 -              WL_DBG("WLAN_CIPHER_SUITE_WEP104\n");
 +              WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
                break;
        case WLAN_CIPHER_SUITE_TKIP:
 +              memcpy(keybuf, &key.data[24], sizeof(keybuf));
 +              memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
 +              memcpy(&key.data[16], keybuf, sizeof(keybuf));
                key.algo = CRYPTO_ALGO_TKIP;
 -              WL_DBG("WLAN_CIPHER_SUITE_TKIP\n");
 +              WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
                break;
        case WLAN_CIPHER_SUITE_AES_CMAC:
                key.algo = CRYPTO_ALGO_AES_CCM;
 -              WL_DBG("WLAN_CIPHER_SUITE_AES_CMAC\n");
 +              WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
                break;
        case WLAN_CIPHER_SUITE_CCMP:
                key.algo = CRYPTO_ALGO_AES_CCM;
 -              WL_DBG("WLAN_CIPHER_SUITE_CCMP\n");
 +              WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
                break;
        default:
                WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
 -              return -EINVAL;
 +              err = -EINVAL;
 +              goto done;
        }
  
        /* Set the new key/index */
        err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
        if (unlikely(err)) {
                WL_ERR("WLC_SET_KEY error (%d)\n", err);
 -              return err;
 +              goto done;
        }
  
        val = WEP_ENABLED;
        err = wl_dev_intvar_get(dev, "wsec", &wsec);
        if (unlikely(err)) {
                WL_ERR("get wsec error (%d)\n", err);
 -              return err;
 +              goto done;
        }
        wsec &= ~(WEP_ENABLED);
        wsec |= val;
        err = wl_dev_intvar_set(dev, "wsec", wsec);
        if (unlikely(err)) {
                WL_ERR("set wsec error (%d)\n", err);
 -              return err;
 +              goto done;
        }
  
        val = 1;                /* assume shared key. otherwise 0 */
        val = cpu_to_le32(val);
        err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
 -      if (unlikely(err)) {
 +      if (unlikely(err))
                WL_ERR("WLC_SET_AUTH error (%d)\n", err);
 -              return err;
 -      }
 +done:
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -1776,7 -1699,6 +1776,7 @@@ wl_cfg80211_del_key(struct wiphy *wiphy
        s32 val;
        s32 wsec;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
        memset(&key, 0, sizeof(key));
  
        key.flags = WL_PRIMARY_KEY;
        key.algo = CRYPTO_ALGO_OFF;
  
 -      WL_DBG("key index (%d)\n", key_idx);
 +      WL_CONN("key index (%d)\n", key_idx);
        /* Set the new key/index */
        swap_key_from_BE(&key);
        err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
        if (unlikely(err)) {
                if (err == -EINVAL) {
 -                      if (key.index >= DOT11_MAX_DEFAULT_KEYS) {
 +                      if (key.index >= DOT11_MAX_DEFAULT_KEYS)
                                /* we ignore this key index in this case */
 -                              WL_DBG("invalid key index (%d)\n", key_idx);
 -                      }
 -              } else {
 +                              WL_ERR("invalid key index (%d)\n", key_idx);
 +              } else
                        WL_ERR("WLC_SET_KEY error (%d)\n", err);
 -              }
 -              return err;
 +
 +              /* Ignore this error, may happen during DISASSOC */
 +              err = -EAGAIN;
 +              goto done;
        }
  
        val = 0;
        err = wl_dev_intvar_get(dev, "wsec", &wsec);
        if (unlikely(err)) {
                WL_ERR("get wsec error (%d)\n", err);
 -              return err;
 +              /* Ignore this error, may happen during DISASSOC */
 +              err = -EAGAIN;
 +              goto done;
        }
        wsec &= ~(WEP_ENABLED);
        wsec |= val;
        err = wl_dev_intvar_set(dev, "wsec", wsec);
        if (unlikely(err)) {
                WL_ERR("set wsec error (%d)\n", err);
 -              return err;
 +              /* Ignore this error, may happen during DISASSOC */
 +              err = -EAGAIN;
 +              goto done;
        }
  
        val = 0;                /* assume open key. otherwise 1 */
        err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
        if (unlikely(err)) {
                WL_ERR("WLC_SET_AUTH error (%d)\n", err);
 -              return err;
 +              /* Ignore this error, may happen during DISASSOC */
 +              err = -EAGAIN;
        }
 +done:
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -1844,8 -1758,7 +1844,8 @@@ wl_cfg80211_get_key(struct wiphy *wiphy
        s32 wsec;
        s32 err = 0;
  
 -      WL_DBG("key index (%d)\n", key_idx);
 +      WL_TRACE("Enter\n");
 +      WL_CONN("key index (%d)\n", key_idx);
        CHECK_SYS_UP();
  
        memset(&key, 0, sizeof(key));
        err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
        if (unlikely(err)) {
                WL_ERR("WLC_GET_WSEC error (%d)\n", err);
 -              return err;
 +              /* Ignore this error, may happen during DISASSOC */
 +              err = -EAGAIN;
 +              goto done;
        }
        wsec = le32_to_cpu(wsec);
        switch (wsec) {
                sec = wl_read_prof(wl, WL_PROF_SEC);
                if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
                        params.cipher = WLAN_CIPHER_SUITE_WEP40;
 -                      WL_DBG("WLAN_CIPHER_SUITE_WEP40\n");
 +                      WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
                } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
                        params.cipher = WLAN_CIPHER_SUITE_WEP104;
 -                      WL_DBG("WLAN_CIPHER_SUITE_WEP104\n");
 +                      WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
                }
                break;
        case TKIP_ENABLED:
                params.cipher = WLAN_CIPHER_SUITE_TKIP;
 -              WL_DBG("WLAN_CIPHER_SUITE_TKIP\n");
 +              WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
                break;
        case AES_ENABLED:
                params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
 -              WL_DBG("WLAN_CIPHER_SUITE_AES_CMAC\n");
 +              WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
                break;
        default:
                WL_ERR("Invalid algo (0x%x)\n", wsec);
 -              return -EINVAL;
 +              err = -EINVAL;
 +              goto done;
        }
 -
        callback(cookie, &params);
 +
 +done:
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -1899,7 -1807,6 +1899,7 @@@ wl_cfg80211_config_default_mgmt_key(str
                                    struct net_device *dev, u8 key_idx)
  {
        WL_INFO("Not supported\n");
 +
        CHECK_SYS_UP();
        return -EOPNOTSUPP;
  }
@@@ -1913,20 -1820,12 +1913,20 @@@ wl_cfg80211_get_station(struct wiphy *w
        int rssi;
        s32 rate;
        s32 err = 0;
 +      u8 *bssid = wl_read_prof(wl, WL_PROF_BSSID);
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        if (unlikely
 -          (memcmp(mac, wl_read_prof(wl, WL_PROF_BSSID), ETH_ALEN))) {
 -              WL_ERR("Wrong Mac address\n");
 -              return -ENOENT;
 +          (memcmp(mac, bssid, ETH_ALEN))) {
 +              WL_ERR("Wrong Mac address cfg_mac-%X:%X:%X:%X:%X:%X"
 +                      "wl_bssid-%X:%X:%X:%X:%X:%X\n",
 +                      mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
 +                      bssid[0], bssid[1], bssid[2], bssid[3],
 +                      bssid[4], bssid[5]);
 +              err = -ENOENT;
 +              goto done;
        }
  
        /* Report the current tx rate */
                rate = le32_to_cpu(rate);
                sinfo->filled |= STATION_INFO_TX_BITRATE;
                sinfo->txrate.legacy = rate * 5;
 -              WL_DBG("Rate %d Mbps\n", rate / 2);
 +              WL_CONN("Rate %d Mbps\n", rate / 2);
        }
  
        if (test_bit(WL_STATUS_CONNECTED, &wl->status)) {
                                sizeof(scb_val_t));
                if (unlikely(err)) {
                        WL_ERR("Could not get rssi (%d)\n", err);
 -                      return err;
                }
                rssi = le32_to_cpu(scb_val.val);
                sinfo->filled |= STATION_INFO_SIGNAL;
                sinfo->signal = rssi;
 -              WL_DBG("RSSI %d dBm\n", rssi);
 +              WL_CONN("RSSI %d dBm\n", rssi);
        }
  
 +done:
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -1965,21 -1863,18 +1965,21 @@@ wl_cfg80211_set_power_mgmt(struct wiph
        s32 pm;
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        pm = enabled ? PM_FAST : PM_OFF;
        pm = cpu_to_le32(pm);
 -      WL_DBG("power save %s\n", (pm ? "enabled" : "disabled"));
 +      WL_INFO("power save %s\n", (pm ? "enabled" : "disabled"));
 +
        err = wl_dev_ioctl(dev, WLC_SET_PM, &pm, sizeof(pm));
        if (unlikely(err)) {
                if (err == -ENODEV)
 -                      WL_DBG("net_device is not ready yet\n");
 +                      WL_ERR("net_device is not ready yet\n");
                else
                        WL_ERR("error (%d)\n", err);
 -              return err;
        }
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -2023,16 -1918,14 +2023,16 @@@ wl_cfg80211_set_bitrate_mask(struct wip
        u32 legacy;
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        /* addr param is always NULL. ignore it */
        /* Get current rateset */
        err = wl_dev_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
                        sizeof(rateset));
        if (unlikely(err)) {
                WL_ERR("could not get current rateset (%d)\n", err);
 -              return err;
 +              goto done;
        }
  
        rateset.count = le32_to_cpu(rateset.count);
  
        val = wl_g_rates[legacy - 1].bitrate * 100000;
  
 -      if (val < rateset.count) {
 +      if (val < rateset.count)
                /* Select rate by rateset index */
                rate = rateset.rates[val] & 0x7f;
 -      } else {
 +      else
                /* Specified rate in bps */
                rate = val / 500000;
 -      }
  
 -      WL_DBG("rate %d mbps\n", rate / 2);
 +      WL_CONN("rate %d mbps\n", rate / 2);
  
        /*
         *
        err_a = wl_dev_intvar_set(dev, "a_rate", rate);
        if (unlikely(err_bg && err_a)) {
                WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
 -              return err_bg | err_a;
 +              err = err_bg | err_a;
        }
  
 +done:
 +      WL_TRACE("Exit\n");
        return err;
  }
  
  static s32 wl_cfg80211_resume(struct wiphy *wiphy)
  {
 -      s32 err = 0;
 +      struct wl_priv *wl = wiphy_to_wl(wiphy);
 +      struct net_device *ndev = wl_to_ndev(wl);
  
 -      CHECK_SYS_UP();
 -      wl_invoke_iscan(wiphy_to_wl(wiphy));
 +      /*
 +       * Check for WL_STATUS_READY before any function call which
 +       * could result is bus access. Don't block the resume for
 +       * any driver error conditions
 +       */
 +      WL_TRACE("Enter\n");
  
 -      return err;
 +#if defined(CONFIG_PM_SLEEP)
 +      atomic_set(&dhd_mmc_suspend, false);
 +#endif        /*  defined(CONFIG_PM_SLEEP) */
 +
 +      if (test_bit(WL_STATUS_READY, &wl->status)) {
 +              /* Turn on Watchdog timer */
 +              wl_os_wd_timer(ndev, dhd_watchdog_ms);
 +              wl_invoke_iscan(wiphy_to_wl(wiphy));
 +      }
 +
 +      WL_TRACE("Exit\n");
 +      return 0;
  }
  
  static s32 wl_cfg80211_suspend(struct wiphy *wiphy)
  {
        struct wl_priv *wl = wiphy_to_wl(wiphy);
        struct net_device *ndev = wl_to_ndev(wl);
 -      s32 err = 0;
 +
 +      WL_TRACE("Enter\n");
 +
 +      /*
 +       * Check for WL_STATUS_READY before any function call which
 +       * could result is bus access. Don't block the suspend for
 +       * any driver error conditions
 +       */
 +
 +      /*
 +       * While going to suspend if associated with AP disassociate
 +       * from AP to save power while system is in suspended state
 +       */
 +      if (test_bit(WL_STATUS_CONNECTED, &wl->status) &&
 +              test_bit(WL_STATUS_READY, &wl->status)) {
 +              WL_INFO("Disassociating from AP"
 +                      " while entering suspend state\n");
 +              wl_link_down(wl);
 +
 +              /*
 +               * Make sure WPA_Supplicant receives all the event
 +               * generated due to DISASSOC call to the fw to keep
 +               * the state fw and WPA_Supplicant state consistent
 +               */
 +              rtnl_unlock();
 +              wl_delay(500);
 +              rtnl_lock();
 +      }
  
        set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
 -      wl_term_iscan(wl);
 +      if (test_bit(WL_STATUS_READY, &wl->status))
 +              wl_term_iscan(wl);
 +
        if (wl->scan_request) {
 -              cfg80211_scan_done(wl->scan_request, true);     /* true means
 -                                                               abort */
 -              wl_set_mpc(ndev, 1);
 +              /* Indidate scan abort to cfg80211 layer */
 +              WL_INFO("Terminating scan in progress\n");
 +              cfg80211_scan_done(wl->scan_request, true);
                wl->scan_request = NULL;
        }
        clear_bit(WL_STATUS_SCANNING, &wl->status);
        clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
 +      clear_bit(WL_STATUS_CONNECTING, &wl->status);
 +      clear_bit(WL_STATUS_CONNECTED, &wl->status);
  
 -      return err;
 +      /* Inform SDIO stack not to switch off power to the chip */
 +      sdioh_sdio_set_host_pm_flags(MMC_PM_KEEP_POWER);
 +
 +      /* Turn off watchdog timer */
 +      if (test_bit(WL_STATUS_READY, &wl->status)) {
 +              WL_INFO("Terminate watchdog timer and enable MPC\n");
 +              wl_set_mpc(ndev, 1);
 +              wl_os_wd_timer(ndev, 0);
 +      }
 +
 +#if defined(CONFIG_PM_SLEEP)
 +      atomic_set(&dhd_mmc_suspend, true);
 +#endif        /*  defined(CONFIG_PM_SLEEP) */
 +
 +      WL_TRACE("Exit\n");
 +
 +      return 0;
  }
  
  static __used s32
@@@ -2168,17 -1997,18 +2168,17 @@@ wl_update_pmklist(struct net_device *de
  {
        int i, j;
  
 -      WL_DBG("No of elements %d\n", pmk_list->pmkids.npmkid);
 +      WL_CONN("No of elements %d\n", pmk_list->pmkids.npmkid);
        for (i = 0; i < pmk_list->pmkids.npmkid; i++) {
 -              WL_DBG("PMKID[%d]: %pM =\n", i,
 +              WL_CONN("PMKID[%d]: %pM =\n", i,
                        &pmk_list->pmkids.pmkid[i].BSSID);
 -              for (j = 0; j < WLAN_PMKID_LEN; j++) {
 -                      WL_DBG("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
 -              }
 +              for (j = 0; j < WLAN_PMKID_LEN; j++)
 +                      WL_CONN("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
        }
 -      if (likely(!err)) {
 -              err = wl_dev_bufvar_set(dev, "pmkid_info", (char *)pmk_list,
 +
 +      if (likely(!err))
 +              wl_dev_bufvar_set(dev, "pmkid_info", (char *)pmk_list,
                                        sizeof(*pmk_list));
 -      }
  
        return err;
  }
@@@ -2191,9 -2021,7 +2191,9 @@@ wl_cfg80211_set_pmksa(struct wiphy *wip
        s32 err = 0;
        int i;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
                if (!memcmp(pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
                            ETH_ALEN))
                       WLAN_PMKID_LEN);
                if (i == wl->pmk_list->pmkids.npmkid)
                        wl->pmk_list->pmkids.npmkid++;
 -      } else {
 +      } else
                err = -EINVAL;
 -      }
 -      WL_DBG("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
 +
 +      WL_CONN("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
               &wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].BSSID);
 -      for (i = 0; i < WLAN_PMKID_LEN; i++) {
 -              WL_DBG("%02x\n",
 +      for (i = 0; i < WLAN_PMKID_LEN; i++)
 +              WL_CONN("%02x\n",
                       wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].
                       PMKID[i]);
  
        err = wl_update_pmklist(dev, wl->pmk_list, err);
  
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -2230,15 -2058,15 +2230,15 @@@ wl_cfg80211_del_pmksa(struct wiphy *wip
        s32 err = 0;
        int i;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
        memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
        memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
  
 -      WL_DBG("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
 +      WL_CONN("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
               &pmkid.pmkid[0].BSSID);
 -      for (i = 0; i < WLAN_PMKID_LEN; i++) {
 -              WL_DBG("%02x\n", pmkid.pmkid[0].PMKID[i]);
 -      }
 +      for (i = 0; i < WLAN_PMKID_LEN; i++)
 +              WL_CONN("%02x\n", pmkid.pmkid[0].PMKID[i]);
  
        for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
                if (!memcmp
                               WLAN_PMKID_LEN);
                }
                wl->pmk_list->pmkids.npmkid--;
 -      } else {
 +      } else
                err = -EINVAL;
  
        err = wl_update_pmklist(dev, wl->pmk_list, err);
  
 +      WL_TRACE("Exit\n");
        return err;
  
  }
@@@ -2274,13 -2102,9 +2274,13 @@@ wl_cfg80211_flush_pmksa(struct wiphy *w
        struct wl_priv *wl = wiphy_to_wl(wiphy);
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
        CHECK_SYS_UP();
 +
        memset(wl->pmk_list, 0, sizeof(*wl->pmk_list));
        err = wl_update_pmklist(dev, wl->pmk_list, err);
 +
 +      WL_TRACE("Exit\n");
        return err;
  
  }
@@@ -2411,7 -2235,7 +2411,7 @@@ static s32 wl_inform_bss(struct wl_pri
                       bss_list->version);
                return -EOPNOTSUPP;
        }
 -      WL_DBG("scanned AP count (%d)\n", bss_list->count);
 +      WL_SCAN("scanned AP count (%d)\n", bss_list->count);
        bi = next_bss(bss_list, bi);
        for_each_bss(bss_list, bi, i) {
                err = wl_inform_single_bss(wl, bi);
        return err;
  }
  
 +
  static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
  {
        struct wiphy *wiphy = wl_to_wiphy(wl);
 -      struct ieee80211_mgmt *mgmt;
 -      struct ieee80211_channel *channel;
 +      struct ieee80211_channel *notify_channel;
 +      struct cfg80211_bss *bss;
        struct ieee80211_supported_band *band;
 -      struct wl_cfg80211_bss_info *notif_bss_info;
 -      struct wl_scan_req *sr = wl_to_sr(wl);
 -      struct beacon_proberesp *beacon_proberesp;
 -      s32 mgmt_type;
 -      u32 signal;
 -      u32 freq;
        s32 err = 0;
 +      u16 channel;
 +      u32 freq;
 +      u64 notify_timestamp;
 +      u16 notify_capability;
 +      u16 notify_interval;
 +      u8 *notify_ie;
 +      size_t notify_ielen;
 +      s32 notify_signal;
  
        if (unlikely(le32_to_cpu(bi->length) > WL_BSS_INFO_MAX)) {
 -              WL_DBG("Beacon is larger than buffer. Discarding\n");
 -              return err;
 -      }
 -      notif_bss_info =
 -          kzalloc(sizeof(*notif_bss_info) + sizeof(*mgmt) - sizeof(u8) +
 -                  WL_BSS_INFO_MAX, GFP_KERNEL);
 -      if (unlikely(!notif_bss_info)) {
 -              WL_ERR("notif_bss_info alloc failed\n");
 -              return -ENOMEM;
 +              WL_ERR("Bss info is larger than buffer. Discarding\n");
 +              return 0;
        }
 -      mgmt = (struct ieee80211_mgmt *)notif_bss_info->frame_buf;
 -      notif_bss_info->channel =
 -              bi->ctl_ch ? bi->ctl_ch : CHSPEC_CHANNEL(bi->chanspec);
  
 -      if (notif_bss_info->channel <= CH_MAX_2G_CHANNEL)
 +      channel = bi->ctl_ch ? bi->ctl_ch :
 +                              CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
 +
 +      if (channel <= CH_MAX_2G_CHANNEL)
                band = wiphy->bands[IEEE80211_BAND_2GHZ];
        else
                band = wiphy->bands[IEEE80211_BAND_5GHZ];
 -      notif_bss_info->rssi = bi->RSSI;
 -      memcpy(mgmt->bssid, &bi->BSSID, ETH_ALEN);
 -      mgmt_type = wl->active_scan ?
 -              IEEE80211_STYPE_PROBE_RESP : IEEE80211_STYPE_BEACON;
 -      if (!memcmp(bi->SSID, sr->ssid.SSID, bi->SSID_len)) {
 -              mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
 -                                                      mgmt_type);
 -      }
 -      beacon_proberesp = wl->active_scan ?
 -              (struct beacon_proberesp *)&mgmt->u.probe_resp :
 -              (struct beacon_proberesp *)&mgmt->u.beacon;
 -      beacon_proberesp->timestamp = 0;
 -      beacon_proberesp->beacon_int = cpu_to_le16(bi->beacon_period);
 -      beacon_proberesp->capab_info = cpu_to_le16(bi->capability);
 -      wl_rst_ie(wl);
 -      /*
 -      * wl_add_ie is not necessary because it can only add duplicated
 -      * SSID, rate information to frame_buf
 -      */
 -      /*
 -      * wl_add_ie(wl, WLAN_EID_SSID, bi->SSID_len, bi->SSID);
 -      * wl_add_ie(wl, WLAN_EID_SUPP_RATES, bi->rateset.count,
 -      * bi->rateset.rates);
 -      */
 -      wl_mrg_ie(wl, ((u8 *) bi) + bi->ie_offset, bi->ie_length);
 -      wl_cp_ie(wl, beacon_proberesp->variable, WL_BSS_INFO_MAX -
 -               offsetof(struct wl_cfg80211_bss_info, frame_buf));
 -      notif_bss_info->frame_len =
 -          offsetof(struct ieee80211_mgmt,
 -                   u.beacon.variable) + wl_get_ielen(wl);
 -      freq = ieee80211_channel_to_frequency(notif_bss_info->channel,
 -                                            band->band);
 -
 -      channel = ieee80211_get_channel(wiphy, freq);
 -
 -      WL_DBG("SSID : \"%s\", rssi %d, channel %d, capability : 0x04%x, bssid %pM\n",
 -             bi->SSID,
 -             notif_bss_info->rssi, notif_bss_info->channel,
 -             mgmt->u.beacon.capab_info, &bi->BSSID);
 -
 -      signal = notif_bss_info->rssi * 100;
 -      if (unlikely(!cfg80211_inform_bss_frame(wiphy, channel, mgmt,
 -                                              le16_to_cpu
 -                                              (notif_bss_info->frame_len),
 -                                              signal, GFP_KERNEL))) {
 +
 +      freq = ieee80211_channel_to_frequency(channel, band->band);
 +      notify_channel = ieee80211_get_channel(wiphy, freq);
 +
 +      notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
 +      notify_capability = le16_to_cpu(bi->capability);
 +      notify_interval = le16_to_cpu(bi->beacon_period);
 +      notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
 +      notify_ielen = le16_to_cpu(bi->ie_length);
 +      notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
 +
 +      WL_CONN("bssid: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
 +                      bi->BSSID[0], bi->BSSID[1], bi->BSSID[2],
 +                      bi->BSSID[3], bi->BSSID[4], bi->BSSID[5]);
 +      WL_CONN("Channel: %d(%d)\n", channel, freq);
 +      WL_CONN("Capability: %X\n", notify_capability);
 +      WL_CONN("Beacon interval: %d\n", notify_interval);
 +      WL_CONN("Signal: %d\n", notify_signal);
 +      WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
 +
 +      bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
 +              notify_timestamp, notify_capability, notify_interval, notify_ie,
 +              notify_ielen, notify_signal, GFP_KERNEL);
 +
 +      if (unlikely(!bss)) {
                WL_ERR("cfg80211_inform_bss_frame error\n");
 -              kfree(notif_bss_info);
                return -EINVAL;
        }
 -      kfree(notif_bss_info);
 +
 +      return err;
 +}
 +
 +static s32
 +wl_inform_ibss(struct wl_priv *wl, struct net_device *dev, const u8 *bssid)
 +{
 +      struct wiphy *wiphy = wl_to_wiphy(wl);
 +      struct ieee80211_channel *notify_channel;
 +      struct wl_bss_info *bi = NULL;
 +      struct ieee80211_supported_band *band;
 +      u8 *buf = NULL;
 +      s32 err = 0;
 +      u16 channel;
 +      u32 freq;
 +      u64 notify_timestamp;
 +      u16 notify_capability;
 +      u16 notify_interval;
 +      u8 *notify_ie;
 +      size_t notify_ielen;
 +      s32 notify_signal;
 +
 +      WL_TRACE("Enter\n");
 +
 +      buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
 +      if (buf == NULL) {
 +              WL_ERR("kzalloc() failed\n");
 +              err = -ENOMEM;
 +              goto CleanUp;
 +      }
 +
 +      *(u32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
 +
 +      err = wl_dev_ioctl(dev, WLC_GET_BSS_INFO, buf, WL_BSS_INFO_MAX);
 +      if (unlikely(err)) {
 +              WL_ERR("WLC_GET_BSS_INFO failed: %d\n", err);
 +              goto CleanUp;
 +      }
 +
 +      bi = (wl_bss_info_t *)(buf + 4);
 +
 +      channel = bi->ctl_ch ? bi->ctl_ch :
 +                              CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
 +
 +      if (channel <= CH_MAX_2G_CHANNEL)
 +              band = wiphy->bands[IEEE80211_BAND_2GHZ];
 +      else
 +              band = wiphy->bands[IEEE80211_BAND_5GHZ];
 +
 +      freq = ieee80211_channel_to_frequency(channel, band->band);
 +      notify_channel = ieee80211_get_channel(wiphy, freq);
 +
 +      notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
 +      notify_capability = le16_to_cpu(bi->capability);
 +      notify_interval = le16_to_cpu(bi->beacon_period);
 +      notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
 +      notify_ielen = le16_to_cpu(bi->ie_length);
 +      notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
 +
 +      WL_CONN("channel: %d(%d)\n", channel, freq);
 +      WL_CONN("capability: %X\n", notify_capability);
 +      WL_CONN("beacon interval: %d\n", notify_interval);
 +      WL_CONN("signal: %d\n", notify_signal);
 +      WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
 +
 +      cfg80211_inform_bss(wiphy, notify_channel, bssid,
 +              notify_timestamp, notify_capability, notify_interval,
 +              notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
 +
 +CleanUp:
 +
 +      kfree(buf);
 +
 +      WL_TRACE("Exit\n");
  
        return err;
  }
  static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e)
  {
        u32 event = be32_to_cpu(e->event_type);
 -      u16 flags = be16_to_cpu(e->flags);
 +      u32 status = be32_to_cpu(e->status);
  
 -      if (event == WLC_E_LINK) {
 -              if (flags & WLC_EVENT_MSG_LINK) {
 -                      if (wl_is_ibssmode(wl)) {
 -                              if (wl_is_ibssstarter(wl)) {
 -                              }
 -                      } else {
 -                              return true;
 -                      }
 -              }
 +      if (event == WLC_E_SET_SSID && status == WLC_E_STATUS_SUCCESS) {
 +              WL_CONN("Processing set ssid\n");
 +              wl->link_up = true;
 +              return true;
        }
  
        return false;
@@@ -2575,10 -2356,13 +2575,10 @@@ static bool wl_is_linkdown(struct wl_pr
        u32 event = be32_to_cpu(e->event_type);
        u16 flags = be16_to_cpu(e->flags);
  
 -      if (event == WLC_E_DEAUTH_IND || event == WLC_E_DISASSOC_IND) {
 +      if (event == WLC_E_LINK && (!(flags & WLC_EVENT_MSG_LINK))) {
 +              WL_CONN("Processing link down\n");
                return true;
 -      } else if (event == WLC_E_LINK) {
 -              if (!(flags & WLC_EVENT_MSG_LINK))
 -                      return true;
        }
 -
        return false;
  }
  
@@@ -2586,17 -2370,10 +2586,17 @@@ static bool wl_is_nonetwork(struct wl_p
  {
        u32 event = be32_to_cpu(e->event_type);
        u32 status = be32_to_cpu(e->status);
 +      u16 flags = be16_to_cpu(e->flags);
 +
 +      if (event == WLC_E_LINK && status == WLC_E_STATUS_NO_NETWORKS) {
 +              WL_CONN("Processing Link %s & no network found\n",
 +                              flags & WLC_EVENT_MSG_LINK ? "up" : "down");
 +              return true;
 +      }
  
 -      if (event == WLC_E_SET_SSID || event == WLC_E_LINK) {
 -              if (status == WLC_E_STATUS_NO_NETWORKS)
 -                      return true;
 +      if (event == WLC_E_SET_SSID && status != WLC_E_STATUS_SUCCESS) {
 +              WL_CONN("Processing connecting & no network found\n");
 +              return true;
        }
  
        return false;
@@@ -2606,39 -2383,30 +2606,39 @@@ static s3
  wl_notify_connect_status(struct wl_priv *wl, struct net_device *ndev,
                         const wl_event_msg_t *e, void *data)
  {
        s32 err = 0;
  
        if (wl_is_linkup(wl, e)) {
 -              wl_link_up(wl);
 +              WL_CONN("Linkup\n");
                if (wl_is_ibssmode(wl)) {
 -                      cfg80211_ibss_joined(ndev, (s8 *)&e->addr,
 -                                           GFP_KERNEL);
 -                      WL_DBG("joined in IBSS network\n");
 -              } else {
 +                      wl_update_prof(wl, NULL, (void *)e->addr,
 +                              WL_PROF_BSSID);
 +                      wl_inform_ibss(wl, ndev, e->addr);
 +                      cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
 +                      clear_bit(WL_STATUS_CONNECTING, &wl->status);
 +                      set_bit(WL_STATUS_CONNECTED, &wl->status);
 +              } else
                        wl_bss_connect_done(wl, ndev, e, data, true);
 -                      WL_DBG("joined in BSS network \"%s\"\n",
 -                             ((struct wlc_ssid *)
 -                              wl_read_prof(wl, WL_PROF_SSID))->SSID);
 -              }
 -              act = true;
 -              wl_update_prof(wl, e, &act, WL_PROF_ACT);
        } else if (wl_is_linkdown(wl, e)) {
 -              cfg80211_disconnected(ndev, 0, NULL, 0, GFP_KERNEL);
 -              clear_bit(WL_STATUS_CONNECTED, &wl->status);
 -              wl_link_down(wl);
 +              WL_CONN("Linkdown\n");
 +              if (wl_is_ibssmode(wl)) {
 +                      if (test_and_clear_bit(WL_STATUS_CONNECTED,
 +                              &wl->status))
 +                              wl_link_down(wl);
 +              } else {
 +                      if (test_and_clear_bit(WL_STATUS_CONNECTED,
 +                              &wl->status)) {
 +                              cfg80211_disconnected(ndev, 0, NULL, 0,
 +                                      GFP_KERNEL);
 +                              wl_link_down(wl);
 +                      }
 +              }
                wl_init_prof(wl->profile);
        } else if (wl_is_nonetwork(wl, e)) {
 -              wl_bss_connect_done(wl, ndev, e, data, false);
 +              if (wl_is_ibssmode(wl))
 +                      clear_bit(WL_STATUS_CONNECTING, &wl->status);
 +              else
 +                      wl_bss_connect_done(wl, ndev, e, data, false);
        }
  
        return err;
@@@ -2648,16 -2416,12 +2648,16 @@@ static s3
  wl_notify_roaming_status(struct wl_priv *wl, struct net_device *ndev,
                         const wl_event_msg_t *e, void *data)
  {
 -      bool act;
        s32 err = 0;
 +      u32 event = be32_to_cpu(e->event_type);
 +      u32 status = be32_to_cpu(e->status);
  
 -      wl_bss_roaming_done(wl, ndev, e, data);
 -      act = true;
 -      wl_update_prof(wl, e, &act, WL_PROF_ACT);
 +      if (event == WLC_E_ROAM && status == WLC_E_STATUS_SUCCESS) {
 +              if (test_bit(WL_STATUS_CONNECTED, &wl->status))
 +                      wl_bss_roaming_done(wl, ndev, e, data);
 +              else
 +                      wl_bss_connect_done(wl, ndev, e, data, true);
 +      }
  
        return err;
  }
@@@ -2704,8 -2468,6 +2704,8 @@@ static s32 wl_get_assoc_ies(struct wl_p
        u32 resp_len;
        s32 err = 0;
  
 +      wl_clear_assoc_ies(wl);
 +
        err = wl_dev_bufvar_get(ndev, "assoc_info", wl->extra_buf,
                                WL_ASSOC_INFO_MAX);
        if (unlikely(err)) {
                conn_info->resp_ie_len = 0;
                conn_info->resp_ie = NULL;
        }
 -      WL_DBG("req len (%d) resp len (%d)\n",
 +      WL_CONN("req len (%d) resp len (%d)\n",
               conn_info->req_ie_len, conn_info->resp_ie_len);
  
        return err;
  }
  
 +static void wl_clear_assoc_ies(struct wl_priv *wl)
 +{
 +      struct wl_connect_info *conn_info = wl_to_conn(wl);
 +
 +      kfree(conn_info->req_ie);
 +      conn_info->req_ie = NULL;
 +      conn_info->req_ie_len = 0;
 +      kfree(conn_info->resp_ie);
 +      conn_info->resp_ie = NULL;
 +      conn_info->resp_ie_len = 0;
 +}
 +
 +
  static void wl_ch_to_chanspec(int ch, struct wl_join_params *join_params,
        size_t *join_params_size)
  {
                join_params->params.chanspec_num = 1;
                join_params->params.chanspec_list[0] = ch;
  
 -              if (join_params->params.chanspec_list[0])
 +              if (join_params->params.chanspec_list[0] <= CH_MAX_2G_CHANNEL)
                        chanspec |= WL_CHANSPEC_BAND_2G;
                else
                        chanspec |= WL_CHANSPEC_BAND_5G;
                join_params->params.chanspec_num =
                        cpu_to_le32(join_params->params.chanspec_num);
  
 -              WL_DBG("join_params->params.chanspec_list[0]= %#X, channel %d, chanspec %#X\n",
 +              WL_CONN("join_params->params.chanspec_list[0]= %#X,"
 +                      "channel %d, chanspec %#X\n",
                       join_params->params.chanspec_list[0], ch, chanspec);
        }
  }
  
  static s32 wl_update_bss_info(struct wl_priv *wl)
  {
 -      struct cfg80211_bss *bss;
        struct wl_bss_info *bi;
        struct wlc_ssid *ssid;
        struct bcm_tlv *tim;
        u8 *ie;
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
        if (wl_is_ibssmode(wl))
                return err;
  
        ssid = (struct wlc_ssid *)wl_read_prof(wl, WL_PROF_SSID);
 -      bss =
 -          cfg80211_get_bss(wl_to_wiphy(wl), NULL, (s8 *)&wl->bssid,
 -                           ssid->SSID, ssid->SSID_len, WLAN_CAPABILITY_ESS,
 -                           WLAN_CAPABILITY_ESS);
 -
 -      rtnl_lock();
 -      if (unlikely(!bss)) {
 -              WL_DBG("Could not find the AP\n");
 -              *(u32 *) wl->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
 -              err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_BSS_INFO,
 -                              wl->extra_buf, WL_EXTRA_BUF_MAX);
 -              if (unlikely(err)) {
 -                      WL_ERR("Could not get bss info %d\n", err);
 -                      goto update_bss_info_out;
 -              }
 -              bi = (struct wl_bss_info *)(wl->extra_buf + 4);
 -              if (unlikely(memcmp(&bi->BSSID, &wl->bssid, ETH_ALEN))) {
 -                      err = -EIO;
 -                      goto update_bss_info_out;
 -              }
 -              err = wl_inform_single_bss(wl, bi);
 -              if (unlikely(err))
 -                      goto update_bss_info_out;
  
 -              ie = ((u8 *)bi) + bi->ie_offset;
 -              ie_len = bi->ie_length;
 -              beacon_interval = cpu_to_le16(bi->beacon_period);
 -      } else {
 -              WL_DBG("Found the AP in the list - BSSID %pM\n", bss->bssid);
 -              ie = bss->information_elements;
 -              ie_len = bss->len_information_elements;
 -              beacon_interval = bss->beacon_interval;
 -              cfg80211_put_bss(bss);
 +      *(u32 *)wl->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
 +      err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_BSS_INFO,
 +                      wl->extra_buf, WL_EXTRA_BUF_MAX);
 +      if (unlikely(err)) {
 +              WL_ERR("Could not get bss info %d\n", err);
 +              goto update_bss_info_out;
        }
  
 +      bi = (struct wl_bss_info *)(wl->extra_buf + 4);
 +      err = wl_inform_single_bss(wl, bi);
 +      if (unlikely(err))
 +              goto update_bss_info_out;
 +
 +      ie = ((u8 *)bi) + bi->ie_offset;
 +      ie_len = bi->ie_length;
 +      beacon_interval = cpu_to_le16(bi->beacon_period);
 +
        tim = bcm_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
 -      if (tim) {
 +      if (tim)
                dtim_period = tim->data[1];
 -      } else {
 +      else {
                /*
                * active scan was done so we could not get dtim
                * information out of probe response.
                * so we speficially query dtim information to dongle.
                */
 -              err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_DTIMPRD,
 -                      &dtim_period, sizeof(dtim_period));
 +              u32 var;
 +              err = wl_dev_intvar_get(wl_to_ndev(wl), "dtim_assoc", &var);
                if (unlikely(err)) {
 -                      WL_ERR("WLC_GET_DTIMPRD error (%d)\n", err);
 +                      WL_ERR("wl dtim_assoc failed (%d)\n", err);
                        goto update_bss_info_out;
                }
 +              dtim_period = (u8)var;
        }
  
        wl_update_prof(wl, NULL, &beacon_interval, WL_PROF_BEACONINT);
        wl_update_prof(wl, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
  
  update_bss_info_out:
 -      rtnl_unlock();
 +      WL_TRACE("Exit");
        return err;
  }
  
@@@ -2863,20 -2627,17 +2863,20 @@@ wl_bss_roaming_done(struct wl_priv *wl
        struct wl_connect_info *conn_info = wl_to_conn(wl);
        s32 err = 0;
  
 +      WL_TRACE("Enter\n");
 +
        wl_get_assoc_ies(wl);
 -      memcpy(&wl->bssid, &e->addr, ETH_ALEN);
 +      wl_update_prof(wl, NULL, &e->addr, WL_PROF_BSSID);
        wl_update_bss_info(wl);
 +
-       cfg80211_roamed(ndev,
+       cfg80211_roamed(ndev, NULL,
 -                      (u8 *)&wl->bssid,
 +                      (u8 *)wl_read_prof(wl, WL_PROF_BSSID),
                        conn_info->req_ie, conn_info->req_ie_len,
                        conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
 -      WL_DBG("Report roaming result\n");
 +      WL_CONN("Report roaming result\n");
  
        set_bit(WL_STATUS_CONNECTED, &wl->status);
 -
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -2887,28 -2648,30 +2887,28 @@@ wl_bss_connect_done(struct wl_priv *wl
        struct wl_connect_info *conn_info = wl_to_conn(wl);
        s32 err = 0;
  
 -      wl_get_assoc_ies(wl);
 -      memcpy(&wl->bssid, &e->addr, ETH_ALEN);
 -      wl_update_bss_info(wl);
 +      WL_TRACE("Enter\n");
 +
        if (test_and_clear_bit(WL_STATUS_CONNECTING, &wl->status)) {
 +              if (completed) {
 +                      wl_get_assoc_ies(wl);
 +                      wl_update_prof(wl, NULL, &e->addr, WL_PROF_BSSID);
 +                      wl_update_bss_info(wl);
 +              }
                cfg80211_connect_result(ndev,
 -                                      (u8 *)&wl->bssid,
 +                                      (u8 *)wl_read_prof(wl, WL_PROF_BSSID),
                                        conn_info->req_ie,
                                        conn_info->req_ie_len,
                                        conn_info->resp_ie,
                                        conn_info->resp_ie_len,
                                        completed ? WLAN_STATUS_SUCCESS : WLAN_STATUS_AUTH_TIMEOUT,
                                        GFP_KERNEL);
 -              WL_DBG("Report connect result - connection %s\n",
 -                     completed ? "succeeded" : "failed");
 -      } else {
 -              cfg80211_roamed(ndev, NULL,
 -                              (u8 *)&wl->bssid,
 -                              conn_info->req_ie, conn_info->req_ie_len,
 -                              conn_info->resp_ie, conn_info->resp_ie_len,
 -                              GFP_KERNEL);
 -              WL_DBG("Report roaming result\n");
 +              if (completed)
 +                      set_bit(WL_STATUS_CONNECTED, &wl->status);
 +              WL_CONN("Report connect result - connection %s\n",
 +                              completed ? "succeeded" : "failed");
        }
 -      set_bit(WL_STATUS_CONNECTED, &wl->status);
 -
 +      WL_TRACE("Exit\n");
        return err;
  }
  
@@@ -2940,45 -2703,37 +2940,45 @@@ wl_notify_scan_status(struct wl_priv *w
        struct wl_scan_results *bss_list;
        u32 len = WL_SCAN_BUF_MAX;
        s32 err = 0;
 +      bool scan_abort = false;
 +
 +      WL_TRACE("Enter\n");
  
 -      if (wl->iscan_on && wl->iscan_kickstart)
 +      if (wl->iscan_on && wl->iscan_kickstart) {
 +              WL_TRACE("Exit\n");
                return wl_wakeup_iscan(wl_to_iscan(wl));
 +      }
  
        if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
                WL_ERR("Scan complete while device not scanning\n");
 -              return -EINVAL;
 -      }
 -      if (unlikely(!wl->scan_request)) {
 +              scan_abort = true;
 +              err = -EINVAL;
 +              goto scan_done_out;
        }
 -      rtnl_lock();
 +
        err = wl_dev_ioctl(ndev, WLC_GET_CHANNEL, &channel_inform,
                        sizeof(channel_inform));
        if (unlikely(err)) {
                WL_ERR("scan busy (%d)\n", err);
 +              scan_abort = true;
                goto scan_done_out;
        }
        channel_inform.scan_channel = le32_to_cpu(channel_inform.scan_channel);
        if (unlikely(channel_inform.scan_channel)) {
  
 -              WL_DBG("channel_inform.scan_channel (%d)\n",
 +              WL_CONN("channel_inform.scan_channel (%d)\n",
                       channel_inform.scan_channel);
        }
        wl->bss_list = wl->scan_results;
        bss_list = wl->bss_list;
        memset(bss_list, 0, len);
        bss_list->buflen = cpu_to_le32(len);
 +
        err = wl_dev_ioctl(ndev, WLC_SCAN_RESULTS, bss_list, len);
        if (unlikely(err)) {
                WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
                err = -EINVAL;
 +              scan_abort = true;
                goto scan_done_out;
        }
        bss_list->buflen = le32_to_cpu(bss_list->buflen);
        bss_list->count = le32_to_cpu(bss_list->count);
  
        err = wl_inform_bss(wl);
 -      if (err)
 +      if (err) {
 +              scan_abort = true;
                goto scan_done_out;
 +      }
  
  scan_done_out:
        if (wl->scan_request) {
 -              cfg80211_scan_done(wl->scan_request, false);
 +              WL_SCAN("calling cfg80211_scan_done\n");
 +              cfg80211_scan_done(wl->scan_request, scan_abort);
                wl_set_mpc(ndev, 1);
                wl->scan_request = NULL;
        }
 -      rtnl_unlock();
 +
 +      WL_TRACE("Exit\n");
 +
        return err;
  }
  
@@@ -3023,7 -2773,12 +3023,7 @@@ static void wl_init_eloop_handler(struc
  {
        memset(el, 0, sizeof(*el));
        el->handler[WLC_E_SCAN_COMPLETE] = wl_notify_scan_status;
 -      el->handler[WLC_E_JOIN] = wl_notify_connect_status;
        el->handler[WLC_E_LINK] = wl_notify_connect_status;
 -      el->handler[WLC_E_DEAUTH_IND] = wl_notify_connect_status;
 -      el->handler[WLC_E_DISASSOC_IND] = wl_notify_connect_status;
 -      el->handler[WLC_E_ASSOC_IND] = wl_notify_connect_status;
 -      el->handler[WLC_E_REASSOC_IND] = wl_notify_connect_status;
        el->handler[WLC_E_ROAM] = wl_notify_roaming_status;
        el->handler[WLC_E_MIC_ERROR] = wl_notify_mic_status;
        el->handler[WLC_E_SET_SSID] = wl_notify_connect_status;
@@@ -3157,8 -2912,6 +3157,8 @@@ static void wl_notify_iscan_complete(st
                return;
        }
        if (likely(wl->scan_request)) {
 +              WL_SCAN("ISCAN Completed scan: %s\n",
 +                              aborted ? "Aborted" : "Done");
                cfg80211_scan_done(wl->scan_request, aborted);
                wl_set_mpc(ndev, 1);
                wl->scan_request = NULL;
  static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan)
  {
        if (likely(iscan->state != WL_ISCAN_STATE_IDLE)) {
 -              WL_DBG("wake up iscan\n");
 +              WL_SCAN("wake up iscan\n");
                up(&iscan->sync);
                return 0;
        }
@@@ -3205,8 -2958,8 +3205,8 @@@ wl_get_iscan_results(struct wl_iscan_ct
        results->buflen = le32_to_cpu(results->buflen);
        results->version = le32_to_cpu(results->version);
        results->count = le32_to_cpu(results->count);
 -      WL_DBG("results->count = %d\n", results->count);
 -      WL_DBG("results->buflen = %d\n", results->buflen);
 +      WL_SCAN("results->count = %d\n", results->count);
 +      WL_SCAN("results->buflen = %d\n", results->buflen);
        *status = le32_to_cpu(list_buf->status);
        *bss_list = results;
  
@@@ -3300,7 -3053,7 +3300,7 @@@ static s32 wl_iscan_thread(void *data
                del_timer_sync(&iscan->timer);
                iscan->timer_on = 0;
        }
 -      WL_DBG("%s was terminated\n", __func__);
 +      WL_SCAN("ISCAN thread terminated\n");
  
        return 0;
  }
@@@ -3311,7 -3064,7 +3311,7 @@@ static void wl_iscan_timer(unsigned lon
  
        if (iscan) {
                iscan->timer_on = 0;
 -              WL_DBG("timer expired\n");
 +              WL_SCAN("timer expired\n");
                wl_wakeup_iscan(iscan);
        }
  }
@@@ -3438,7 -3191,7 +3438,7 @@@ s32 wl_cfg80211_attach(struct net_devic
                WL_ERR("wl_cfg80211_dev is invalid\n");
                return -ENOMEM;
        }
 -      WL_DBG("func %p\n", wl_cfg80211_get_sdio_func());
 +      WL_INFO("func %p\n", wl_cfg80211_get_sdio_func());
        wdev = wl_alloc_wdev(sizeof(struct wl_iface), &wl_cfg80211_get_sdio_func()->dev);
        if (IS_ERR(wdev))
                return -ENOMEM;
                goto cfg80211_attach_out;
        }
        wl_set_drvdata(wl_cfg80211_dev, ci);
 -      set_bit(WL_STATUS_READY, &wl->status);
  
        return err;
  
@@@ -3501,16 -3255,16 +3501,16 @@@ static s32 wl_event_handler(void *data
                        WL_ERR("event queue empty...\n");
                        BUG();
                }
 -              WL_DBG("event type (%d)\n", e->etype);
 +              WL_INFO("event type (%d)\n", e->etype);
                if (wl->el.handler[e->etype]) {
                        wl->el.handler[e->etype] (wl, wl_to_ndev(wl), &e->emsg,
                                                  e->edata);
                } else {
 -                      WL_DBG("Unknown Event (%d): ignoring\n", e->etype);
 +                      WL_INFO("Unknown Event (%d): ignoring\n", e->etype);
                }
                wl_put_event(e);
        }
 -      WL_DBG("%s was terminated\n", __func__);
 +      WL_INFO("was terminated\n");
        return 0;
  }
  
@@@ -3519,7 -3273,11 +3519,7 @@@ wl_cfg80211_event(struct net_device *nd
  {
        u32 event_type = be32_to_cpu(e->event_type);
        struct wl_priv *wl = ndev_to_wl(ndev);
 -#if (WL_DBG_LEVEL > 0)
 -      s8 *estr = (event_type <= sizeof(wl_dbg_estr) / WL_DBG_ESTR_MAX - 1) ?
 -          wl_dbg_estr[event_type] : (s8 *) "Unknown";
 -#endif                                /* (WL_DBG_LEVEL > 0) */
 -      WL_DBG("event_type (%d):" "WLC_E_" "%s\n", event_type, estr);
 +
        if (likely(!wl_enq_event(wl, event_type, e, data)))
                wl_wakeup_event(wl);
  }
@@@ -3612,6 -3370,7 +3612,6 @@@ struct sdio_func *wl_cfg80211_get_sdio_
  static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype)
  {
        s32 infra = 0;
 -      s32 ap = 0;
        s32 err = 0;
  
        switch (iftype) {
                err = -EINVAL;
                return err;
        case NL80211_IFTYPE_ADHOC:
 +              infra = 0;
                break;
        case NL80211_IFTYPE_STATION:
                infra = 1;
                return err;
        }
        infra = cpu_to_le32(infra);
 -      ap = cpu_to_le32(ap);
 -      WL_DBG("%s ap (%d), infra (%d)\n", ndev->name, ap, infra);
        err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
        if (unlikely(err)) {
                WL_ERR("WLC_SET_INFRA error (%d)\n", err);
                return err;
        }
 -      err = wl_dev_ioctl(ndev, WLC_SET_AP, &ap, sizeof(ap));
 -      if (unlikely(err)) {
 -              WL_ERR("WLC_SET_AP error (%d)\n", err);
 -              return err;
 -      }
  
 -      return -EINPROGRESS;
 +      return 0;
  }
  
  #ifndef EMBEDDED_PLATFORM
@@@ -3700,6 -3465,116 +3700,6 @@@ dongle_glom_out
  }
  
  static s32
 -wl_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
 -{
 -      s8 iovbuf[WL_EVENTING_MASK_LEN + 12];   /*  Room for "event_msgs" +
 -                                               '\0' + bitvec  */
 -      s32 err = 0;
 -
 -      /* Setup timeout if Beacons are lost and roam is
 -               off to report link down */
 -      if (roamvar) {
 -              bcm_mkiovar("bcn_timeout", (char *)&bcn_timeout, 4, iovbuf,
 -                          sizeof(iovbuf));
 -              err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
 -              if (unlikely(err)) {
 -                      WL_ERR("bcn_timeout error (%d)\n", err);
 -                      goto dongle_rom_out;
 -              }
 -      }
 -      /* Enable/Disable built-in roaming to allow supplicant
 -               to take care of roaming */
 -      bcm_mkiovar("roam_off", (char *)&roamvar, 4, iovbuf, sizeof(iovbuf));
 -      err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
 -      if (unlikely(err)) {
 -              WL_ERR("roam_off error (%d)\n", err);
 -              goto dongle_rom_out;
 -      }
 -dongle_rom_out:
 -      return err;
 -}
 -
 -static s32 wl_dongle_eventmsg(struct net_device *ndev)
 -{
 -
 -      s8 iovbuf[WL_EVENTING_MASK_LEN + 12];   /*  Room for "event_msgs" +
 -                                               '\0' + bitvec  */
 -      s8 eventmask[WL_EVENTING_MASK_LEN];
 -      s32 err = 0;
 -
 -      /* Setup event_msgs */
 -      bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
 -                  sizeof(iovbuf));
 -      err = wl_dev_ioctl(ndev, WLC_GET_VAR, iovbuf, sizeof(iovbuf));
 -      if (unlikely(err)) {
 -              WL_ERR("Get event_msgs error (%d)\n", err);
 -              goto dongle_eventmsg_out;
 -      }
 -      memcpy(eventmask, iovbuf, WL_EVENTING_MASK_LEN);
 -
 -      setbit(eventmask, WLC_E_SET_SSID);
 -      setbit(eventmask, WLC_E_PRUNE);
 -      setbit(eventmask, WLC_E_AUTH);
 -      setbit(eventmask, WLC_E_REASSOC);
 -      setbit(eventmask, WLC_E_REASSOC_IND);
 -      setbit(eventmask, WLC_E_DEAUTH_IND);
 -      setbit(eventmask, WLC_E_DISASSOC_IND);
 -      setbit(eventmask, WLC_E_DISASSOC);
 -      setbit(eventmask, WLC_E_JOIN);
 -      setbit(eventmask, WLC_E_ASSOC_IND);
 -      setbit(eventmask, WLC_E_PSK_SUP);
 -      setbit(eventmask, WLC_E_LINK);
 -      setbit(eventmask, WLC_E_NDIS_LINK);
 -      setbit(eventmask, WLC_E_MIC_ERROR);
 -      setbit(eventmask, WLC_E_PMKID_CACHE);
 -      setbit(eventmask, WLC_E_TXFAIL);
 -      setbit(eventmask, WLC_E_JOIN_START);
 -      setbit(eventmask, WLC_E_SCAN_COMPLETE);
 -
 -      bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
 -                  sizeof(iovbuf));
 -      err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
 -      if (unlikely(err)) {
 -              WL_ERR("Set event_msgs error (%d)\n", err);
 -              goto dongle_eventmsg_out;
 -      }
 -
 -dongle_eventmsg_out:
 -      return err;
 -}
 -
 -static s32
 -wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
 -                 s32 scan_unassoc_time)
 -{
 -      s32 err = 0;
 -
 -      err = wl_dev_ioctl(ndev, WLC_SET_SCAN_CHANNEL_TIME, &scan_assoc_time,
 -                      sizeof(scan_assoc_time));
 -      if (err) {
 -              if (err == -EOPNOTSUPP) {
 -                      WL_INFO("Scan assoc time is not supported\n");
 -              } else {
 -                      WL_ERR("Scan assoc time error (%d)\n", err);
 -              }
 -              goto dongle_scantime_out;
 -      }
 -      err = wl_dev_ioctl(ndev, WLC_SET_SCAN_UNASSOC_TIME, &scan_unassoc_time,
 -                      sizeof(scan_unassoc_time));
 -      if (err) {
 -              if (err == -EOPNOTSUPP) {
 -                      WL_INFO("Scan unassoc time is not supported\n");
 -              } else {
 -                      WL_ERR("Scan unassoc time error (%d)\n", err);
 -              }
 -              goto dongle_scantime_out;
 -      }
 -
 -dongle_scantime_out:
 -      return err;
 -}
 -
 -static s32
  wl_dongle_offload(struct net_device *ndev, s32 arpoe, s32 arp_ol)
  {
        s8 iovbuf[WL_EVENTING_MASK_LEN + 12];   /*  Room for "event_msgs" +
@@@ -3847,154 -3722,6 +3847,154 @@@ dongle_filter_out
  }
  #endif                                /* !EMBEDDED_PLATFORM */
  
 +static s32 wl_dongle_eventmsg(struct net_device *ndev)
 +{
 +      s8 iovbuf[WL_EVENTING_MASK_LEN + 12];   /*  Room for "event_msgs" +
 +                                               '\0' + bitvec  */
 +      s8 eventmask[WL_EVENTING_MASK_LEN];
 +      s32 err = 0;
 +
 +      WL_TRACE("Enter\n");
 +
 +      /* Setup event_msgs */
 +      bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
 +                  sizeof(iovbuf));
 +      err = wl_dev_ioctl(ndev, WLC_GET_VAR, iovbuf, sizeof(iovbuf));
 +      if (unlikely(err)) {
 +              WL_ERR("Get event_msgs error (%d)\n", err);
 +              goto dongle_eventmsg_out;
 +      }
 +      memcpy(eventmask, iovbuf, WL_EVENTING_MASK_LEN);
 +
 +      setbit(eventmask, WLC_E_SET_SSID);
 +      setbit(eventmask, WLC_E_ROAM);
 +      setbit(eventmask, WLC_E_PRUNE);
 +      setbit(eventmask, WLC_E_AUTH);
 +      setbit(eventmask, WLC_E_REASSOC);
 +      setbit(eventmask, WLC_E_REASSOC_IND);
 +      setbit(eventmask, WLC_E_DEAUTH_IND);
 +      setbit(eventmask, WLC_E_DISASSOC_IND);
 +      setbit(eventmask, WLC_E_DISASSOC);
 +      setbit(eventmask, WLC_E_JOIN);
 +      setbit(eventmask, WLC_E_ASSOC_IND);
 +      setbit(eventmask, WLC_E_PSK_SUP);
 +      setbit(eventmask, WLC_E_LINK);
 +      setbit(eventmask, WLC_E_NDIS_LINK);
 +      setbit(eventmask, WLC_E_MIC_ERROR);
 +      setbit(eventmask, WLC_E_PMKID_CACHE);
 +      setbit(eventmask, WLC_E_TXFAIL);
 +      setbit(eventmask, WLC_E_JOIN_START);
 +      setbit(eventmask, WLC_E_SCAN_COMPLETE);
 +
 +      bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
 +                  sizeof(iovbuf));
 +      err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
 +      if (unlikely(err)) {
 +              WL_ERR("Set event_msgs error (%d)\n", err);
 +              goto dongle_eventmsg_out;
 +      }
 +
 +dongle_eventmsg_out:
 +      WL_TRACE("Exit\n");
 +      return err;
 +}
 +
 +static s32
 +wl_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
 +{
 +      s8 iovbuf[32];
 +      s32 roamtrigger[2];
 +      s32 roam_delta[2];
 +      s32 err = 0;
 +
 +      /*
 +       * Setup timeout if Beacons are lost and roam is
 +       * off to report link down
 +       */
 +      if (roamvar) {
 +              bcm_mkiovar("bcn_timeout", (char *)&bcn_timeout,
 +                      sizeof(bcn_timeout), iovbuf, sizeof(iovbuf));
 +              err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
 +              if (unlikely(err)) {
 +                      WL_ERR("bcn_timeout error (%d)\n", err);
 +                      goto dongle_rom_out;
 +              }
 +      }
 +
 +      /*
 +       * Enable/Disable built-in roaming to allow supplicant
 +       * to take care of roaming
 +       */
 +      WL_INFO("Internal Roaming = %s\n", roamvar ? "Off" : "On");
 +      bcm_mkiovar("roam_off", (char *)&roamvar,
 +                              sizeof(roamvar), iovbuf, sizeof(iovbuf));
 +      err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
 +      if (unlikely(err)) {
 +              WL_ERR("roam_off error (%d)\n", err);
 +              goto dongle_rom_out;
 +      }
 +
 +      roamtrigger[0] = WL_ROAM_TRIGGER_LEVEL;
 +      roamtrigger[1] = WLC_BAND_ALL;
 +      err = wl_dev_ioctl(ndev, WLC_SET_ROAM_TRIGGER,
 +                      (void *)roamtrigger, sizeof(roamtrigger));
 +      if (unlikely(err)) {
 +              WL_ERR("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
 +              goto dongle_rom_out;
 +      }
 +
 +      roam_delta[0] = WL_ROAM_DELTA;
 +      roam_delta[1] = WLC_BAND_ALL;
 +      err = wl_dev_ioctl(ndev, WLC_SET_ROAM_DELTA,
 +                              (void *)roam_delta, sizeof(roam_delta));
 +      if (unlikely(err)) {
 +              WL_ERR("WLC_SET_ROAM_DELTA error (%d)\n", err);
 +              goto dongle_rom_out;
 +      }
 +
 +dongle_rom_out:
 +      return err;
 +}
 +
 +static s32
 +wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
 +              s32 scan_unassoc_time, s32 scan_passive_time)
 +{
 +      s32 err = 0;
 +
 +      err = wl_dev_ioctl(ndev, WLC_SET_SCAN_CHANNEL_TIME, &scan_assoc_time,
 +                      sizeof(scan_assoc_time));
 +      if (err) {
 +              if (err == -EOPNOTSUPP)
 +                      WL_INFO("Scan assoc time is not supported\n");
 +              else
 +                      WL_ERR("Scan assoc time error (%d)\n", err);
 +              goto dongle_scantime_out;
 +      }
 +      err = wl_dev_ioctl(ndev, WLC_SET_SCAN_UNASSOC_TIME, &scan_unassoc_time,
 +                      sizeof(scan_unassoc_time));
 +      if (err) {
 +              if (err == -EOPNOTSUPP)
 +                      WL_INFO("Scan unassoc time is not supported\n");
 +              else
 +                      WL_ERR("Scan unassoc time error (%d)\n", err);
 +              goto dongle_scantime_out;
 +      }
 +
 +      err = wl_dev_ioctl(ndev, WLC_SET_SCAN_PASSIVE_TIME, &scan_passive_time,
 +                      sizeof(scan_passive_time));
 +      if (err) {
 +              if (err == -EOPNOTSUPP)
 +                      WL_INFO("Scan passive time is not supported\n");
 +              else
 +                      WL_ERR("Scan passive time error (%d)\n", err);
 +              goto dongle_scantime_out;
 +      }
 +
 +dongle_scantime_out:
 +      return err;
 +}
 +
  s32 wl_config_dongle(struct wl_priv *wl, bool need_lock)
  {
  #ifndef DHD_SDALIGN
        err = wl_dongle_glom(ndev, 0, DHD_SDALIGN);
        if (unlikely(err))
                goto default_conf_out;
 -      err = wl_dongle_roam(ndev, (wl->roam_on ? 0 : 1), 3);
 -      if (unlikely(err))
 -              goto default_conf_out;
 -      err = wl_dongle_eventmsg(ndev);
 -      if (unlikely(err))
 -              goto default_conf_out;
  
 -      wl_dongle_scantime(ndev, 40, 80);
        wl_dongle_offload(ndev, 1, 0xf);
        wl_dongle_filter(ndev, 1);
 -#endif                                /* !EMBEDDED_PLATFORM */
 +#endif /* !EMBEDDED_PLATFORM */
  
 +      wl_dongle_scantime(ndev, WL_SCAN_CHANNEL_TIME,
 +                      WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
 +
 +      err = wl_dongle_eventmsg(ndev);
 +      if (unlikely(err))
 +              goto default_conf_out;
 +      err = wl_dongle_roam(ndev, (wl->roam_on ? 0 : 1), WL_BEACON_TIMEOUT);
 +      if (unlikely(err))
 +              goto default_conf_out;
        err = wl_dongle_mode(ndev, wdev->iftype);
        if (unlikely(err && err != -EINPROGRESS))
                goto default_conf_out;
@@@ -4073,7 -3798,7 +4073,7 @@@ static s32 wl_update_wiphybands(struct 
        }
  
        phy = ((char *)&phy_list)[1];
 -      WL_DBG("%c phy\n", phy);
 +      WL_INFO("%c phy\n", phy);
        if (phy == 'n' || phy == 'a') {
                wiphy = wl_to_wiphy(wl);
                wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
@@@ -4086,8 -3811,6 +4086,8 @@@ static s32 __wl_cfg80211_up(struct wl_p
  {
        s32 err = 0;
  
 +      set_bit(WL_STATUS_READY, &wl->status);
 +
        wl_debugfs_add_netdev_params(wl);
  
        err = wl_config_dongle(wl, false);
                return err;
  
        wl_invoke_iscan(wl);
 -      set_bit(WL_STATUS_READY, &wl->status);
 +
        return err;
  }
  
  static s32 __wl_cfg80211_down(struct wl_priv *wl)
  {
        set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
        wl_term_iscan(wl);
        if (wl->scan_request) {
 -              cfg80211_scan_done(wl->scan_request, true);     /* true
 -                                                               means abort */
 -              /* wl_set_mpc(wl_to_ndev(wl), 1); */    /* BUG
 -                                              * this operation cannot help
 -                                              * but here because sdio
 -                                              * is already down through
 -                                              * rmmod process.
 -                                              * Need to figure out how to
 -                                              * address this issue
 -                                              */
 +              cfg80211_scan_done(wl->scan_request, true);
 +              /* May need to perform this to cover rmmod */
 +              /* wl_set_mpc(wl_to_ndev(wl), 1); */
                wl->scan_request = NULL;
        }
        clear_bit(WL_STATUS_READY, &wl->status);
        clear_bit(WL_STATUS_SCANNING, &wl->status);
        clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
 +      clear_bit(WL_STATUS_CONNECTING, &wl->status);
        clear_bit(WL_STATUS_CONNECTED, &wl->status);
  
        wl_debugfs_remove_netdev(wl);
  
 -      return err;
 +      return 0;
  }
  
  s32 wl_cfg80211_up(void)
@@@ -4162,6 -3897,8 +4162,6 @@@ static void *wl_read_prof(struct wl_pri
        switch (item) {
        case WL_PROF_SEC:
                return &wl->profile->sec;
 -      case WL_PROF_ACT:
 -              return &wl->profile->active;
        case WL_PROF_BSSID:
                return &wl->profile->bssid;
        case WL_PROF_SSID:
@@@ -4195,6 -3932,9 +4195,6 @@@ wl_update_prof(struct wl_priv *wl, cons
        case WL_PROF_SEC:
                memcpy(&wl->profile->sec, data, sizeof(wl->profile->sec));
                break;
 -      case WL_PROF_ACT:
 -              wl->profile->active = *(bool *)data;
 -              break;
        case WL_PROF_BEACONINT:
                wl->profile->beacon_interval = *(u16 *)data;
                break;
        return err;
  }
  
 -void wl_cfg80211_dbg_level(u32 level)
 -{
 -      /*
 -      * prohibit to change debug level
 -      * by insmod parameter.
 -      * eventually debug level will be configured
 -      * in compile time by using CONFIG_XXX
 -      */
 -      /* wl_dbg_level = level; */
 -}
 -
  static bool wl_is_ibssmode(struct wl_priv *wl)
  {
        return wl->conf->mode == WL_MODE_IBSS;
  }
  
 -static bool wl_is_ibssstarter(struct wl_priv *wl)
 -{
 -      return wl->ibss_starter;
 -}
 -
 -static void wl_rst_ie(struct wl_priv *wl)
 -{
 -      struct wl_ie *ie = wl_to_ie(wl);
 -
 -      ie->offset = 0;
 -}
 -
  static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v)
  {
        struct wl_ie *ie = wl_to_ie(wl);
        return err;
  }
  
 -static s32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, u16 ie_size)
 -{
 -      struct wl_ie *ie = wl_to_ie(wl);
 -      s32 err = 0;
 -
 -      if (unlikely(ie->offset + ie_size > WL_TLV_INFO_MAX)) {
 -              WL_ERR("ei_stream crosses buffer boundary\n");
 -              return -ENOSPC;
 -      }
 -      memcpy(&ie->buf[ie->offset], ie_stream, ie_size);
 -      ie->offset += ie_size;
  
 -      return err;
 -}
 -
 -static s32 wl_cp_ie(struct wl_priv *wl, u8 *dst, u16 dst_size)
 +static void wl_link_down(struct wl_priv *wl)
  {
 -      struct wl_ie *ie = wl_to_ie(wl);
 +      struct net_device *dev = NULL;
        s32 err = 0;
  
 -      if (unlikely(ie->offset > dst_size)) {
 -              WL_ERR("dst_size is not enough\n");
 -              return -ENOSPC;
 -      }
 -      memcpy(dst, &ie->buf[0], ie->offset);
 -
 -      return err;
 -}
 -
 -static u32 wl_get_ielen(struct wl_priv *wl)
 -{
 -      struct wl_ie *ie = wl_to_ie(wl);
 -
 -      return ie->offset;
 -}
 -
 -static void wl_link_up(struct wl_priv *wl)
 -{
 -      wl->link_up = true;
 -}
 -
 -static void wl_link_down(struct wl_priv *wl)
 -{
 -      struct wl_connect_info *conn_info = wl_to_conn(wl);
 +      WL_TRACE("Enter\n");
 +      clear_bit(WL_STATUS_CONNECTED, &wl->status);
  
 -      wl->link_up = false;
 -      kfree(conn_info->req_ie);
 -      conn_info->req_ie = NULL;
 -      conn_info->req_ie_len = 0;
 -      kfree(conn_info->resp_ie);
 -      conn_info->resp_ie = NULL;
 -      conn_info->resp_ie_len = 0;
 +      if (wl->link_up) {
 +              dev = wl_to_ndev(wl);
 +              WL_INFO("Call WLC_DISASSOC to stop excess roaming\n ");
 +              err = wl_dev_ioctl(dev, WLC_DISASSOC, NULL, 0);
 +              if (unlikely(err))
 +                      WL_ERR("WLC_DISASSOC failed (%d)\n", err);
 +              wl->link_up = false;
 +      }
 +      WL_TRACE("Exit\n");
  }
  
  static void wl_lock_eq(struct wl_priv *wl)
@@@ -4319,7 -4116,7 +4319,7 @@@ void *wl_cfg80211_request_fw(s8 *file_n
        const struct firmware *fw_entry = NULL;
        s32 err = 0;
  
 -      WL_DBG("file name : \"%s\"\n", file_name);
 +      WL_INFO("file name : \"%s\"\n", file_name);
        wl = WL_PRIV_GET();
  
        if (!test_bit(WL_FW_LOADING_DONE, &wl->fw->status)) {
                set_bit(WL_FW_LOADING_DONE, &wl->fw->status);
                fw_entry = wl->fw->fw_entry;
                if (fw_entry) {
 -                      WL_DBG("fw size (%zd), data (%p)\n",
 +                      WL_INFO("fw size (%zd), data (%p)\n",
                               fw_entry->size, fw_entry->data);
                }
        } else if (!test_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status)) {
                set_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status);
                fw_entry = wl->fw->fw_entry;
                if (fw_entry) {
 -                      WL_DBG("nvram size (%zd), data (%p)\n",
 +                      WL_INFO("nvram size (%zd), data (%p)\n",
                               fw_entry->size, fw_entry->data);
                }
        } else {
 -              WL_DBG("Downloading already done. Nothing to do more\n");
 +              WL_INFO("Downloading already done. Nothing to do more\n");
                err = -EPERM;
        }
  
@@@ -4382,16 -4179,13 +4382,16 @@@ s8 *wl_cfg80211_get_nvramname(void
  static void wl_set_mpc(struct net_device *ndev, int mpc)
  {
        s32 err = 0;
 +      struct wl_priv *wl = ndev_to_wl(ndev);
  
 -      err = wl_dev_intvar_set(ndev, "mpc", mpc);
 -      if (unlikely(err)) {
 -              WL_ERR("fail to set mpc\n");
 -              return;
 +      if (test_bit(WL_STATUS_READY, &wl->status)) {
 +              err = wl_dev_intvar_set(ndev, "mpc", mpc);
 +              if (unlikely(err)) {
 +                      WL_ERR("fail to set mpc\n");
 +                      return;
 +              }
 +              WL_INFO("MPC : %d\n", mpc);
        }
 -      WL_DBG("MPC : %d\n", mpc);
  }
  
  static int wl_debugfs_add_netdev_params(struct wl_priv *wl)