drivers/staging/brcm80211/brcmfmac/wl_cfg80211.c

   1 /*
   2  * Copyright (c) 2010 Broadcom Corporation
   3  *
   4  * Permission to use, copy, modify, and/or distribute this software for any
   5  * purpose with or without fee is hereby granted, provided that the above
   6  * copyright notice and this permission notice appear in all copies.
   7  *
   8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
   9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
  11  * SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION
  13  * OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
  14  * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  15  */
  16
  17 #include <linux/kernel.h>
  18 #include <linux/if_arp.h>
  19 #include <linux/sched.h>
  20 #include <linux/kthread.h>
  21 #include <linux/netdevice.h>
  22 #include <linux/sched.h>
  23 #include <linux/etherdevice.h>
  24 #include <linux/ieee80211.h>
  25 #include <linux/mmc/sdio_func.h>
  26 #include <linux/uaccess.h>
  27 #include <net/cfg80211.h>
  28 #include <net/rtnetlink.h>
  29
  30 #include <brcmu_utils.h>
  31 #include <defs.h>
  32 #include <brcmu_wifi.h>
  33 #include "dhd.h"
  34 #include "wl_cfg80211.h"
  35
  36 static struct sdio_func *cfg80211_sdio_func;
  37 static struct brcmf_cfg80211_dev *cfg80211_dev;
  38 static const u8 ether_bcast[ETH_ALEN] = {255, 255, 255, 255, 255, 255};
  39
  40 u32 brcmf_dbg_level = WL_DBG_ERR;
  41
  42 /*
  43 ** cfg80211_ops api/callback list
  44 */
  45 static s32 brcmf_cfg80211_change_iface(struct wiphy *wiphy,
  46                                        struct net_device *ndev,
  47                                        enum nl80211_iftype type, u32 *flags,
  48                                        struct vif_params *params);
  49 static s32 __brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
  50                                  struct cfg80211_scan_request *request,
  51                                  struct cfg80211_ssid *this_ssid);
  52 static s32 brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
  53                                struct cfg80211_scan_request *request);
  54 static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed);
  55 static s32 brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
  56                                     struct cfg80211_ibss_params *params);
  57 static s32 brcmf_cfg80211_leave_ibss(struct wiphy *wiphy,
  58                                      struct net_device *dev);
  59 static s32 brcmf_cfg80211_get_station(struct wiphy *wiphy,
  60                                       struct net_device *dev, u8 *mac,
  61                                       struct station_info *sinfo);
  62 static s32 brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy,
  63                                          struct net_device *dev, bool enabled,
  64                                          s32 timeout);
  65 static s32 brcmf_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
  66                                            struct net_device *dev,
  67                                            const u8 *addr,
  68                                            const struct cfg80211_bitrate_mask
  69                                            *mask);
  70 static int brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
  71                                   struct cfg80211_connect_params *sme);
  72 static s32 brcmf_cfg80211_disconnect(struct wiphy *wiphy,
  73                                      struct net_device *dev,
  74                                      u16 reason_code);
  75 static s32 brcmf_cfg80211_set_tx_power(struct wiphy *wiphy,
  76                                       enum nl80211_tx_power_setting type,
  77                                       s32 dbm);
  78 static s32 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm);
  79 static s32 brcmf_cfg80211_config_default_key(struct wiphy *wiphy,
  80                                           struct net_device *dev, u8 key_idx,
  81                                           bool unicast, bool multicast);
  82 static s32 brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
  83                                  u8 key_idx, bool pairwise, const u8 *mac_addr,
  84                                  struct key_params *params);
  85 static s32 brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
  86                                  u8 key_idx, bool pairwise, const u8 *mac_addr);
  87 static s32 brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
  88                                  u8 key_idx, bool pairwise, const u8 *mac_addr,
  89                                  void *cookie, void (*callback) (void *cookie,
  90                                                                  struct
  91                                                                  key_params *
  92                                                                  params));
  93 static s32 brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
  94                                                  struct net_device *dev,
  95                                                  u8 key_idx);
  96 static s32 brcmf_cfg80211_resume(struct wiphy *wiphy);
  97 static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
  98                                  struct cfg80211_wowlan *wow);
  99 static s32 brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
 100                                    struct cfg80211_pmksa *pmksa);
 101 static s32 brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
 102                                    struct cfg80211_pmksa *pmksa);
 103 static s32 brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy,
 104                                      struct net_device *dev);
 105 /*
 106 ** event & event Q handlers for cfg80211 interfaces
 107 */
 108 static s32 brcmf_create_event_handler(struct brcmf_cfg80211_priv *cfg_priv);
 109 static void brcmf_destroy_event_handler(struct brcmf_cfg80211_priv *cfg_priv);
 110 static s32 brcmf_event_handler(void *data);
 111 static void brcmf_init_eq(struct brcmf_cfg80211_priv *cfg_priv);
 112 static void brcmf_flush_eq(struct brcmf_cfg80211_priv *cfg_priv);
 113 static void brcmf_lock_eq(struct brcmf_cfg80211_priv *cfg_priv);
 114 static void brcmf_unlock_eq(struct brcmf_cfg80211_priv *cfg_priv);
 115 static void brcmf_init_eq_lock(struct brcmf_cfg80211_priv *cfg_priv);
 116 static void brcmf_init_eloop_handler(struct brcmf_cfg80211_event_loop *el);
 117 static struct brcmf_cfg80211_event_q *
 118 brcmf_deq_event(struct brcmf_cfg80211_priv *cfg_priv);
 119 static s32 brcmf_enq_event(struct brcmf_cfg80211_priv *cfg_priv, u32 type,
 120                           const struct brcmf_event_msg *msg);
 121 static void brcmf_put_event(struct brcmf_cfg80211_event_q *e);
 122 static void brcmf_wakeup_event(struct brcmf_cfg80211_priv *cfg_priv);
 123 static s32 brcmf_notify_connect_status(struct brcmf_cfg80211_priv *cfg_priv,
 124                                        struct net_device *ndev,
 125                                        const struct brcmf_event_msg *e,
 126                                        void *data);
 127 static s32 brcmf_notify_roaming_status(struct brcmf_cfg80211_priv *cfg_priv,
 128                                        struct net_device *ndev,
 129                                        const struct brcmf_event_msg *e,
 130                                        void *data);
 131 static s32 brcmf_notify_scan_status(struct brcmf_cfg80211_priv *cfg_priv,
 132                                     struct net_device *ndev,
 133                                     const struct brcmf_event_msg *e,
 134                                     void *data);
 135 static s32 brcmf_bss_connect_done(struct brcmf_cfg80211_priv *cfg_priv,
 136                                   struct net_device *ndev,
 137                                   const struct brcmf_event_msg *e,
 138                                   bool completed);
 139 static s32 brcmf_bss_roaming_done(struct brcmf_cfg80211_priv *cfg_priv,
 140                                   struct net_device *ndev,
 141                                   const struct brcmf_event_msg *e);
 142 static s32 brcmf_notify_mic_status(struct brcmf_cfg80211_priv *cfg_priv,
 143                                    struct net_device *ndev,
 144                                    const struct brcmf_event_msg *e, void *data);
 145
 146 /*
 147 ** register/deregister sdio function
 148 */
 149 static void brcmf_clear_sdio_func(void);
 150
 151 /*
 152 ** ioctl utilites
 153 */
 154 static s32 brcmf_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
 155                                s32 buf_len);
 156 static __used s32 brcmf_dev_bufvar_set(struct net_device *dev, s8 *name,
 157                                       s8 *buf, s32 len);
 158 static s32 brcmf_dev_intvar_set(struct net_device *dev, s8 *name, s32 val);
 159 static s32 brcmf_dev_intvar_get(struct net_device *dev, s8 *name,
 160                                s32 *retval);
 161 static s32 brcmf_dev_ioctl(struct net_device *dev, u32 cmd, void *arg,
 162                           u32 len);
 163
 164 /*
 165 ** cfg80211 set_wiphy_params utilities
 166 */
 167 static s32 brcmf_set_frag(struct net_device *dev, u32 frag_threshold);
 168 static s32 brcmf_set_rts(struct net_device *dev, u32 frag_threshold);
 169 static s32 brcmf_set_retry(struct net_device *dev, u32 retry, bool l);
 170
 171 /*
 172 ** wl profile utilities
 173 */
 174 static s32 brcmf_update_prof(struct brcmf_cfg80211_priv *cfg_priv,
 175                              const struct brcmf_event_msg *e,
 176                              void *data, s32 item);
 177 static void *brcmf_read_prof(struct brcmf_cfg80211_priv *cfg_priv, s32 item);
 178 static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof);
 179
 180 /*
 181 ** cfg80211 connect utilites
 182 */
 183 static s32 brcmf_set_wpa_version(struct net_device *dev,
 184                         struct cfg80211_connect_params *sme);
 185 static s32 brcmf_set_auth_type(struct net_device *dev,
 186                         struct cfg80211_connect_params *sme);
 187 static s32 brcmf_set_set_cipher(struct net_device *dev,
 188                         struct cfg80211_connect_params *sme);
 189 static s32 brcmf_set_key_mgmt(struct net_device *dev,
 190                         struct cfg80211_connect_params *sme);
 191 static s32 brcmf_set_set_sharedkey(struct net_device *dev,
 192                         struct cfg80211_connect_params *sme);
 193 static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv);
 194 static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv);
 195 static void brcmf_ch_to_chanspec(int ch,
 196         struct brcmf_join_params *join_params, size_t *join_params_size);
 197
 198 /*
 199 ** information element utilities
 200 */
 201 static __used s32 brcmf_add_ie(struct brcmf_cfg80211_priv *cfg_priv,
 202                                u8 t, u8 l, u8 *v);
 203 static s32 brcmf_mode_to_nl80211_iftype(s32 mode);
 204 static struct wireless_dev *brcmf_alloc_wdev(s32 sizeof_iface,
 205                         struct device *dev);
 206 static void brcmf_free_wdev(struct brcmf_cfg80211_priv *cfg_priv);
 207 static s32 brcmf_inform_bss(struct brcmf_cfg80211_priv *cfg_priv);
 208 static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_priv *cfg_priv,
 209                                    struct brcmf_bss_info *bi);
 210 static s32 brcmf_update_bss_info(struct brcmf_cfg80211_priv *cfg_priv);
 211 static s32 brcmf_add_keyext(struct wiphy *wiphy, struct net_device *dev,
 212                         u8 key_idx, const u8 *mac_addr,
 213                         struct key_params *params);
 214
 215 /*
 216 ** key indianess swap utilities
 217 */
 218 static void convert_key_from_CPU(struct brcmf_wsec_key *key);
 219 static void convert_key_to_CPU(struct brcmf_wsec_key *key);
 220
 221 /*
 222 ** brcmf_cfg80211_priv memory init/deinit utilities
 223 */
 224 static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_priv *cfg_priv);
 225 static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_priv *cfg_priv);
 226
 227 static void brcmf_delay(u32 ms);
 228
 229 /*
 230 ** store/restore cfg80211 instance data
 231 */
 232 static void brcmf_set_drvdata(struct brcmf_cfg80211_dev *dev, void *data);
 233 static void *brcmf_get_drvdata(struct brcmf_cfg80211_dev *dev);
 234
 235 /*
 236 ** ibss mode utilities
 237 */
 238 static bool brcmf_is_ibssmode(struct brcmf_cfg80211_priv *cfg_priv);
 239
 240 /*
 241 ** dongle up/down , default configuration utilities
 242 */
 243 static bool brcmf_is_linkdown(struct brcmf_cfg80211_priv *cfg_priv,
 244                               const struct brcmf_event_msg *e);
 245 static bool brcmf_is_linkup(struct brcmf_cfg80211_priv *cfg_priv,
 246                             const struct brcmf_event_msg *e);
 247 static bool brcmf_is_nonetwork(struct brcmf_cfg80211_priv *cfg_priv,
 248                                const struct brcmf_event_msg *e);
 249 static void brcmf_link_down(struct brcmf_cfg80211_priv *cfg_priv);
 250 static s32 brcmf_dongle_mode(struct net_device *ndev, s32 iftype);
 251 static s32 __brcmf_cfg80211_up(struct brcmf_cfg80211_priv *cfg_priv);
 252 static s32 __brcmf_cfg80211_down(struct brcmf_cfg80211_priv *cfg_priv);
 253 static s32 brcmf_dongle_probecap(struct brcmf_cfg80211_priv *cfg_priv);
 254 static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf);
 255
 256 /*
 257 ** dongle configuration utilities
 258 */
 259 static s32 brcmf_dongle_eventmsg(struct net_device *ndev);
 260 static s32 brcmf_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
 261                                  s32 scan_unassoc_time, s32 scan_passive_time);
 262 static s32 brcmf_config_dongle(struct brcmf_cfg80211_priv *cfg_priv,
 263                                bool need_lock);
 264 static s32 brcmf_dongle_roam(struct net_device *ndev, u32 roamvar,
 265                             u32 bcn_timeout);
 266
 267 /*
 268 ** iscan handler
 269 */
 270 static void brcmf_iscan_timer(unsigned long data);
 271 static void brcmf_term_iscan(struct brcmf_cfg80211_priv *cfg_priv);
 272 static s32 brcmf_init_iscan(struct brcmf_cfg80211_priv *cfg_priv);
 273 static s32 brcmf_iscan_thread(void *data);
 274 static s32 brcmf_dev_iovar_setbuf(struct net_device *dev, s8 *iovar,
 275                                  void *param, s32 paramlen, void *bufptr,
 276                                  s32 buflen);
 277 static s32 brcmf_dev_iovar_getbuf(struct net_device *dev, s8 *iovar,
 278                                  void *param, s32 paramlen, void *bufptr,
 279                                  s32 buflen);
 280 static s32 brcmf_run_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan,
 281                            struct brcmf_ssid *ssid, u16 action);
 282 static s32 brcmf_do_iscan(struct brcmf_cfg80211_priv *cfg_priv);
 283 static s32 brcmf_wakeup_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan);
 284 static s32 brcmf_invoke_iscan(struct brcmf_cfg80211_priv *cfg_priv);
 285 static s32 brcmf_get_iscan_results(struct brcmf_cfg80211_iscan_ctrl *iscan,
 286                                    u32 *status,
 287                                    struct brcmf_scan_results **bss_list);
 288 static void brcmf_notify_iscan_complete(struct brcmf_cfg80211_iscan_ctrl *iscan,
 289                                         bool aborted);
 290 static void brcmf_init_iscan_eloop(struct brcmf_cfg80211_iscan_eloop *el);
 291 static s32 brcmf_iscan_done(struct brcmf_cfg80211_priv *cfg_priv);
 292 static s32 brcmf_iscan_pending(struct brcmf_cfg80211_priv *cfg_priv);
 293 static s32 brcmf_iscan_inprogress(struct brcmf_cfg80211_priv *cfg_priv);
 294 static s32 brcmf_iscan_aborted(struct brcmf_cfg80211_priv *cfg_priv);
 295
 296 /*
 297 * find most significant bit set
 298 */
 299 static __used u32 brcmf_find_msb(u16 bit16);
 300
 301 /*
 302 * update pmklist to dongle
 303 */
 304 static __used s32 brcmf_update_pmklist(struct net_device *dev,
 305                                        struct brcmf_cfg80211_pmk_list *pmk_list,
 306                                        s32 err);
 307
 308 static void brcmf_set_mpc(struct net_device *ndev, int mpc);
 309
 310 /*
 311 * debufs support
 312 */
 313 static int
 314 brcmf_debugfs_add_netdev_params(struct brcmf_cfg80211_priv *cfg_priv);
 315 static void brcmf_debugfs_remove_netdev(struct brcmf_cfg80211_priv *cfg_priv);
 316
 317 #define WL_PRIV_GET()                                                   \
 318         ({                                                              \
 319         struct brcmf_cfg80211_iface *ci = brcmf_get_drvdata(cfg80211_dev); \
 320         if (unlikely(!ci)) {                                            \
 321                 WL_ERR("wl_cfg80211_dev is unavailable\n");             \
 322                 BUG();                                                  \
 323         }                                                               \
 324         ci->cfg_priv;                                                   \
 325 })
 326
 327 #define CHECK_SYS_UP()                                                  \
 328 do {                                                                    \
 329         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);     \
 330         if (unlikely(!test_bit(WL_STATUS_READY, &cfg_priv->status))) {  \
 331                 WL_INFO("device is not ready : status (%d)\n",          \
 332                         (int)cfg_priv->status);                         \
 333                 return -EIO;                                            \
 334         }                                                               \
 335 } while (0)
 336
 337 #define CHAN2G(_channel, _freq, _flags) {                       \
 338         .band                   = IEEE80211_BAND_2GHZ,          \
 339         .center_freq            = (_freq),                      \
 340         .hw_value               = (_channel),                   \
 341         .flags                  = (_flags),                     \
 342         .max_antenna_gain       = 0,                            \
 343         .max_power              = 30,                           \
 344 }
 345
 346 #define CHAN5G(_channel, _flags) {                              \
 347         .band                   = IEEE80211_BAND_5GHZ,          \
 348         .center_freq            = 5000 + (5 * (_channel)),      \
 349         .hw_value               = (_channel),                   \
 350         .flags                  = (_flags),                     \
 351         .max_antenna_gain       = 0,                            \
 352         .max_power              = 30,                           \
 353 }
 354
 355 #define RATE_TO_BASE100KBPS(rate)   (((rate) * 10) / 2)
 356 #define RATETAB_ENT(_rateid, _flags) \
 357         {                                                               \
 358                 .bitrate        = RATE_TO_BASE100KBPS(_rateid),     \
 359                 .hw_value       = (_rateid),                            \
 360                 .flags          = (_flags),                             \
 361         }
 362
 363 static struct ieee80211_rate __wl_rates[] = {
 364         RATETAB_ENT(BRCM_RATE_1M, 0),
 365         RATETAB_ENT(BRCM_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
 366         RATETAB_ENT(BRCM_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
 367         RATETAB_ENT(BRCM_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
 368         RATETAB_ENT(BRCM_RATE_6M, 0),
 369         RATETAB_ENT(BRCM_RATE_9M, 0),
 370         RATETAB_ENT(BRCM_RATE_12M, 0),
 371         RATETAB_ENT(BRCM_RATE_18M, 0),
 372         RATETAB_ENT(BRCM_RATE_24M, 0),
 373         RATETAB_ENT(BRCM_RATE_36M, 0),
 374         RATETAB_ENT(BRCM_RATE_48M, 0),
 375         RATETAB_ENT(BRCM_RATE_54M, 0),
 376 };
 377
 378 #define wl_a_rates              (__wl_rates + 4)
 379 #define wl_a_rates_size 8
 380 #define wl_g_rates              (__wl_rates + 0)
 381 #define wl_g_rates_size 12
 382
 383 static struct ieee80211_channel __wl_2ghz_channels[] = {
 384         CHAN2G(1, 2412, 0),
 385         CHAN2G(2, 2417, 0),
 386         CHAN2G(3, 2422, 0),
 387         CHAN2G(4, 2427, 0),
 388         CHAN2G(5, 2432, 0),
 389         CHAN2G(6, 2437, 0),
 390         CHAN2G(7, 2442, 0),
 391         CHAN2G(8, 2447, 0),
 392         CHAN2G(9, 2452, 0),
 393         CHAN2G(10, 2457, 0),
 394         CHAN2G(11, 2462, 0),
 395         CHAN2G(12, 2467, 0),
 396         CHAN2G(13, 2472, 0),
 397         CHAN2G(14, 2484, 0),
 398 };
 399
 400 static struct ieee80211_channel __wl_5ghz_a_channels[] = {
 401         CHAN5G(34, 0), CHAN5G(36, 0),
 402         CHAN5G(38, 0), CHAN5G(40, 0),
 403         CHAN5G(42, 0), CHAN5G(44, 0),
 404         CHAN5G(46, 0), CHAN5G(48, 0),
 405         CHAN5G(52, 0), CHAN5G(56, 0),
 406         CHAN5G(60, 0), CHAN5G(64, 0),
 407         CHAN5G(100, 0), CHAN5G(104, 0),
 408         CHAN5G(108, 0), CHAN5G(112, 0),
 409         CHAN5G(116, 0), CHAN5G(120, 0),
 410         CHAN5G(124, 0), CHAN5G(128, 0),
 411         CHAN5G(132, 0), CHAN5G(136, 0),
 412         CHAN5G(140, 0), CHAN5G(149, 0),
 413         CHAN5G(153, 0), CHAN5G(157, 0),
 414         CHAN5G(161, 0), CHAN5G(165, 0),
 415         CHAN5G(184, 0), CHAN5G(188, 0),
 416         CHAN5G(192, 0), CHAN5G(196, 0),
 417         CHAN5G(200, 0), CHAN5G(204, 0),
 418         CHAN5G(208, 0), CHAN5G(212, 0),
 419         CHAN5G(216, 0),
 420 };
 421
 422 static struct ieee80211_channel __wl_5ghz_n_channels[] = {
 423         CHAN5G(32, 0), CHAN5G(34, 0),
 424         CHAN5G(36, 0), CHAN5G(38, 0),
 425         CHAN5G(40, 0), CHAN5G(42, 0),
 426         CHAN5G(44, 0), CHAN5G(46, 0),
 427         CHAN5G(48, 0), CHAN5G(50, 0),
 428         CHAN5G(52, 0), CHAN5G(54, 0),
 429         CHAN5G(56, 0), CHAN5G(58, 0),
 430         CHAN5G(60, 0), CHAN5G(62, 0),
 431         CHAN5G(64, 0), CHAN5G(66, 0),
 432         CHAN5G(68, 0), CHAN5G(70, 0),
 433         CHAN5G(72, 0), CHAN5G(74, 0),
 434         CHAN5G(76, 0), CHAN5G(78, 0),
 435         CHAN5G(80, 0), CHAN5G(82, 0),
 436         CHAN5G(84, 0), CHAN5G(86, 0),
 437         CHAN5G(88, 0), CHAN5G(90, 0),
 438         CHAN5G(92, 0), CHAN5G(94, 0),
 439         CHAN5G(96, 0), CHAN5G(98, 0),
 440         CHAN5G(100, 0), CHAN5G(102, 0),
 441         CHAN5G(104, 0), CHAN5G(106, 0),
 442         CHAN5G(108, 0), CHAN5G(110, 0),
 443         CHAN5G(112, 0), CHAN5G(114, 0),
 444         CHAN5G(116, 0), CHAN5G(118, 0),
 445         CHAN5G(120, 0), CHAN5G(122, 0),
 446         CHAN5G(124, 0), CHAN5G(126, 0),
 447         CHAN5G(128, 0), CHAN5G(130, 0),
 448         CHAN5G(132, 0), CHAN5G(134, 0),
 449         CHAN5G(136, 0), CHAN5G(138, 0),
 450         CHAN5G(140, 0), CHAN5G(142, 0),
 451         CHAN5G(144, 0), CHAN5G(145, 0),
 452         CHAN5G(146, 0), CHAN5G(147, 0),
 453         CHAN5G(148, 0), CHAN5G(149, 0),
 454         CHAN5G(150, 0), CHAN5G(151, 0),
 455         CHAN5G(152, 0), CHAN5G(153, 0),
 456         CHAN5G(154, 0), CHAN5G(155, 0),
 457         CHAN5G(156, 0), CHAN5G(157, 0),
 458         CHAN5G(158, 0), CHAN5G(159, 0),
 459         CHAN5G(160, 0), CHAN5G(161, 0),
 460         CHAN5G(162, 0), CHAN5G(163, 0),
 461         CHAN5G(164, 0), CHAN5G(165, 0),
 462         CHAN5G(166, 0), CHAN5G(168, 0),
 463         CHAN5G(170, 0), CHAN5G(172, 0),
 464         CHAN5G(174, 0), CHAN5G(176, 0),
 465         CHAN5G(178, 0), CHAN5G(180, 0),
 466         CHAN5G(182, 0), CHAN5G(184, 0),
 467         CHAN5G(186, 0), CHAN5G(188, 0),
 468         CHAN5G(190, 0), CHAN5G(192, 0),
 469         CHAN5G(194, 0), CHAN5G(196, 0),
 470         CHAN5G(198, 0), CHAN5G(200, 0),
 471         CHAN5G(202, 0), CHAN5G(204, 0),
 472         CHAN5G(206, 0), CHAN5G(208, 0),
 473         CHAN5G(210, 0), CHAN5G(212, 0),
 474         CHAN5G(214, 0), CHAN5G(216, 0),
 475         CHAN5G(218, 0), CHAN5G(220, 0),
 476         CHAN5G(222, 0), CHAN5G(224, 0),
 477         CHAN5G(226, 0), CHAN5G(228, 0),
 478 };
 479
 480 static struct ieee80211_supported_band __wl_band_2ghz = {
 481         .band = IEEE80211_BAND_2GHZ,
 482         .channels = __wl_2ghz_channels,
 483         .n_channels = ARRAY_SIZE(__wl_2ghz_channels),
 484         .bitrates = wl_g_rates,
 485         .n_bitrates = wl_g_rates_size,
 486 };
 487
 488 static struct ieee80211_supported_band __wl_band_5ghz_a = {
 489         .band = IEEE80211_BAND_5GHZ,
 490         .channels = __wl_5ghz_a_channels,
 491         .n_channels = ARRAY_SIZE(__wl_5ghz_a_channels),
 492         .bitrates = wl_a_rates,
 493         .n_bitrates = wl_a_rates_size,
 494 };
 495
 496 static struct ieee80211_supported_band __wl_band_5ghz_n = {
 497         .band = IEEE80211_BAND_5GHZ,
 498         .channels = __wl_5ghz_n_channels,
 499         .n_channels = ARRAY_SIZE(__wl_5ghz_n_channels),
 500         .bitrates = wl_a_rates,
 501         .n_bitrates = wl_a_rates_size,
 502 };
 503
 504 static const u32 __wl_cipher_suites[] = {
 505         WLAN_CIPHER_SUITE_WEP40,
 506         WLAN_CIPHER_SUITE_WEP104,
 507         WLAN_CIPHER_SUITE_TKIP,
 508         WLAN_CIPHER_SUITE_CCMP,
 509         WLAN_CIPHER_SUITE_AES_CMAC,
 510 };
 511
 512 static void convert_key_from_CPU(struct brcmf_wsec_key *key)
 513 {
 514         key->index = cpu_to_le32(key->index);
 515         key->len = cpu_to_le32(key->len);
 516         key->algo = cpu_to_le32(key->algo);
 517         key->flags = cpu_to_le32(key->flags);
 518         key->rxiv.hi = cpu_to_le32(key->rxiv.hi);
 519         key->rxiv.lo = cpu_to_le16(key->rxiv.lo);
 520         key->iv_initialized = cpu_to_le32(key->iv_initialized);
 521 }
 522
 523 static void convert_key_to_CPU(struct brcmf_wsec_key *key)
 524 {
 525         key->index = le32_to_cpu(key->index);
 526         key->len = le32_to_cpu(key->len);
 527         key->algo = le32_to_cpu(key->algo);
 528         key->flags = le32_to_cpu(key->flags);
 529         key->rxiv.hi = le32_to_cpu(key->rxiv.hi);
 530         key->rxiv.lo = le16_to_cpu(key->rxiv.lo);
 531         key->iv_initialized = le32_to_cpu(key->iv_initialized);
 532 }
 533
 534 static s32
 535 brcmf_dev_ioctl(struct net_device *dev, u32 cmd, void *arg, u32 len)
 536 {
 537         struct ifreq ifr;
 538         struct brcmf_ioctl ioc;
 539         mm_segment_t fs;
 540         s32 err = 0;
 541
 542         memset(&ioc, 0, sizeof(ioc));
 543         ioc.cmd = cmd;
 544         ioc.buf = arg;
 545         ioc.len = len;
 546         strcpy(ifr.ifr_name, dev->name);
 547         ifr.ifr_data = (caddr_t)&ioc;
 548
 549         fs = get_fs();
 550         set_fs(get_ds());
 551         err = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
 552         set_fs(fs);
 553
 554         return err;
 555 }
 556
 557 static s32
 558 brcmf_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
 559                          enum nl80211_iftype type, u32 *flags,
 560                          struct vif_params *params)
 561 {
 562         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
 563         struct wireless_dev *wdev;
 564         s32 infra = 0;
 565         s32 err = 0;
 566
 567         WL_TRACE("Enter\n");
 568         CHECK_SYS_UP();
 569
 570         switch (type) {
 571         case NL80211_IFTYPE_MONITOR:
 572         case NL80211_IFTYPE_WDS:
 573                 WL_ERR("type (%d) : currently we do not support this type\n",
 574                        type);
 575                 return -EOPNOTSUPP;
 576         case NL80211_IFTYPE_ADHOC:
 577                 cfg_priv->conf->mode = WL_MODE_IBSS;
 578                 infra = 0;
 579                 break;
 580         case NL80211_IFTYPE_STATION:
 581                 cfg_priv->conf->mode = WL_MODE_BSS;
 582                 infra = 1;
 583                 break;
 584         default:
 585                 err = -EINVAL;
 586                 goto done;
 587         }
 588
 589         infra = cpu_to_le32(infra);
 590         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_INFRA, &infra, sizeof(infra));
 591         if (unlikely(err)) {
 592                 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
 593                 err = -EAGAIN;
 594         } else {
 595                 wdev = ndev->ieee80211_ptr;
 596                 wdev->iftype = type;
 597         }
 598
 599         WL_INFO("IF Type = %s\n",
 600                 (cfg_priv->conf->mode == WL_MODE_IBSS) ? "Adhoc" : "Infra");
 601
 602 done:
 603         WL_TRACE("Exit\n");
 604
 605         return err;
 606 }
 607
 608 static void wl_iscan_prep(struct brcmf_scan_params *params,
 609                           struct brcmf_ssid *ssid)
 610 {
 611         memcpy(params->bssid, ether_bcast, ETH_ALEN);
 612         params->bss_type = DOT11_BSSTYPE_ANY;
 613         params->scan_type = 0;
 614         params->nprobes = -1;
 615         params->active_time = -1;
 616         params->passive_time = -1;
 617         params->home_time = -1;
 618         params->channel_num = 0;
 619
 620         params->nprobes = cpu_to_le32(params->nprobes);
 621         params->active_time = cpu_to_le32(params->active_time);
 622         params->passive_time = cpu_to_le32(params->passive_time);
 623         params->home_time = cpu_to_le32(params->home_time);
 624         if (ssid && ssid->SSID_len)
 625                 memcpy(&params->ssid, ssid, sizeof(struct brcmf_ssid));
 626
 627 }
 628
 629 static s32
 630 brcmf_dev_iovar_setbuf(struct net_device *dev, s8 * iovar, void *param,
 631                     s32 paramlen, void *bufptr, s32 buflen)
 632 {
 633         s32 iolen;
 634
 635         iolen = brcmu_mkiovar(iovar, param, paramlen, bufptr, buflen);
 636         BUG_ON(!iolen);
 637
 638         return brcmf_dev_ioctl(dev, BRCMF_C_SET_VAR, bufptr, iolen);
 639 }
 640
 641 static s32
 642 brcmf_dev_iovar_getbuf(struct net_device *dev, s8 * iovar, void *param,
 643                     s32 paramlen, void *bufptr, s32 buflen)
 644 {
 645         s32 iolen;
 646
 647         iolen = brcmu_mkiovar(iovar, param, paramlen, bufptr, buflen);
 648         BUG_ON(!iolen);
 649
 650         return brcmf_dev_ioctl(dev, BRCMF_C_GET_VAR, bufptr, buflen);
 651 }
 652
 653 static s32
 654 brcmf_run_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan,
 655                 struct brcmf_ssid *ssid, u16 action)
 656 {
 657         s32 params_size = (BRCMF_SCAN_PARAMS_FIXED_SIZE +
 658                                 offsetof(struct brcmf_iscan_params, params));
 659         struct brcmf_iscan_params *params;
 660         s32 err = 0;
 661
 662         if (ssid && ssid->SSID_len)
 663                 params_size += sizeof(struct brcmf_ssid);
 664         params = kzalloc(params_size, GFP_KERNEL);
 665         if (unlikely(!params))
 666                 return -ENOMEM;
 667         BUG_ON(params_size >= BRCMF_C_IOCTL_SMLEN);
 668
 669         wl_iscan_prep(&params->params, ssid);
 670
 671         params->version = cpu_to_le32(BRCMF_ISCAN_REQ_VERSION);
 672         params->action = cpu_to_le16(action);
 673         params->scan_duration = cpu_to_le16(0);
 674
 675         /* params_size += offsetof(struct brcmf_iscan_params, params); */
 676         err = brcmf_dev_iovar_setbuf(iscan->dev, "iscan", params, params_size,
 677                                 iscan->ioctl_buf, BRCMF_C_IOCTL_SMLEN);
 678         if (unlikely(err)) {
 679                 if (err == -EBUSY)
 680                         WL_INFO("system busy : iscan canceled\n");
 681                 else
 682                         WL_ERR("error (%d)\n", err);
 683         }
 684
 685         kfree(params);
 686         return err;
 687 }
 688
 689 static s32 brcmf_do_iscan(struct brcmf_cfg80211_priv *cfg_priv)
 690 {
 691         struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
 692         struct net_device *ndev = cfg_to_ndev(cfg_priv);
 693         struct brcmf_ssid ssid;
 694         s32 passive_scan;
 695         s32 err = 0;
 696
 697         /* Broadcast scan by default */
 698         memset(&ssid, 0, sizeof(ssid));
 699
 700         iscan->state = WL_ISCAN_STATE_SCANING;
 701
 702         passive_scan = cfg_priv->active_scan ? 0 : 1;
 703         err = brcmf_dev_ioctl(cfg_to_ndev(cfg_priv), BRCMF_C_SET_PASSIVE_SCAN,
 704                         &passive_scan, sizeof(passive_scan));
 705         if (unlikely(err)) {
 706                 WL_ERR("error (%d)\n", err);
 707                 return err;
 708         }
 709         brcmf_set_mpc(ndev, 0);
 710         cfg_priv->iscan_kickstart = true;
 711         err = brcmf_run_iscan(iscan, &ssid, BRCMF_SCAN_ACTION_START);
 712         if (err) {
 713                 brcmf_set_mpc(ndev, 1);
 714                 cfg_priv->iscan_kickstart = false;
 715                 return err;
 716         }
 717         mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
 718         iscan->timer_on = 1;
 719         return err;
 720 }
 721
 722 static s32
 723 __brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
 724                    struct cfg80211_scan_request *request,
 725                    struct cfg80211_ssid *this_ssid)
 726 {
 727         struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
 728         struct cfg80211_ssid *ssids;
 729         struct brcmf_cfg80211_scan_req *sr = cfg_priv->scan_req_int;
 730         s32 passive_scan;
 731         bool iscan_req;
 732         bool spec_scan;
 733         s32 err = 0;
 734
 735         if (unlikely(test_bit(WL_STATUS_SCANNING, &cfg_priv->status))) {
 736                 WL_ERR("Scanning already : status (%lu)\n", cfg_priv->status);
 737                 return -EAGAIN;
 738         }
 739         if (unlikely(test_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status))) {
 740                 WL_ERR("Scanning being aborted : status (%lu)\n",
 741                        cfg_priv->status);
 742                 return -EAGAIN;
 743         }
 744         if (test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) {
 745                 WL_ERR("Connecting : status (%lu)\n",
 746                        cfg_priv->status);
 747                 return -EAGAIN;
 748         }
 749
 750         iscan_req = false;
 751         spec_scan = false;
 752         if (request) {
 753                 /* scan bss */
 754                 ssids = request->ssids;
 755                 if (cfg_priv->iscan_on && (!ssids || !ssids->ssid_len))
 756                         iscan_req = true;
 757         } else {
 758                 /* scan in ibss */
 759                 /* we don't do iscan in ibss */
 760                 ssids = this_ssid;
 761         }
 762
 763         cfg_priv->scan_request = request;
 764         set_bit(WL_STATUS_SCANNING, &cfg_priv->status);
 765         if (iscan_req) {
 766                 err = brcmf_do_iscan(cfg_priv);
 767                 if (likely(!err))
 768                         return err;
 769                 else
 770                         goto scan_out;
 771         } else {
 772                 WL_SCAN("ssid \"%s\", ssid_len (%d)\n",
 773                        ssids->ssid, ssids->ssid_len);
 774                 memset(&sr->ssid, 0, sizeof(sr->ssid));
 775                 sr->ssid.SSID_len =
 776                             min_t(u8, sizeof(sr->ssid.SSID), ssids->ssid_len);
 777                 if (sr->ssid.SSID_len) {
 778                         memcpy(sr->ssid.SSID, ssids->ssid, sr->ssid.SSID_len);
 779                         sr->ssid.SSID_len = cpu_to_le32(sr->ssid.SSID_len);
 780                         spec_scan = true;
 781                 } else {
 782                         WL_SCAN("Broadcast scan\n");
 783                 }
 784
 785                 passive_scan = cfg_priv->active_scan ? 0 : 1;
 786                 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_PASSIVE_SCAN,
 787                                 &passive_scan, sizeof(passive_scan));
 788                 if (unlikely(err)) {
 789                         WL_ERR("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
 790                         goto scan_out;
 791                 }
 792                 brcmf_set_mpc(ndev, 0);
 793                 err = brcmf_dev_ioctl(ndev, BRCMF_C_SCAN, &sr->ssid,
 794                                 sizeof(sr->ssid));
 795                 if (err) {
 796                         if (err == -EBUSY)
 797                                 WL_INFO("system busy : scan for \"%s\" "
 798                                         "canceled\n", sr->ssid.SSID);
 799                         else
 800                                 WL_ERR("WLC_SCAN error (%d)\n", err);
 801
 802                         brcmf_set_mpc(ndev, 1);
 803                         goto scan_out;
 804                 }
 805         }
 806
 807         return 0;
 808
 809 scan_out:
 810         clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
 811         cfg_priv->scan_request = NULL;
 812         return err;
 813 }
 814
 815 static s32
 816 brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
 817                  struct cfg80211_scan_request *request)
 818 {
 819         s32 err = 0;
 820
 821         WL_TRACE("Enter\n");
 822
 823         CHECK_SYS_UP();
 824
 825         err = __brcmf_cfg80211_scan(wiphy, ndev, request, NULL);
 826         if (unlikely(err))
 827                 WL_ERR("scan error (%d)\n", err);
 828
 829         WL_TRACE("Exit\n");
 830         return err;
 831 }
 832
 833 static s32 brcmf_dev_intvar_set(struct net_device *dev, s8 *name, s32 val)
 834 {
 835         s8 buf[BRCMF_C_IOCTL_SMLEN];
 836         u32 len;
 837         s32 err = 0;
 838
 839         val = cpu_to_le32(val);
 840         len = brcmu_mkiovar(name, (char *)(&val), sizeof(val), buf,
 841                             sizeof(buf));
 842         BUG_ON(!len);
 843
 844         err = brcmf_dev_ioctl(dev, BRCMF_C_SET_VAR, buf, len);
 845         if (unlikely(err))
 846                 WL_ERR("error (%d)\n", err);
 847
 848         return err;
 849 }
 850
 851 static s32
 852 brcmf_dev_intvar_get(struct net_device *dev, s8 *name, s32 *retval)
 853 {
 854         union {
 855                 s8 buf[BRCMF_C_IOCTL_SMLEN];
 856                 s32 val;
 857         } var;
 858         u32 len;
 859         u32 data_null;
 860         s32 err = 0;
 861
 862         len =
 863             brcmu_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
 864                         sizeof(var.buf));
 865         BUG_ON(!len);
 866         err = brcmf_dev_ioctl(dev, BRCMF_C_GET_VAR, &var, len);
 867         if (unlikely(err))
 868                 WL_ERR("error (%d)\n", err);
 869
 870         *retval = le32_to_cpu(var.val);
 871
 872         return err;
 873 }
 874
 875 static s32 brcmf_set_rts(struct net_device *dev, u32 rts_threshold)
 876 {
 877         s32 err = 0;
 878
 879         err = brcmf_dev_intvar_set(dev, "rtsthresh", rts_threshold);
 880         if (unlikely(err))
 881                 WL_ERR("Error (%d)\n", err);
 882
 883         return err;
 884 }
 885
 886 static s32 brcmf_set_frag(struct net_device *dev, u32 frag_threshold)
 887 {
 888         s32 err = 0;
 889
 890         err = brcmf_dev_intvar_set(dev, "fragthresh", frag_threshold);
 891         if (unlikely(err))
 892                 WL_ERR("Error (%d)\n", err);
 893
 894         return err;
 895 }
 896
 897 static s32 brcmf_set_retry(struct net_device *dev, u32 retry, bool l)
 898 {
 899         s32 err = 0;
 900         u32 cmd = (l ? BRCM_SET_LRL : BRCM_SET_SRL);
 901
 902         retry = cpu_to_le32(retry);
 903         err = brcmf_dev_ioctl(dev, cmd, &retry, sizeof(retry));
 904         if (unlikely(err)) {
 905                 WL_ERR("cmd (%d) , error (%d)\n", cmd, err);
 906                 return err;
 907         }
 908         return err;
 909 }
 910
 911 static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
 912 {
 913         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
 914         struct net_device *ndev = cfg_to_ndev(cfg_priv);
 915         s32 err = 0;
 916
 917         WL_TRACE("Enter\n");
 918         CHECK_SYS_UP();
 919
 920         if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
 921             (cfg_priv->conf->rts_threshold != wiphy->rts_threshold)) {
 922                 cfg_priv->conf->rts_threshold = wiphy->rts_threshold;
 923                 err = brcmf_set_rts(ndev, cfg_priv->conf->rts_threshold);
 924                 if (!err)
 925                         goto done;
 926         }
 927         if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
 928             (cfg_priv->conf->frag_threshold != wiphy->frag_threshold)) {
 929                 cfg_priv->conf->frag_threshold = wiphy->frag_threshold;
 930                 err = brcmf_set_frag(ndev, cfg_priv->conf->frag_threshold);
 931                 if (!err)
 932                         goto done;
 933         }
 934         if (changed & WIPHY_PARAM_RETRY_LONG
 935             && (cfg_priv->conf->retry_long != wiphy->retry_long)) {
 936                 cfg_priv->conf->retry_long = wiphy->retry_long;
 937                 err = brcmf_set_retry(ndev, cfg_priv->conf->retry_long, true);
 938                 if (!err)
 939                         goto done;
 940         }
 941         if (changed & WIPHY_PARAM_RETRY_SHORT
 942             && (cfg_priv->conf->retry_short != wiphy->retry_short)) {
 943                 cfg_priv->conf->retry_short = wiphy->retry_short;
 944                 err = brcmf_set_retry(ndev, cfg_priv->conf->retry_short, false);
 945                 if (!err)
 946                         goto done;
 947         }
 948
 949 done:
 950         WL_TRACE("Exit\n");
 951         return err;
 952 }
 953
 954 static s32
 955 brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
 956                       struct cfg80211_ibss_params *params)
 957 {
 958         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
 959         struct brcmf_join_params join_params;
 960         size_t join_params_size = 0;
 961         s32 err = 0;
 962         s32 wsec = 0;
 963         s32 bcnprd;
 964
 965         WL_TRACE("Enter\n");
 966         CHECK_SYS_UP();
 967
 968         if (params->ssid)
 969                 WL_CONN("SSID: %s\n", params->ssid);
 970         else {
 971                 WL_CONN("SSID: NULL, Not supported\n");
 972                 return -EOPNOTSUPP;
 973         }
 974
 975         set_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
 976
 977         if (params->bssid)
 978                 WL_CONN("BSSID: %02X %02X %02X %02X %02X %02X\n",
 979                 params->bssid[0], params->bssid[1], params->bssid[2],
 980                 params->bssid[3], params->bssid[4], params->bssid[5]);
 981         else
 982                 WL_CONN("No BSSID specified\n");
 983
 984         if (params->channel)
 985                 WL_CONN("channel: %d\n", params->channel->center_freq);
 986         else
 987                 WL_CONN("no channel specified\n");
 988
 989         if (params->channel_fixed)
 990                 WL_CONN("fixed channel required\n");
 991         else
 992                 WL_CONN("no fixed channel required\n");
 993
 994         if (params->ie && params->ie_len)
 995                 WL_CONN("ie len: %d\n", params->ie_len);
 996         else
 997                 WL_CONN("no ie specified\n");
 998
 999         if (params->beacon_interval)
1000                 WL_CONN("beacon interval: %d\n", params->beacon_interval);
1001         else
1002                 WL_CONN("no beacon interval specified\n");
1003
1004         if (params->basic_rates)
1005                 WL_CONN("basic rates: %08X\n", params->basic_rates);
1006         else
1007                 WL_CONN("no basic rates specified\n");
1008
1009         if (params->privacy)
1010                 WL_CONN("privacy required\n");
1011         else
1012                 WL_CONN("no privacy required\n");
1013
1014         /* Configure Privacy for starter */
1015         if (params->privacy)
1016                 wsec |= WEP_ENABLED;
1017
1018         err = brcmf_dev_intvar_set(dev, "wsec", wsec);
1019         if (unlikely(err)) {
1020                 WL_ERR("wsec failed (%d)\n", err);
1021                 goto done;
1022         }
1023
1024         /* Configure Beacon Interval for starter */
1025         if (params->beacon_interval)
1026                 bcnprd = cpu_to_le32(params->beacon_interval);
1027         else
1028                 bcnprd = cpu_to_le32(100);
1029
1030         err = brcmf_dev_ioctl(dev, BRCM_SET_BCNPRD, &bcnprd, sizeof(bcnprd));
1031         if (unlikely(err)) {
1032                 WL_ERR("WLC_SET_BCNPRD failed (%d)\n", err);
1033                 goto done;
1034         }
1035
1036         /* Configure required join parameter */
1037         memset(&join_params, 0, sizeof(struct brcmf_join_params));
1038
1039         /* SSID */
1040         join_params.ssid.SSID_len =
1041                         (params->ssid_len > 32) ? 32 : params->ssid_len;
1042         memcpy(join_params.ssid.SSID, params->ssid, join_params.ssid.SSID_len);
1043         join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1044         join_params_size = sizeof(join_params.ssid);
1045         brcmf_update_prof(cfg_priv, NULL, &join_params.ssid, WL_PROF_SSID);
1046
1047         /* BSSID */
1048         if (params->bssid) {
1049                 memcpy(join_params.params.bssid, params->bssid, ETH_ALEN);
1050                 join_params_size = sizeof(join_params.ssid) +
1051                                         BRCMF_ASSOC_PARAMS_FIXED_SIZE;
1052         } else {
1053                 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1054         }
1055
1056         brcmf_update_prof(cfg_priv, NULL,
1057                           &join_params.params.bssid, WL_PROF_BSSID);
1058
1059         /* Channel */
1060         if (params->channel) {
1061                 u32 target_channel;
1062
1063                 cfg_priv->channel =
1064                         ieee80211_frequency_to_channel(
1065                                 params->channel->center_freq);
1066                 if (params->channel_fixed) {
1067                         /* adding chanspec */
1068                         brcmf_ch_to_chanspec(cfg_priv->channel,
1069                                 &join_params, &join_params_size);
1070                 }
1071
1072                 /* set channel for starter */
1073                 target_channel = cpu_to_le32(cfg_priv->channel);
1074                 err = brcmf_dev_ioctl(dev, BRCM_SET_CHANNEL,
1075                         &target_channel, sizeof(target_channel));
1076                 if (unlikely(err)) {
1077                         WL_ERR("WLC_SET_CHANNEL failed (%d)\n", err);
1078                         goto done;
1079                 }
1080         } else
1081                 cfg_priv->channel = 0;
1082
1083         cfg_priv->ibss_starter = false;
1084
1085
1086         err = brcmf_dev_ioctl(dev, BRCMF_C_SET_SSID,
1087                            &join_params, join_params_size);
1088         if (unlikely(err)) {
1089                 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1090                 goto done;
1091         }
1092
1093 done:
1094         if (err)
1095                 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1096         WL_TRACE("Exit\n");
1097         return err;
1098 }
1099
1100 static s32
1101 brcmf_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1102 {
1103         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1104         s32 err = 0;
1105
1106         WL_TRACE("Enter\n");
1107         CHECK_SYS_UP();
1108
1109         brcmf_link_down(cfg_priv);
1110
1111         WL_TRACE("Exit\n");
1112
1113         return err;
1114 }
1115
1116 static s32 brcmf_set_wpa_version(struct net_device *dev,
1117                                  struct cfg80211_connect_params *sme)
1118 {
1119         struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
1120         struct brcmf_cfg80211_security *sec;
1121         s32 val = 0;
1122         s32 err = 0;
1123
1124         if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1125                 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1126         else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1127                 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1128         else
1129                 val = WPA_AUTH_DISABLED;
1130         WL_CONN("setting wpa_auth to 0x%0x\n", val);
1131         err = brcmf_dev_intvar_set(dev, "wpa_auth", val);
1132         if (unlikely(err)) {
1133                 WL_ERR("set wpa_auth failed (%d)\n", err);
1134                 return err;
1135         }
1136         sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1137         sec->wpa_versions = sme->crypto.wpa_versions;
1138         return err;
1139 }
1140
1141 static s32
1142 brcmf_set_auth_type(struct net_device *dev, struct cfg80211_connect_params *sme)
1143 {
1144         struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
1145         struct brcmf_cfg80211_security *sec;
1146         s32 val = 0;
1147         s32 err = 0;
1148
1149         switch (sme->auth_type) {
1150         case NL80211_AUTHTYPE_OPEN_SYSTEM:
1151                 val = 0;
1152                 WL_CONN("open system\n");
1153                 break;
1154         case NL80211_AUTHTYPE_SHARED_KEY:
1155                 val = 1;
1156                 WL_CONN("shared key\n");
1157                 break;
1158         case NL80211_AUTHTYPE_AUTOMATIC:
1159                 val = 2;
1160                 WL_CONN("automatic\n");
1161                 break;
1162         case NL80211_AUTHTYPE_NETWORK_EAP:
1163                 WL_CONN("network eap\n");
1164         default:
1165                 val = 2;
1166                 WL_ERR("invalid auth type (%d)\n", sme->auth_type);
1167                 break;
1168         }
1169
1170         err = brcmf_dev_intvar_set(dev, "auth", val);
1171         if (unlikely(err)) {
1172                 WL_ERR("set auth failed (%d)\n", err);
1173                 return err;
1174         }
1175         sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1176         sec->auth_type = sme->auth_type;
1177         return err;
1178 }
1179
1180 static s32
1181 brcmf_set_set_cipher(struct net_device *dev,
1182                      struct cfg80211_connect_params *sme)
1183 {
1184         struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
1185         struct brcmf_cfg80211_security *sec;
1186         s32 pval = 0;
1187         s32 gval = 0;
1188         s32 err = 0;
1189
1190         if (sme->crypto.n_ciphers_pairwise) {
1191                 switch (sme->crypto.ciphers_pairwise[0]) {
1192                 case WLAN_CIPHER_SUITE_WEP40:
1193                 case WLAN_CIPHER_SUITE_WEP104:
1194                         pval = WEP_ENABLED;
1195                         break;
1196                 case WLAN_CIPHER_SUITE_TKIP:
1197                         pval = TKIP_ENABLED;
1198                         break;
1199                 case WLAN_CIPHER_SUITE_CCMP:
1200                         pval = AES_ENABLED;
1201                         break;
1202                 case WLAN_CIPHER_SUITE_AES_CMAC:
1203                         pval = AES_ENABLED;
1204                         break;
1205                 default:
1206                         WL_ERR("invalid cipher pairwise (%d)\n",
1207                                sme->crypto.ciphers_pairwise[0]);
1208                         return -EINVAL;
1209                 }
1210         }
1211         if (sme->crypto.cipher_group) {
1212                 switch (sme->crypto.cipher_group) {
1213                 case WLAN_CIPHER_SUITE_WEP40:
1214                 case WLAN_CIPHER_SUITE_WEP104:
1215                         gval = WEP_ENABLED;
1216                         break;
1217                 case WLAN_CIPHER_SUITE_TKIP:
1218                         gval = TKIP_ENABLED;
1219                         break;
1220                 case WLAN_CIPHER_SUITE_CCMP:
1221                         gval = AES_ENABLED;
1222                         break;
1223                 case WLAN_CIPHER_SUITE_AES_CMAC:
1224                         gval = AES_ENABLED;
1225                         break;
1226                 default:
1227                         WL_ERR("invalid cipher group (%d)\n",
1228                                sme->crypto.cipher_group);
1229                         return -EINVAL;
1230                 }
1231         }
1232
1233         WL_CONN("pval (%d) gval (%d)\n", pval, gval);
1234         err = brcmf_dev_intvar_set(dev, "wsec", pval | gval);
1235         if (unlikely(err)) {
1236                 WL_ERR("error (%d)\n", err);
1237                 return err;
1238         }
1239
1240         sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1241         sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1242         sec->cipher_group = sme->crypto.cipher_group;
1243
1244         return err;
1245 }
1246
1247 static s32
1248 brcmf_set_key_mgmt(struct net_device *dev, struct cfg80211_connect_params *sme)
1249 {
1250         struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
1251         struct brcmf_cfg80211_security *sec;
1252         s32 val = 0;
1253         s32 err = 0;
1254
1255         if (sme->crypto.n_akm_suites) {
1256                 err = brcmf_dev_intvar_get(dev, "wpa_auth", &val);
1257                 if (unlikely(err)) {
1258                         WL_ERR("could not get wpa_auth (%d)\n", err);
1259                         return err;
1260                 }
1261                 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1262                         switch (sme->crypto.akm_suites[0]) {
1263                         case WLAN_AKM_SUITE_8021X:
1264                                 val = WPA_AUTH_UNSPECIFIED;
1265                                 break;
1266                         case WLAN_AKM_SUITE_PSK:
1267                                 val = WPA_AUTH_PSK;
1268                                 break;
1269                         default:
1270                                 WL_ERR("invalid cipher group (%d)\n",
1271                                        sme->crypto.cipher_group);
1272                                 return -EINVAL;
1273                         }
1274                 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1275                         switch (sme->crypto.akm_suites[0]) {
1276                         case WLAN_AKM_SUITE_8021X:
1277                                 val = WPA2_AUTH_UNSPECIFIED;
1278                                 break;
1279                         case WLAN_AKM_SUITE_PSK:
1280                                 val = WPA2_AUTH_PSK;
1281                                 break;
1282                         default:
1283                                 WL_ERR("invalid cipher group (%d)\n",
1284                                        sme->crypto.cipher_group);
1285                                 return -EINVAL;
1286                         }
1287                 }
1288
1289                 WL_CONN("setting wpa_auth to %d\n", val);
1290                 err = brcmf_dev_intvar_set(dev, "wpa_auth", val);
1291                 if (unlikely(err)) {
1292                         WL_ERR("could not set wpa_auth (%d)\n", err);
1293                         return err;
1294                 }
1295         }
1296         sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1297         sec->wpa_auth = sme->crypto.akm_suites[0];
1298
1299         return err;
1300 }
1301
1302 static s32
1303 brcmf_set_set_sharedkey(struct net_device *dev,
1304                      struct cfg80211_connect_params *sme)
1305 {
1306         struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
1307         struct brcmf_cfg80211_security *sec;
1308         struct brcmf_wsec_key key;
1309         s32 val;
1310         s32 err = 0;
1311
1312         WL_CONN("key len (%d)\n", sme->key_len);
1313         if (sme->key_len) {
1314                 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1315                 WL_CONN("wpa_versions 0x%x cipher_pairwise 0x%x\n",
1316                        sec->wpa_versions, sec->cipher_pairwise);
1317                 if (!
1318                     (sec->wpa_versions & (NL80211_WPA_VERSION_1 |
1319                                           NL80211_WPA_VERSION_2))
1320 && (sec->cipher_pairwise & (WLAN_CIPHER_SUITE_WEP40 |
1321                             WLAN_CIPHER_SUITE_WEP104))) {
1322                         memset(&key, 0, sizeof(key));
1323                         key.len = (u32) sme->key_len;
1324                         key.index = (u32) sme->key_idx;
1325                         if (unlikely(key.len > sizeof(key.data))) {
1326                                 WL_ERR("Too long key length (%u)\n", key.len);
1327                                 return -EINVAL;
1328                         }
1329                         memcpy(key.data, sme->key, key.len);
1330                         key.flags = BRCMF_PRIMARY_KEY;
1331                         switch (sec->cipher_pairwise) {
1332                         case WLAN_CIPHER_SUITE_WEP40:
1333                                 key.algo = CRYPTO_ALGO_WEP1;
1334                                 break;
1335                         case WLAN_CIPHER_SUITE_WEP104:
1336                                 key.algo = CRYPTO_ALGO_WEP128;
1337                                 break;
1338                         default:
1339                                 WL_ERR("Invalid algorithm (%d)\n",
1340                                        sme->crypto.ciphers_pairwise[0]);
1341                                 return -EINVAL;
1342                         }
1343                         /* Set the new key/index */
1344                         WL_CONN("key length (%d) key index (%d) algo (%d)\n",
1345                                key.len, key.index, key.algo);
1346                         WL_CONN("key \"%s\"\n", key.data);
1347                         convert_key_from_CPU(&key);
1348                         err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY, &key,
1349                                         sizeof(key));
1350                         if (unlikely(err)) {
1351                                 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1352                                 return err;
1353                         }
1354                         if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
1355                                 WL_CONN("set auth_type to shared key\n");
1356                                 val = 1;        /* shared key */
1357                                 err = brcmf_dev_intvar_set(dev, "auth", val);
1358                                 if (unlikely(err)) {
1359                                         WL_ERR("set auth failed (%d)\n", err);
1360                                         return err;
1361                                 }
1362                         }
1363                 }
1364         }
1365         return err;
1366 }
1367
1368 static s32
1369 brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
1370                     struct cfg80211_connect_params *sme)
1371 {
1372         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1373         struct ieee80211_channel *chan = sme->channel;
1374         struct brcmf_join_params join_params;
1375         size_t join_params_size;
1376
1377         s32 err = 0;
1378
1379         WL_TRACE("Enter\n");
1380         CHECK_SYS_UP();
1381
1382         if (unlikely(!sme->ssid)) {
1383                 WL_ERR("Invalid ssid\n");
1384                 return -EOPNOTSUPP;
1385         }
1386
1387         set_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1388
1389         if (chan) {
1390                 cfg_priv->channel =
1391                         ieee80211_frequency_to_channel(chan->center_freq);
1392                 WL_CONN("channel (%d), center_req (%d)\n",
1393                                 cfg_priv->channel, chan->center_freq);
1394         } else
1395                 cfg_priv->channel = 0;
1396
1397         WL_INFO("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1398
1399         err = brcmf_set_wpa_version(dev, sme);
1400         if (err) {
1401                 WL_ERR("wl_set_wpa_version failed (%d)\n", err);
1402                 goto done;
1403         }
1404
1405         err = brcmf_set_auth_type(dev, sme);
1406         if (err) {
1407                 WL_ERR("wl_set_auth_type failed (%d)\n", err);
1408                 goto done;
1409         }
1410
1411         err = brcmf_set_set_cipher(dev, sme);
1412         if (err) {
1413                 WL_ERR("wl_set_set_cipher failed (%d)\n", err);
1414                 goto done;
1415         }
1416
1417         err = brcmf_set_key_mgmt(dev, sme);
1418         if (err) {
1419                 WL_ERR("wl_set_key_mgmt failed (%d)\n", err);
1420                 goto done;
1421         }
1422
1423         err = brcmf_set_set_sharedkey(dev, sme);
1424         if (err) {
1425                 WL_ERR("wl_set_set_sharedkey failed (%d)\n", err);
1426                 goto done;
1427         }
1428
1429         memset(&join_params, 0, sizeof(join_params));
1430         join_params_size = sizeof(join_params.ssid);
1431
1432         join_params.ssid.SSID_len =
1433                 min(sizeof(join_params.ssid.SSID), sme->ssid_len);
1434         memcpy(&join_params.ssid.SSID, sme->ssid, join_params.ssid.SSID_len);
1435         join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1436         brcmf_update_prof(cfg_priv, NULL, &join_params.ssid, WL_PROF_SSID);
1437
1438         memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1439
1440         if (join_params.ssid.SSID_len < IEEE80211_MAX_SSID_LEN)
1441                 WL_CONN("ssid \"%s\", len (%d)\n",
1442                        join_params.ssid.SSID, join_params.ssid.SSID_len);
1443
1444         brcmf_ch_to_chanspec(cfg_priv->channel,
1445                              &join_params, &join_params_size);
1446         err = brcmf_dev_ioctl(dev, BRCMF_C_SET_SSID,
1447                            &join_params, join_params_size);
1448         if (err)
1449                 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1450
1451 done:
1452         if (err)
1453                 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1454         WL_TRACE("Exit\n");
1455         return err;
1456 }
1457
1458 static s32
1459 brcmf_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1460                        u16 reason_code)
1461 {
1462         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1463         struct brcmf_scb_val scbval;
1464         s32 err = 0;
1465
1466         WL_TRACE("Enter. Reason code = %d\n", reason_code);
1467         CHECK_SYS_UP();
1468
1469         clear_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
1470
1471         scbval.val = reason_code;
1472         memcpy(&scbval.ea, brcmf_read_prof(cfg_priv, WL_PROF_BSSID), ETH_ALEN);
1473         scbval.val = cpu_to_le32(scbval.val);
1474         err = brcmf_dev_ioctl(dev, BRCMF_C_DISASSOC, &scbval,
1475                         sizeof(struct brcmf_scb_val));
1476         if (unlikely(err))
1477                 WL_ERR("error (%d)\n", err);
1478
1479         cfg_priv->link_up = false;
1480
1481         WL_TRACE("Exit\n");
1482         return err;
1483 }
1484
1485 static s32
1486 brcmf_cfg80211_set_tx_power(struct wiphy *wiphy,
1487                          enum nl80211_tx_power_setting type, s32 dbm)
1488 {
1489
1490         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1491         struct net_device *ndev = cfg_to_ndev(cfg_priv);
1492         u16 txpwrmw;
1493         s32 err = 0;
1494         s32 disable = 0;
1495
1496         WL_TRACE("Enter\n");
1497         CHECK_SYS_UP();
1498
1499         switch (type) {
1500         case NL80211_TX_POWER_AUTOMATIC:
1501                 break;
1502         case NL80211_TX_POWER_LIMITED:
1503                 if (dbm < 0) {
1504                         WL_ERR("TX_POWER_LIMITED - dbm is negative\n");
1505                         err = -EINVAL;
1506                         goto done;
1507                 }
1508                 break;
1509         case NL80211_TX_POWER_FIXED:
1510                 if (dbm < 0) {
1511                         WL_ERR("TX_POWER_FIXED - dbm is negative\n");
1512                         err = -EINVAL;
1513                         goto done;
1514                 }
1515                 break;
1516         }
1517         /* Make sure radio is off or on as far as software is concerned */
1518         disable = WL_RADIO_SW_DISABLE << 16;
1519         disable = cpu_to_le32(disable);
1520         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_RADIO, &disable,
1521                               sizeof(disable));
1522         if (unlikely(err))
1523                 WL_ERR("WLC_SET_RADIO error (%d)\n", err);
1524
1525         if (dbm > 0xffff)
1526                 txpwrmw = 0xffff;
1527         else
1528                 txpwrmw = (u16) dbm;
1529         err = brcmf_dev_intvar_set(ndev, "qtxpower",
1530                         (s32) (brcmu_mw_to_qdbm(txpwrmw)));
1531         if (unlikely(err))
1532                 WL_ERR("qtxpower error (%d)\n", err);
1533         cfg_priv->conf->tx_power = dbm;
1534
1535 done:
1536         WL_TRACE("Exit\n");
1537         return err;
1538 }
1539
1540 static s32 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1541 {
1542         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1543         struct net_device *ndev = cfg_to_ndev(cfg_priv);
1544         s32 txpwrdbm;
1545         u8 result;
1546         s32 err = 0;
1547
1548         WL_TRACE("Enter\n");
1549         CHECK_SYS_UP();
1550
1551         err = brcmf_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1552         if (unlikely(err)) {
1553                 WL_ERR("error (%d)\n", err);
1554                 goto done;
1555         }
1556
1557         result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1558         *dbm = (s32) brcmu_qdbm_to_mw(result);
1559
1560 done:
1561         WL_TRACE("Exit\n");
1562         return err;
1563 }
1564
1565 static s32
1566 brcmf_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
1567                                u8 key_idx, bool unicast, bool multicast)
1568 {
1569         u32 index;
1570         s32 wsec;
1571         s32 err = 0;
1572
1573         WL_TRACE("Enter\n");
1574         WL_CONN("key index (%d)\n", key_idx);
1575         CHECK_SYS_UP();
1576
1577         err = brcmf_dev_ioctl(dev, BRCMF_C_GET_WSEC, &wsec, sizeof(wsec));
1578         if (unlikely(err)) {
1579                 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1580                 goto done;
1581         }
1582
1583         wsec = le32_to_cpu(wsec);
1584         if (wsec & WEP_ENABLED) {
1585                 /* Just select a new current key */
1586                 index = (u32) key_idx;
1587                 index = cpu_to_le32(index);
1588                 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY_PRIMARY, &index,
1589                                 sizeof(index));
1590                 if (unlikely(err))
1591                         WL_ERR("error (%d)\n", err);
1592         }
1593 done:
1594         WL_TRACE("Exit\n");
1595         return err;
1596 }
1597
1598 static s32
1599 brcmf_add_keyext(struct wiphy *wiphy, struct net_device *dev,
1600               u8 key_idx, const u8 *mac_addr, struct key_params *params)
1601 {
1602         struct brcmf_wsec_key key;
1603         s32 err = 0;
1604
1605         memset(&key, 0, sizeof(key));
1606         key.index = (u32) key_idx;
1607         /* Instead of bcast for ea address for default wep keys,
1608                  driver needs it to be Null */
1609         if (!is_multicast_ether_addr(mac_addr))
1610                 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1611         key.len = (u32) params->key_len;
1612         /* check for key index change */
1613         if (key.len == 0) {
1614                 /* key delete */
1615                 convert_key_from_CPU(&key);
1616                 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1617                 if (unlikely(err)) {
1618                         WL_ERR("key delete error (%d)\n", err);
1619                         return err;
1620                 }
1621         } else {
1622                 if (key.len > sizeof(key.data)) {
1623                         WL_ERR("Invalid key length (%d)\n", key.len);
1624                         return -EINVAL;
1625                 }
1626
1627                 WL_CONN("Setting the key index %d\n", key.index);
1628                 memcpy(key.data, params->key, key.len);
1629
1630                 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1631                         u8 keybuf[8];
1632                         memcpy(keybuf, &key.data[24], sizeof(keybuf));
1633                         memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1634                         memcpy(&key.data[16], keybuf, sizeof(keybuf));
1635                 }
1636
1637                 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1638                 if (params->seq && params->seq_len == 6) {
1639                         /* rx iv */
1640                         u8 *ivptr;
1641                         ivptr = (u8 *) params->seq;
1642                         key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1643                             (ivptr[3] << 8) | ivptr[2];
1644                         key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1645                         key.iv_initialized = true;
1646                 }
1647
1648                 switch (params->cipher) {
1649                 case WLAN_CIPHER_SUITE_WEP40:
1650                         key.algo = CRYPTO_ALGO_WEP1;
1651                         WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1652                         break;
1653                 case WLAN_CIPHER_SUITE_WEP104:
1654                         key.algo = CRYPTO_ALGO_WEP128;
1655                         WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1656                         break;
1657                 case WLAN_CIPHER_SUITE_TKIP:
1658                         key.algo = CRYPTO_ALGO_TKIP;
1659                         WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1660                         break;
1661                 case WLAN_CIPHER_SUITE_AES_CMAC:
1662                         key.algo = CRYPTO_ALGO_AES_CCM;
1663                         WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1664                         break;
1665                 case WLAN_CIPHER_SUITE_CCMP:
1666                         key.algo = CRYPTO_ALGO_AES_CCM;
1667                         WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1668                         break;
1669                 default:
1670                         WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1671                         return -EINVAL;
1672                 }
1673                 convert_key_from_CPU(&key);
1674
1675                 brcmf_netdev_wait_pend8021x(dev);
1676                 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1677                 if (unlikely(err)) {
1678                         WL_ERR("WLC_SET_KEY error (%d)\n", err);
1679                         return err;
1680                 }
1681         }
1682         return err;
1683 }
1684
1685 static s32
1686 brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
1687                     u8 key_idx, bool pairwise, const u8 *mac_addr,
1688                     struct key_params *params)
1689 {
1690         struct brcmf_wsec_key key;
1691         s32 val;
1692         s32 wsec;
1693         s32 err = 0;
1694         u8 keybuf[8];
1695
1696         WL_TRACE("Enter\n");
1697         WL_CONN("key index (%d)\n", key_idx);
1698         CHECK_SYS_UP();
1699
1700         if (mac_addr) {
1701                 WL_TRACE("Exit");
1702                 return brcmf_add_keyext(wiphy, dev, key_idx, mac_addr, params);
1703         }
1704         memset(&key, 0, sizeof(key));
1705
1706         key.len = (u32) params->key_len;
1707         key.index = (u32) key_idx;
1708
1709         if (unlikely(key.len > sizeof(key.data))) {
1710                 WL_ERR("Too long key length (%u)\n", key.len);
1711                 err = -EINVAL;
1712                 goto done;
1713         }
1714         memcpy(key.data, params->key, key.len);
1715
1716         key.flags = BRCMF_PRIMARY_KEY;
1717         switch (params->cipher) {
1718         case WLAN_CIPHER_SUITE_WEP40:
1719                 key.algo = CRYPTO_ALGO_WEP1;
1720                 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1721                 break;
1722         case WLAN_CIPHER_SUITE_WEP104:
1723                 key.algo = CRYPTO_ALGO_WEP128;
1724                 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1725                 break;
1726         case WLAN_CIPHER_SUITE_TKIP:
1727                 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1728                 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1729                 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1730                 key.algo = CRYPTO_ALGO_TKIP;
1731                 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1732                 break;
1733         case WLAN_CIPHER_SUITE_AES_CMAC:
1734                 key.algo = CRYPTO_ALGO_AES_CCM;
1735                 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1736                 break;
1737         case WLAN_CIPHER_SUITE_CCMP:
1738                 key.algo = CRYPTO_ALGO_AES_CCM;
1739                 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1740                 break;
1741         default:
1742                 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1743                 err = -EINVAL;
1744                 goto done;
1745         }
1746
1747         /* Set the new key/index */
1748         convert_key_from_CPU(&key);
1749         err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1750         if (unlikely(err)) {
1751                 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1752                 goto done;
1753         }
1754
1755         val = WEP_ENABLED;
1756         err = brcmf_dev_intvar_get(dev, "wsec", &wsec);
1757         if (unlikely(err)) {
1758                 WL_ERR("get wsec error (%d)\n", err);
1759                 goto done;
1760         }
1761         wsec &= ~(WEP_ENABLED);
1762         wsec |= val;
1763         err = brcmf_dev_intvar_set(dev, "wsec", wsec);
1764         if (unlikely(err)) {
1765                 WL_ERR("set wsec error (%d)\n", err);
1766                 goto done;
1767         }
1768
1769         val = 1;                /* assume shared key. otherwise 0 */
1770         val = cpu_to_le32(val);
1771         err = brcmf_dev_ioctl(dev, BRCMF_C_SET_AUTH, &val, sizeof(val));
1772         if (unlikely(err))
1773                 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1774 done:
1775         WL_TRACE("Exit\n");
1776         return err;
1777 }
1778
1779 static s32
1780 brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
1781                     u8 key_idx, bool pairwise, const u8 *mac_addr)
1782 {
1783         struct brcmf_wsec_key key;
1784         s32 err = 0;
1785         s32 val;
1786         s32 wsec;
1787
1788         WL_TRACE("Enter\n");
1789         CHECK_SYS_UP();
1790         memset(&key, 0, sizeof(key));
1791
1792         key.index = (u32) key_idx;
1793         key.flags = BRCMF_PRIMARY_KEY;
1794         key.algo = CRYPTO_ALGO_OFF;
1795
1796         WL_CONN("key index (%d)\n", key_idx);
1797         /* Set the new key/index */
1798         convert_key_from_CPU(&key);
1799         err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1800         if (unlikely(err)) {
1801                 if (err == -EINVAL) {
1802                         if (key.index >= DOT11_MAX_DEFAULT_KEYS)
1803                                 /* we ignore this key index in this case */
1804                                 WL_ERR("invalid key index (%d)\n", key_idx);
1805                 } else
1806                         WL_ERR("WLC_SET_KEY error (%d)\n", err);
1807
1808                 /* Ignore this error, may happen during DISASSOC */
1809                 err = -EAGAIN;
1810                 goto done;
1811         }
1812
1813         val = 0;
1814         err = brcmf_dev_intvar_get(dev, "wsec", &wsec);
1815         if (unlikely(err)) {
1816                 WL_ERR("get wsec error (%d)\n", err);
1817                 /* Ignore this error, may happen during DISASSOC */
1818                 err = -EAGAIN;
1819                 goto done;
1820         }
1821         wsec &= ~(WEP_ENABLED);
1822         wsec |= val;
1823         err = brcmf_dev_intvar_set(dev, "wsec", wsec);
1824         if (unlikely(err)) {
1825                 WL_ERR("set wsec error (%d)\n", err);
1826                 /* Ignore this error, may happen during DISASSOC */
1827                 err = -EAGAIN;
1828                 goto done;
1829         }
1830
1831         val = 0;                /* assume open key. otherwise 1 */
1832         val = cpu_to_le32(val);
1833         err = brcmf_dev_ioctl(dev, BRCMF_C_SET_AUTH, &val, sizeof(val));
1834         if (unlikely(err)) {
1835                 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1836                 /* Ignore this error, may happen during DISASSOC */
1837                 err = -EAGAIN;
1838         }
1839 done:
1840         WL_TRACE("Exit\n");
1841         return err;
1842 }
1843
1844 static s32
1845 brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
1846                     u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
1847                     void (*callback) (void *cookie, struct key_params * params))
1848 {
1849         struct key_params params;
1850         struct brcmf_wsec_key key;
1851         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1852         struct brcmf_cfg80211_security *sec;
1853         s32 wsec;
1854         s32 err = 0;
1855
1856         WL_TRACE("Enter\n");
1857         WL_CONN("key index (%d)\n", key_idx);
1858         CHECK_SYS_UP();
1859
1860         memset(&key, 0, sizeof(key));
1861         key.index = key_idx;
1862         convert_key_to_CPU(&key);
1863         memset(&params, 0, sizeof(params));
1864         params.key_len = (u8) min_t(u8, WLAN_MAX_KEY_LEN, key.len);
1865         memcpy(params.key, key.data, params.key_len);
1866
1867         err = brcmf_dev_ioctl(dev, BRCMF_C_GET_WSEC, &wsec, sizeof(wsec));
1868         if (unlikely(err)) {
1869                 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1870                 /* Ignore this error, may happen during DISASSOC */
1871                 err = -EAGAIN;
1872                 goto done;
1873         }
1874         wsec = le32_to_cpu(wsec);
1875         switch (wsec) {
1876         case WEP_ENABLED:
1877                 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1878                 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1879                         params.cipher = WLAN_CIPHER_SUITE_WEP40;
1880                         WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1881                 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1882                         params.cipher = WLAN_CIPHER_SUITE_WEP104;
1883                         WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1884                 }
1885                 break;
1886         case TKIP_ENABLED:
1887                 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1888                 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1889                 break;
1890         case AES_ENABLED:
1891                 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1892                 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1893                 break;
1894         default:
1895                 WL_ERR("Invalid algo (0x%x)\n", wsec);
1896                 err = -EINVAL;
1897                 goto done;
1898         }
1899         callback(cookie, &params);
1900
1901 done:
1902         WL_TRACE("Exit\n");
1903         return err;
1904 }
1905
1906 static s32
1907 brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1908                                     struct net_device *dev, u8 key_idx)
1909 {
1910         WL_INFO("Not supported\n");
1911
1912         CHECK_SYS_UP();
1913         return -EOPNOTSUPP;
1914 }
1915
1916 static s32
1917 brcmf_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
1918                         u8 *mac, struct station_info *sinfo)
1919 {
1920         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1921         struct brcmf_scb_val scb_val;
1922         int rssi;
1923         s32 rate;
1924         s32 err = 0;
1925         u8 *bssid = brcmf_read_prof(cfg_priv, WL_PROF_BSSID);
1926
1927         WL_TRACE("Enter\n");
1928         CHECK_SYS_UP();
1929
1930         if (unlikely
1931             (memcmp(mac, bssid, ETH_ALEN))) {
1932                 WL_ERR("Wrong Mac address cfg_mac-%X:%X:%X:%X:%X:%X"
1933                         "wl_bssid-%X:%X:%X:%X:%X:%X\n",
1934                         mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
1935                         bssid[0], bssid[1], bssid[2], bssid[3],
1936                         bssid[4], bssid[5]);
1937                 err = -ENOENT;
1938                 goto done;
1939         }
1940
1941         /* Report the current tx rate */
1942         err = brcmf_dev_ioctl(dev, BRCMF_C_GET_RATE, &rate, sizeof(rate));
1943         if (err) {
1944                 WL_ERR("Could not get rate (%d)\n", err);
1945         } else {
1946                 rate = le32_to_cpu(rate);
1947                 sinfo->filled |= STATION_INFO_TX_BITRATE;
1948                 sinfo->txrate.legacy = rate * 5;
1949                 WL_CONN("Rate %d Mbps\n", rate / 2);
1950         }
1951
1952         if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status)) {
1953                 scb_val.val = 0;
1954                 err = brcmf_dev_ioctl(dev, BRCMF_C_GET_RSSI, &scb_val,
1955                                 sizeof(struct brcmf_scb_val));
1956                 if (unlikely(err))
1957                         WL_ERR("Could not get rssi (%d)\n", err);
1958
1959                 rssi = le32_to_cpu(scb_val.val);
1960                 sinfo->filled |= STATION_INFO_SIGNAL;
1961                 sinfo->signal = rssi;
1962                 WL_CONN("RSSI %d dBm\n", rssi);
1963         }
1964
1965 done:
1966         WL_TRACE("Exit\n");
1967         return err;
1968 }
1969
1970 static s32
1971 brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1972                            bool enabled, s32 timeout)
1973 {
1974         s32 pm;
1975         s32 err = 0;
1976         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1977
1978         WL_TRACE("Enter\n");
1979
1980         /*
1981          * Powersave enable/disable request is coming from the
1982          * cfg80211 even before the interface is up. In that
1983          * scenario, driver will be storing the power save
1984          * preference in cfg_priv struct to apply this to
1985          * FW later while initializing the dongle
1986          */
1987         cfg_priv->pwr_save = enabled;
1988         if (!test_bit(WL_STATUS_READY, &cfg_priv->status)) {
1989
1990                 WL_INFO("Device is not ready,"
1991                         "storing the value in cfg_priv struct\n");
1992                 goto done;
1993         }
1994
1995         pm = enabled ? PM_FAST : PM_OFF;
1996         pm = cpu_to_le32(pm);
1997         WL_INFO("power save %s\n", (pm ? "enabled" : "disabled"));
1998
1999         err = brcmf_dev_ioctl(dev, BRCMF_C_SET_PM, &pm, sizeof(pm));
2000         if (unlikely(err)) {
2001                 if (err == -ENODEV)
2002                         WL_ERR("net_device is not ready yet\n");
2003                 else
2004                         WL_ERR("error (%d)\n", err);
2005         }
2006 done:
2007         WL_TRACE("Exit\n");
2008         return err;
2009 }
2010
2011 static __used u32 brcmf_find_msb(u16 bit16)
2012 {
2013         u32 ret = 0;
2014
2015         if (bit16 & 0xff00) {
2016                 ret += 8;
2017                 bit16 >>= 8;
2018         }
2019
2020         if (bit16 & 0xf0) {
2021                 ret += 4;
2022                 bit16 >>= 4;
2023         }
2024
2025         if (bit16 & 0xc) {
2026                 ret += 2;
2027                 bit16 >>= 2;
2028         }
2029
2030         if (bit16 & 2)
2031                 ret += bit16 & 2;
2032         else if (bit16)
2033                 ret += bit16;
2034
2035         return ret;
2036 }
2037
2038 static s32
2039 brcmf_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
2040                              const u8 *addr,
2041                              const struct cfg80211_bitrate_mask *mask)
2042 {
2043         struct brcm_rateset rateset;
2044         s32 rate;
2045         s32 val;
2046         s32 err_bg;
2047         s32 err_a;
2048         u32 legacy;
2049         s32 err = 0;
2050
2051         WL_TRACE("Enter\n");
2052         CHECK_SYS_UP();
2053
2054         /* addr param is always NULL. ignore it */
2055         /* Get current rateset */
2056         err = brcmf_dev_ioctl(dev, BRCM_GET_CURR_RATESET, &rateset,
2057                         sizeof(rateset));
2058         if (unlikely(err)) {
2059                 WL_ERR("could not get current rateset (%d)\n", err);
2060                 goto done;
2061         }
2062
2063         rateset.count = le32_to_cpu(rateset.count);
2064
2065         legacy = brcmf_find_msb(mask->control[IEEE80211_BAND_2GHZ].legacy);
2066         if (!legacy)
2067                 legacy = brcmf_find_msb(
2068                                 mask->control[IEEE80211_BAND_5GHZ].legacy);
2069
2070         val = wl_g_rates[legacy - 1].bitrate * 100000;
2071
2072         if (val < rateset.count)
2073                 /* Select rate by rateset index */
2074                 rate = rateset.rates[val] & 0x7f;
2075         else
2076                 /* Specified rate in bps */
2077                 rate = val / 500000;
2078
2079         WL_CONN("rate %d mbps\n", rate / 2);
2080
2081         /*
2082          *
2083          *      Set rate override,
2084          *      Since the is a/b/g-blind, both a/bg_rate are enforced.
2085          */
2086         err_bg = brcmf_dev_intvar_set(dev, "bg_rate", rate);
2087         err_a = brcmf_dev_intvar_set(dev, "a_rate", rate);
2088         if (unlikely(err_bg && err_a)) {
2089                 WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
2090                 err = err_bg | err_a;
2091         }
2092
2093 done:
2094         WL_TRACE("Exit\n");
2095         return err;
2096 }
2097
2098 static s32 brcmf_cfg80211_resume(struct wiphy *wiphy)
2099 {
2100         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2101
2102         /*
2103          * Check for WL_STATUS_READY before any function call which
2104          * could result is bus access. Don't block the resume for
2105          * any driver error conditions
2106          */
2107         WL_TRACE("Enter\n");
2108
2109         if (test_bit(WL_STATUS_READY, &cfg_priv->status))
2110                 brcmf_invoke_iscan(wiphy_to_cfg(wiphy));
2111
2112         WL_TRACE("Exit\n");
2113         return 0;
2114 }
2115
2116 static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
2117                                   struct cfg80211_wowlan *wow)
2118 {
2119         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2120         struct net_device *ndev = cfg_to_ndev(cfg_priv);
2121
2122         WL_TRACE("Enter\n");
2123
2124         /*
2125          * Check for WL_STATUS_READY before any function call which
2126          * could result is bus access. Don't block the suspend for
2127          * any driver error conditions
2128          */
2129
2130         /*
2131          * While going to suspend if associated with AP disassociate
2132          * from AP to save power while system is in suspended state
2133          */
2134         if ((test_bit(WL_STATUS_CONNECTED, &cfg_priv->status) ||
2135              test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) &&
2136              test_bit(WL_STATUS_READY, &cfg_priv->status)) {
2137                 WL_INFO("Disassociating from AP"
2138                         " while entering suspend state\n");
2139                 brcmf_link_down(cfg_priv);
2140
2141                 /*
2142                  * Make sure WPA_Supplicant receives all the event
2143                  * generated due to DISASSOC call to the fw to keep
2144                  * the state fw and WPA_Supplicant state consistent
2145                  */
2146                 rtnl_unlock();
2147                 brcmf_delay(500);
2148                 rtnl_lock();
2149         }
2150
2151         set_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
2152         if (test_bit(WL_STATUS_READY, &cfg_priv->status))
2153                 brcmf_term_iscan(cfg_priv);
2154
2155         if (cfg_priv->scan_request) {
2156                 /* Indidate scan abort to cfg80211 layer */
2157                 WL_INFO("Terminating scan in progress\n");
2158                 cfg80211_scan_done(cfg_priv->scan_request, true);
2159                 cfg_priv->scan_request = NULL;
2160         }
2161         clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
2162         clear_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
2163
2164         /* Turn off watchdog timer */
2165         if (test_bit(WL_STATUS_READY, &cfg_priv->status)) {
2166                 WL_INFO("Enable MPC\n");
2167                 brcmf_set_mpc(ndev, 1);
2168         }
2169
2170         WL_TRACE("Exit\n");
2171
2172         return 0;
2173 }
2174
2175 static __used s32
2176 brcmf_update_pmklist(struct net_device *dev,
2177                      struct brcmf_cfg80211_pmk_list *pmk_list, s32 err)
2178 {
2179         int i, j;
2180
2181         WL_CONN("No of elements %d\n", pmk_list->pmkids.npmkid);
2182         for (i = 0; i < pmk_list->pmkids.npmkid; i++) {
2183                 WL_CONN("PMKID[%d]: %pM =\n", i,
2184                         &pmk_list->pmkids.pmkid[i].BSSID);
2185                 for (j = 0; j < WLAN_PMKID_LEN; j++)
2186                         WL_CONN("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
2187         }
2188
2189         if (likely(!err))
2190                 brcmf_dev_bufvar_set(dev, "pmkid_info", (char *)pmk_list,
2191                                         sizeof(*pmk_list));
2192
2193         return err;
2194 }
2195
2196 static s32
2197 brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
2198                          struct cfg80211_pmksa *pmksa)
2199 {
2200         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2201         struct pmkid_list *pmkids = &cfg_priv->pmk_list->pmkids;
2202         s32 err = 0;
2203         int i;
2204
2205         WL_TRACE("Enter\n");
2206         CHECK_SYS_UP();
2207
2208         for (i = 0; i < pmkids->npmkid; i++)
2209                 if (!memcmp(pmksa->bssid, pmkids->pmkid[i].BSSID, ETH_ALEN))
2210                         break;
2211         if (i < WL_NUM_PMKIDS_MAX) {
2212                 memcpy(pmkids->pmkid[i].BSSID, pmksa->bssid, ETH_ALEN);
2213                 memcpy(pmkids->pmkid[i].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2214                 if (i == pmkids->npmkid)
2215                         pmkids->npmkid++;
2216         } else
2217                 err = -EINVAL;
2218
2219         WL_CONN("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
2220                 pmkids->pmkid[pmkids->npmkid].BSSID);
2221         for (i = 0; i < WLAN_PMKID_LEN; i++)
2222                 WL_CONN("%02x\n", pmkids->pmkid[pmkids->npmkid].PMKID[i]);
2223
2224         err = brcmf_update_pmklist(dev, cfg_priv->pmk_list, err);
2225
2226         WL_TRACE("Exit\n");
2227         return err;
2228 }
2229
2230 static s32
2231 brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
2232                       struct cfg80211_pmksa *pmksa)
2233 {
2234         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2235         struct pmkid_list pmkid;
2236         s32 err = 0;
2237         int i;
2238
2239         WL_TRACE("Enter\n");
2240         CHECK_SYS_UP();
2241         memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2242         memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2243
2244         WL_CONN("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2245                &pmkid.pmkid[0].BSSID);
2246         for (i = 0; i < WLAN_PMKID_LEN; i++)
2247                 WL_CONN("%02x\n", pmkid.pmkid[0].PMKID[i]);
2248
2249         for (i = 0; i < cfg_priv->pmk_list->pmkids.npmkid; i++)
2250                 if (!memcmp
2251                     (pmksa->bssid, &cfg_priv->pmk_list->pmkids.pmkid[i].BSSID,
2252                      ETH_ALEN))
2253                         break;
2254
2255         if ((cfg_priv->pmk_list->pmkids.npmkid > 0)
2256             && (i < cfg_priv->pmk_list->pmkids.npmkid)) {
2257                 memset(&cfg_priv->pmk_list->pmkids.pmkid[i], 0,
2258                        sizeof(struct pmkid));
2259                 for (; i < (cfg_priv->pmk_list->pmkids.npmkid - 1); i++) {
2260                         memcpy(&cfg_priv->pmk_list->pmkids.pmkid[i].BSSID,
2261                                &cfg_priv->pmk_list->pmkids.pmkid[i + 1].BSSID,
2262                                ETH_ALEN);
2263                         memcpy(&cfg_priv->pmk_list->pmkids.pmkid[i].PMKID,
2264                                &cfg_priv->pmk_list->pmkids.pmkid[i + 1].PMKID,
2265                                WLAN_PMKID_LEN);
2266                 }
2267                 cfg_priv->pmk_list->pmkids.npmkid--;
2268         } else
2269                 err = -EINVAL;
2270
2271         err = brcmf_update_pmklist(dev, cfg_priv->pmk_list, err);
2272
2273         WL_TRACE("Exit\n");
2274         return err;
2275
2276 }
2277
2278 static s32
2279 brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *dev)
2280 {
2281         struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2282         s32 err = 0;
2283
2284         WL_TRACE("Enter\n");
2285         CHECK_SYS_UP();
2286
2287         memset(cfg_priv->pmk_list, 0, sizeof(*cfg_priv->pmk_list));
2288         err = brcmf_update_pmklist(dev, cfg_priv->pmk_list, err);
2289
2290         WL_TRACE("Exit\n");
2291         return err;
2292
2293 }
2294
2295 static struct cfg80211_ops wl_cfg80211_ops = {
2296         .change_virtual_intf = brcmf_cfg80211_change_iface,
2297         .scan = brcmf_cfg80211_scan,
2298         .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
2299         .join_ibss = brcmf_cfg80211_join_ibss,
2300         .leave_ibss = brcmf_cfg80211_leave_ibss,
2301         .get_station = brcmf_cfg80211_get_station,
2302         .set_tx_power = brcmf_cfg80211_set_tx_power,
2303         .get_tx_power = brcmf_cfg80211_get_tx_power,
2304         .add_key = brcmf_cfg80211_add_key,
2305         .del_key = brcmf_cfg80211_del_key,
2306         .get_key = brcmf_cfg80211_get_key,
2307         .set_default_key = brcmf_cfg80211_config_default_key,
2308         .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
2309         .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
2310         .set_bitrate_mask = brcmf_cfg80211_set_bitrate_mask,
2311         .connect = brcmf_cfg80211_connect,
2312         .disconnect = brcmf_cfg80211_disconnect,
2313         .suspend = brcmf_cfg80211_suspend,
2314         .resume = brcmf_cfg80211_resume,
2315         .set_pmksa = brcmf_cfg80211_set_pmksa,
2316         .del_pmksa = brcmf_cfg80211_del_pmksa,
2317         .flush_pmksa = brcmf_cfg80211_flush_pmksa
2318 };
2319
2320 static s32 brcmf_mode_to_nl80211_iftype(s32 mode)
2321 {
2322         s32 err = 0;
2323
2324         switch (mode) {
2325         case WL_MODE_BSS:
2326                 return NL80211_IFTYPE_STATION;
2327         case WL_MODE_IBSS:
2328                 return NL80211_IFTYPE_ADHOC;
2329         default:
2330                 return NL80211_IFTYPE_UNSPECIFIED;
2331         }
2332
2333         return err;
2334 }
2335
2336 static struct wireless_dev *brcmf_alloc_wdev(s32 sizeof_iface,
2337                                           struct device *dev)
2338 {
2339         struct wireless_dev *wdev;
2340         s32 err = 0;
2341
2342         wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2343         if (unlikely(!wdev)) {
2344                 WL_ERR("Could not allocate wireless device\n");
2345                 return ERR_PTR(-ENOMEM);
2346         }
2347         wdev->wiphy =
2348             wiphy_new(&wl_cfg80211_ops,
2349                       sizeof(struct brcmf_cfg80211_priv) + sizeof_iface);
2350         if (unlikely(!wdev->wiphy)) {
2351                 WL_ERR("Couldn not allocate wiphy device\n");
2352                 err = -ENOMEM;
2353                 goto wiphy_new_out;
2354         }
2355         set_wiphy_dev(wdev->wiphy, dev);
2356         wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2357         wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2358         wdev->wiphy->interface_modes =
2359             BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2360         wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2361         wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a;    /* Set
2362                                                 * it as 11a by default.
2363                                                 * This will be updated with
2364                                                 * 11n phy tables in
2365                                                 * "ifconfig up"
2366                                                 * if phy has 11n capability
2367                                                 */
2368         wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2369         wdev->wiphy->cipher_suites = __wl_cipher_suites;
2370         wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2371 #ifndef WL_POWERSAVE_DISABLED
2372         wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT;      /* enable power
2373                                                                  * save mode
2374                                                                  * by default
2375                                                                  */
2376 #else
2377         wdev->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
2378 #endif                          /* !WL_POWERSAVE_DISABLED */
2379         err = wiphy_register(wdev->wiphy);
2380         if (unlikely(err < 0)) {
2381                 WL_ERR("Couldn not register wiphy device (%d)\n", err);
2382                 goto wiphy_register_out;
2383         }
2384         return wdev;
2385
2386 wiphy_register_out:
2387         wiphy_free(wdev->wiphy);
2388
2389 wiphy_new_out:
2390         kfree(wdev);
2391
2392         return ERR_PTR(err);
2393 }
2394
2395 static void brcmf_free_wdev(struct brcmf_cfg80211_priv *cfg_priv)
2396 {
2397         struct wireless_dev *wdev = cfg_to_wdev(cfg_priv);
2398
2399         if (unlikely(!wdev)) {
2400                 WL_ERR("wdev is invalid\n");
2401                 return;
2402         }
2403         wiphy_unregister(wdev->wiphy);
2404         wiphy_free(wdev->wiphy);
2405         kfree(wdev);
2406         cfg_to_wdev(cfg_priv) = NULL;
2407 }
2408
2409 static s32 brcmf_inform_bss(struct brcmf_cfg80211_priv *cfg_priv)
2410 {
2411         struct brcmf_scan_results *bss_list;
2412         struct brcmf_bss_info *bi = NULL;       /* must be initialized */
2413         s32 err = 0;
2414         int i;
2415
2416         bss_list = cfg_priv->bss_list;
2417         if (unlikely(bss_list->version != BRCMF_BSS_INFO_VERSION)) {
2418                 WL_ERR("Version %d != WL_BSS_INFO_VERSION\n",
2419                        bss_list->version);
2420                 return -EOPNOTSUPP;
2421         }
2422         WL_SCAN("scanned AP count (%d)\n", bss_list->count);
2423         bi = next_bss(bss_list, bi);
2424         for_each_bss(bss_list, bi, i) {
2425                 err = brcmf_inform_single_bss(cfg_priv, bi);
2426                 if (unlikely(err))
2427                         break;
2428         }
2429         return err;
2430 }
2431
2432
2433 static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_priv *cfg_priv,
2434                                    struct brcmf_bss_info *bi)
2435 {
2436         struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2437         struct ieee80211_channel *notify_channel;
2438         struct cfg80211_bss *bss;
2439         struct ieee80211_supported_band *band;
2440         s32 err = 0;
2441         u16 channel;
2442         u32 freq;
2443         u64 notify_timestamp;
2444         u16 notify_capability;
2445         u16 notify_interval;
2446         u8 *notify_ie;
2447         size_t notify_ielen;
2448         s32 notify_signal;
2449
2450         if (unlikely(le32_to_cpu(bi->length) > WL_BSS_INFO_MAX)) {
2451                 WL_ERR("Bss info is larger than buffer. Discarding\n");
2452                 return 0;
2453         }
2454
2455         channel = bi->ctl_ch ? bi->ctl_ch :
2456                                 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2457
2458         if (channel <= CH_MAX_2G_CHANNEL)
2459                 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2460         else
2461                 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2462
2463         freq = ieee80211_channel_to_frequency(channel, band->band);
2464         notify_channel = ieee80211_get_channel(wiphy, freq);
2465
2466         notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2467         notify_capability = le16_to_cpu(bi->capability);
2468         notify_interval = le16_to_cpu(bi->beacon_period);
2469         notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2470         notify_ielen = le16_to_cpu(bi->ie_length);
2471         notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2472
2473         WL_CONN("bssid: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2474                         bi->BSSID[0], bi->BSSID[1], bi->BSSID[2],
2475                         bi->BSSID[3], bi->BSSID[4], bi->BSSID[5]);
2476         WL_CONN("Channel: %d(%d)\n", channel, freq);
2477         WL_CONN("Capability: %X\n", notify_capability);
2478         WL_CONN("Beacon interval: %d\n", notify_interval);
2479         WL_CONN("Signal: %d\n", notify_signal);
2480         WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2481
2482         bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
2483                 notify_timestamp, notify_capability, notify_interval, notify_ie,
2484                 notify_ielen, notify_signal, GFP_KERNEL);
2485
2486         if (unlikely(!bss)) {
2487                 WL_ERR("cfg80211_inform_bss_frame error\n");
2488                 return -EINVAL;
2489         }
2490
2491         return err;
2492 }
2493
2494 static s32 wl_inform_ibss(struct brcmf_cfg80211_priv *cfg_priv,
2495                           struct net_device *dev, const u8 *bssid)
2496 {
2497         struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2498         struct ieee80211_channel *notify_channel;
2499         struct brcmf_bss_info *bi = NULL;
2500         struct ieee80211_supported_band *band;
2501         u8 *buf = NULL;
2502         s32 err = 0;
2503         u16 channel;
2504         u32 freq;
2505         u64 notify_timestamp;
2506         u16 notify_capability;
2507         u16 notify_interval;
2508         u8 *notify_ie;
2509         size_t notify_ielen;
2510         s32 notify_signal;
2511
2512         WL_TRACE("Enter\n");
2513
2514         buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2515         if (buf == NULL) {
2516                 WL_ERR("kzalloc() failed\n");
2517                 err = -ENOMEM;
2518                 goto CleanUp;
2519         }
2520
2521         *(u32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2522
2523         err = brcmf_dev_ioctl(dev, BRCMF_C_GET_BSS_INFO, buf, WL_BSS_INFO_MAX);
2524         if (unlikely(err)) {
2525                 WL_ERR("WLC_GET_BSS_INFO failed: %d\n", err);
2526                 goto CleanUp;
2527         }
2528
2529         bi = (struct brcmf_bss_info *)(buf + 4);
2530
2531         channel = bi->ctl_ch ? bi->ctl_ch :
2532                                 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2533
2534         if (channel <= CH_MAX_2G_CHANNEL)
2535                 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2536         else
2537                 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2538
2539         freq = ieee80211_channel_to_frequency(channel, band->band);
2540         notify_channel = ieee80211_get_channel(wiphy, freq);
2541
2542         notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2543         notify_capability = le16_to_cpu(bi->capability);
2544         notify_interval = le16_to_cpu(bi->beacon_period);
2545         notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2546         notify_ielen = le16_to_cpu(bi->ie_length);
2547         notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2548
2549         WL_CONN("channel: %d(%d)\n", channel, freq);
2550         WL_CONN("capability: %X\n", notify_capability);
2551         WL_CONN("beacon interval: %d\n", notify_interval);
2552         WL_CONN("signal: %d\n", notify_signal);
2553         WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2554
2555         cfg80211_inform_bss(wiphy, notify_channel, bssid,
2556                 notify_timestamp, notify_capability, notify_interval,
2557                 notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
2558
2559 CleanUp:
2560
2561         kfree(buf);
2562
2563         WL_TRACE("Exit\n");
2564
2565         return err;
2566 }
2567
2568 static bool brcmf_is_linkup(struct brcmf_cfg80211_priv *cfg_priv,
2569                             const struct brcmf_event_msg *e)
2570 {
2571         u32 event = be32_to_cpu(e->event_type);
2572         u32 status = be32_to_cpu(e->status);
2573
2574         if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
2575                 WL_CONN("Processing set ssid\n");
2576                 cfg_priv->link_up = true;
2577                 return true;
2578         }
2579
2580         return false;
2581 }
2582
2583 static bool brcmf_is_linkdown(struct brcmf_cfg80211_priv *cfg_priv,
2584                               const struct brcmf_event_msg *e)
2585 {
2586         u32 event = be32_to_cpu(e->event_type);
2587         u16 flags = be16_to_cpu(e->flags);
2588
2589         if (event == BRCMF_E_LINK && (!(flags & BRCMF_EVENT_MSG_LINK))) {
2590                 WL_CONN("Processing link down\n");
2591                 return true;
2592         }
2593         return false;
2594 }
2595
2596 static bool brcmf_is_nonetwork(struct brcmf_cfg80211_priv *cfg_priv,
2597                                const struct brcmf_event_msg *e)
2598 {
2599         u32 event = be32_to_cpu(e->event_type);
2600         u32 status = be32_to_cpu(e->status);
2601
2602         if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
2603                 WL_CONN("Processing Link %s & no network found\n",
2604                                 be16_to_cpu(e->flags) & BRCMF_EVENT_MSG_LINK ?
2605                                 "up" : "down");
2606                 return true;
2607         }
2608
2609         if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
2610                 WL_CONN("Processing connecting & no network found\n");
2611                 return true;
2612         }
2613
2614         return false;
2615 }
2616
2617 static s32
2618 brcmf_notify_connect_status(struct brcmf_cfg80211_priv *cfg_priv,
2619                             struct net_device *ndev,
2620                             const struct brcmf_event_msg *e, void *data)
2621 {
2622         s32 err = 0;
2623
2624         if (brcmf_is_linkup(cfg_priv, e)) {
2625                 WL_CONN("Linkup\n");
2626                 if (brcmf_is_ibssmode(cfg_priv)) {
2627                         brcmf_update_prof(cfg_priv, NULL, (void *)e->addr,
2628                                 WL_PROF_BSSID);
2629                         wl_inform_ibss(cfg_priv, ndev, e->addr);
2630                         cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
2631                         clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
2632                         set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
2633                 } else
2634                         brcmf_bss_connect_done(cfg_priv, ndev, e, true);
2635         } else if (brcmf_is_linkdown(cfg_priv, e)) {
2636                 WL_CONN("Linkdown\n");
2637                 if (brcmf_is_ibssmode(cfg_priv)) {
2638                         clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
2639                         if (test_and_clear_bit(WL_STATUS_CONNECTED,
2640                                 &cfg_priv->status))
2641                                 brcmf_link_down(cfg_priv);
2642                 } else {
2643                         brcmf_bss_connect_done(cfg_priv, ndev, e, false);
2644                         if (test_and_clear_bit(WL_STATUS_CONNECTED,
2645                                 &cfg_priv->status)) {
2646                                 cfg80211_disconnected(ndev, 0, NULL, 0,
2647                                         GFP_KERNEL);
2648                                 brcmf_link_down(cfg_priv);
2649                         }
2650                 }
2651                 brcmf_init_prof(cfg_priv->profile);
2652         } else if (brcmf_is_nonetwork(cfg_priv, e)) {
2653                 if (brcmf_is_ibssmode(cfg_priv))
2654                         clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
2655                 else
2656                         brcmf_bss_connect_done(cfg_priv, ndev, e, false);
2657         }
2658
2659         return err;
2660 }
2661
2662 static s32
2663 brcmf_notify_roaming_status(struct brcmf_cfg80211_priv *cfg_priv,
2664                             struct net_device *ndev,
2665                             const struct brcmf_event_msg *e, void *data)
2666 {
2667         s32 err = 0;
2668         u32 event = be32_to_cpu(e->event_type);
2669         u32 status = be32_to_cpu(e->status);
2670
2671         if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
2672                 if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status))
2673                         brcmf_bss_roaming_done(cfg_priv, ndev, e);
2674                 else
2675                         brcmf_bss_connect_done(cfg_priv, ndev, e, true);
2676         }
2677
2678         return err;
2679 }
2680
2681 static __used s32
2682 brcmf_dev_bufvar_set(struct net_device *dev, s8 *name, s8 *buf, s32 len)
2683 {
2684         struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
2685         u32 buflen;
2686
2687         buflen = brcmu_mkiovar(name, buf, len, cfg_priv->ioctl_buf,
2688                                WL_IOCTL_LEN_MAX);
2689         BUG_ON(!buflen);
2690
2691         return brcmf_dev_ioctl(dev, BRCMF_C_SET_VAR, cfg_priv->ioctl_buf,
2692                                buflen);
2693 }
2694
2695 static s32
2696 brcmf_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
2697                   s32 buf_len)
2698 {
2699         struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
2700         u32 len;
2701         s32 err = 0;
2702
2703         len = brcmu_mkiovar(name, NULL, 0, cfg_priv->ioctl_buf,
2704                             WL_IOCTL_LEN_MAX);
2705         BUG_ON(!len);
2706         err = brcmf_dev_ioctl(dev, BRCMF_C_GET_VAR, (void *)cfg_priv->ioctl_buf,
2707                         WL_IOCTL_LEN_MAX);
2708         if (unlikely(err)) {
2709                 WL_ERR("error (%d)\n", err);
2710                 return err;
2711         }
2712         memcpy(buf, cfg_priv->ioctl_buf, buf_len);
2713
2714         return err;
2715 }
2716
2717 static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv)
2718 {
2719         struct net_device *ndev = cfg_to_ndev(cfg_priv);
2720         struct brcmf_cfg80211_assoc_ielen *assoc_info;
2721         struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2722         u32 req_len;
2723         u32 resp_len;
2724         s32 err = 0;
2725
2726         brcmf_clear_assoc_ies(cfg_priv);
2727
2728         err = brcmf_dev_bufvar_get(ndev, "assoc_info", cfg_priv->extra_buf,
2729                                 WL_ASSOC_INFO_MAX);
2730         if (unlikely(err)) {
2731                 WL_ERR("could not get assoc info (%d)\n", err);
2732                 return err;
2733         }
2734         assoc_info = (struct brcmf_cfg80211_assoc_ielen *)cfg_priv->extra_buf;
2735         req_len = assoc_info->req_len;
2736         resp_len = assoc_info->resp_len;
2737         if (req_len) {
2738                 err = brcmf_dev_bufvar_get(ndev, "assoc_req_ies",
2739                                            cfg_priv->extra_buf,
2740                                            WL_ASSOC_INFO_MAX);
2741                 if (unlikely(err)) {
2742                         WL_ERR("could not get assoc req (%d)\n", err);
2743                         return err;
2744                 }
2745                 conn_info->req_ie_len = req_len;
2746                 conn_info->req_ie =
2747                     kmemdup(cfg_priv->extra_buf, conn_info->req_ie_len,
2748                             GFP_KERNEL);
2749         } else {
2750                 conn_info->req_ie_len = 0;
2751                 conn_info->req_ie = NULL;
2752         }
2753         if (resp_len) {
2754                 err = brcmf_dev_bufvar_get(ndev, "assoc_resp_ies",
2755                                            cfg_priv->extra_buf,
2756                                            WL_ASSOC_INFO_MAX);
2757                 if (unlikely(err)) {
2758                         WL_ERR("could not get assoc resp (%d)\n", err);
2759                         return err;
2760                 }
2761                 conn_info->resp_ie_len = resp_len;
2762                 conn_info->resp_ie =
2763                     kmemdup(cfg_priv->extra_buf, conn_info->resp_ie_len,
2764                             GFP_KERNEL);
2765         } else {
2766                 conn_info->resp_ie_len = 0;
2767                 conn_info->resp_ie = NULL;
2768         }
2769         WL_CONN("req len (%d) resp len (%d)\n",
2770                conn_info->req_ie_len, conn_info->resp_ie_len);
2771
2772         return err;
2773 }
2774
2775 static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv)
2776 {
2777         struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2778
2779         kfree(conn_info->req_ie);
2780         conn_info->req_ie = NULL;
2781         conn_info->req_ie_len = 0;
2782         kfree(conn_info->resp_ie);
2783         conn_info->resp_ie = NULL;
2784         conn_info->resp_ie_len = 0;
2785 }
2786
2787
2788 static void brcmf_ch_to_chanspec(int ch, struct brcmf_join_params *join_params,
2789         size_t *join_params_size)
2790 {
2791         u16 chanspec = 0;
2792
2793         if (ch != 0) {
2794                 join_params->params.chanspec_num = 1;
2795                 join_params->params.chanspec_list[0] = ch;
2796
2797                 if (join_params->params.chanspec_list[0] <= CH_MAX_2G_CHANNEL)
2798                         chanspec |= WL_CHANSPEC_BAND_2G;
2799                 else
2800                         chanspec |= WL_CHANSPEC_BAND_5G;
2801
2802                 chanspec |= WL_CHANSPEC_BW_20;
2803                 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
2804
2805                 *join_params_size += BRCMF_ASSOC_PARAMS_FIXED_SIZE +
2806                         join_params->params.chanspec_num * sizeof(u16);
2807
2808                 join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
2809                 join_params->params.chanspec_list[0] |= chanspec;
2810                 join_params->params.chanspec_list[0] =
2811                 cpu_to_le16(join_params->params.chanspec_list[0]);
2812
2813                 join_params->params.chanspec_num =
2814                         cpu_to_le32(join_params->params.chanspec_num);
2815
2816                 WL_CONN("join_params->params.chanspec_list[0]= %#X,"
2817                         "channel %d, chanspec %#X\n",
2818                        join_params->params.chanspec_list[0], ch, chanspec);
2819         }
2820 }
2821
2822 static s32 brcmf_update_bss_info(struct brcmf_cfg80211_priv *cfg_priv)
2823 {
2824         struct brcmf_bss_info *bi;
2825         struct brcmf_ssid *ssid;
2826         struct brcmu_tlv *tim;
2827         u16 beacon_interval;
2828         u8 dtim_period;
2829         size_t ie_len;
2830         u8 *ie;
2831         s32 err = 0;
2832
2833         WL_TRACE("Enter\n");
2834         if (brcmf_is_ibssmode(cfg_priv))
2835                 return err;
2836
2837         ssid = (struct brcmf_ssid *)brcmf_read_prof(cfg_priv, WL_PROF_SSID);
2838
2839         *(u32 *)cfg_priv->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2840         err = brcmf_dev_ioctl(cfg_to_ndev(cfg_priv), BRCMF_C_GET_BSS_INFO,
2841                         cfg_priv->extra_buf, WL_EXTRA_BUF_MAX);
2842         if (unlikely(err)) {
2843                 WL_ERR("Could not get bss info %d\n", err);
2844                 goto update_bss_info_out;
2845         }
2846
2847         bi = (struct brcmf_bss_info *)(cfg_priv->extra_buf + 4);
2848         err = brcmf_inform_single_bss(cfg_priv, bi);
2849         if (unlikely(err))
2850                 goto update_bss_info_out;
2851
2852         ie = ((u8 *)bi) + bi->ie_offset;
2853         ie_len = bi->ie_length;
2854         beacon_interval = cpu_to_le16(bi->beacon_period);
2855
2856         tim = brcmu_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2857         if (tim)
2858                 dtim_period = tim->data[1];
2859         else {
2860                 /*
2861                 * active scan was done so we could not get dtim
2862                 * information out of probe response.
2863                 * so we speficially query dtim information to dongle.
2864                 */
2865                 u32 var;
2866                 err = brcmf_dev_intvar_get(cfg_to_ndev(cfg_priv),
2867                                            "dtim_assoc", &var);
2868                 if (unlikely(err)) {
2869                         WL_ERR("wl dtim_assoc failed (%d)\n", err);
2870                         goto update_bss_info_out;
2871                 }
2872                 dtim_period = (u8)var;
2873         }
2874
2875         brcmf_update_prof(cfg_priv, NULL, &beacon_interval, WL_PROF_BEACONINT);
2876         brcmf_update_prof(cfg_priv, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
2877
2878 update_bss_info_out:
2879         WL_TRACE("Exit");
2880         return err;
2881 }
2882
2883 static s32
2884 brcmf_bss_roaming_done(struct brcmf_cfg80211_priv *cfg_priv,
2885                        struct net_device *ndev,
2886                        const struct brcmf_event_msg *e)
2887 {
2888         struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2889         struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2890         struct brcmf_channel_info channel;
2891         struct ieee80211_channel *notify_channel;
2892         struct ieee80211_supported_band *band;
2893         u32 freq;
2894         s32 err = 0;
2895
2896         WL_TRACE("Enter\n");
2897
2898         brcmf_get_assoc_ies(cfg_priv);
2899         brcmf_update_prof(cfg_priv, NULL, &e->addr, WL_PROF_BSSID);
2900         brcmf_update_bss_info(cfg_priv);
2901
2902         brcmf_dev_ioctl(ndev, BRCMF_C_GET_CHANNEL, &channel, sizeof(channel));
2903
2904         channel.target_channel = le32_to_cpu(channel.target_channel);
2905         WL_CONN("Roamed to channel %d\n", channel.target_channel);
2906
2907         if (channel.target_channel <= CH_MAX_2G_CHANNEL)
2908                 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2909         else
2910                 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2911
2912         freq = ieee80211_channel_to_frequency(channel.target_channel,
2913                                                 band->band);
2914         notify_channel = ieee80211_get_channel(wiphy, freq);
2915
2916         cfg80211_roamed(ndev, notify_channel,
2917                         (u8 *)brcmf_read_prof(cfg_priv, WL_PROF_BSSID),
2918                         conn_info->req_ie, conn_info->req_ie_len,
2919                         conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
2920         WL_CONN("Report roaming result\n");
2921
2922         set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
2923         WL_TRACE("Exit\n");
2924         return err;
2925 }
2926
2927 static s32
2928 brcmf_bss_connect_done(struct brcmf_cfg80211_priv *cfg_priv,
2929                        struct net_device *ndev, const struct brcmf_event_msg *e,
2930                        bool completed)
2931 {
2932         struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2933         s32 err = 0;
2934
2935         WL_TRACE("Enter\n");
2936
2937         if (test_and_clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) {
2938                 if (completed) {
2939                         brcmf_get_assoc_ies(cfg_priv);
2940                         brcmf_update_prof(cfg_priv, NULL, &e->addr,
2941                                           WL_PROF_BSSID);
2942                         brcmf_update_bss_info(cfg_priv);
2943                 }
2944                 cfg80211_connect_result(ndev,
2945                                         (u8 *)brcmf_read_prof(cfg_priv,
2946                                                               WL_PROF_BSSID),
2947                                         conn_info->req_ie,
2948                                         conn_info->req_ie_len,
2949                                         conn_info->resp_ie,
2950                                         conn_info->resp_ie_len,
2951                                         completed ? WLAN_STATUS_SUCCESS :
2952                                                     WLAN_STATUS_AUTH_TIMEOUT,
2953                                         GFP_KERNEL);
2954                 if (completed)
2955                         set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
2956                 WL_CONN("Report connect result - connection %s\n",
2957                                 completed ? "succeeded" : "failed");
2958         }
2959         WL_TRACE("Exit\n");
2960         return err;
2961 }
2962
2963 static s32
2964 brcmf_notify_mic_status(struct brcmf_cfg80211_priv *cfg_priv,
2965                         struct net_device *ndev,
2966                         const struct brcmf_event_msg *e, void *data)
2967 {
2968         u16 flags = be16_to_cpu(e->flags);
2969         enum nl80211_key_type key_type;
2970
2971         rtnl_lock();
2972         if (flags & BRCMF_EVENT_MSG_GROUP)
2973                 key_type = NL80211_KEYTYPE_GROUP;
2974         else
2975                 key_type = NL80211_KEYTYPE_PAIRWISE;
2976
2977         cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
2978                                      NULL, GFP_KERNEL);
2979         rtnl_unlock();
2980
2981         return 0;
2982 }
2983
2984 static s32
2985 brcmf_notify_scan_status(struct brcmf_cfg80211_priv *cfg_priv,
2986                          struct net_device *ndev,
2987                          const struct brcmf_event_msg *e, void *data)
2988 {
2989         struct brcmf_channel_info channel_inform;
2990         struct brcmf_scan_results *bss_list;
2991         u32 len = WL_SCAN_BUF_MAX;
2992         s32 err = 0;
2993         bool scan_abort = false;
2994
2995         WL_TRACE("Enter\n");
2996
2997         if (cfg_priv->iscan_on && cfg_priv->iscan_kickstart) {
2998                 WL_TRACE("Exit\n");
2999                 return brcmf_wakeup_iscan(cfg_to_iscan(cfg_priv));
3000         }
3001
3002         if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING,
3003                                          &cfg_priv->status))) {
3004                 WL_ERR("Scan complete while device not scanning\n");
3005                 scan_abort = true;
3006                 err = -EINVAL;
3007                 goto scan_done_out;
3008         }
3009
3010         err = brcmf_dev_ioctl(ndev, BRCMF_C_GET_CHANNEL, &channel_inform,
3011                         sizeof(channel_inform));
3012         if (unlikely(err)) {
3013                 WL_ERR("scan busy (%d)\n", err);
3014                 scan_abort = true;
3015                 goto scan_done_out;
3016         }
3017         channel_inform.scan_channel = le32_to_cpu(channel_inform.scan_channel);
3018         if (unlikely(channel_inform.scan_channel)) {
3019
3020                 WL_CONN("channel_inform.scan_channel (%d)\n",
3021                        channel_inform.scan_channel);
3022         }
3023         cfg_priv->bss_list = cfg_priv->scan_results;
3024         bss_list = cfg_priv->bss_list;
3025         memset(bss_list, 0, len);
3026         bss_list->buflen = cpu_to_le32(len);
3027
3028         err = brcmf_dev_ioctl(ndev, BRCMF_C_SCAN_RESULTS, bss_list, len);
3029         if (unlikely(err)) {
3030                 WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
3031                 err = -EINVAL;
3032                 scan_abort = true;
3033                 goto scan_done_out;
3034         }
3035         bss_list->buflen = le32_to_cpu(bss_list->buflen);
3036         bss_list->version = le32_to_cpu(bss_list->version);
3037         bss_list->count = le32_to_cpu(bss_list->count);
3038
3039         err = brcmf_inform_bss(cfg_priv);
3040         if (err) {
3041                 scan_abort = true;
3042                 goto scan_done_out;
3043         }
3044
3045 scan_done_out:
3046         if (cfg_priv->scan_request) {
3047                 WL_SCAN("calling cfg80211_scan_done\n");
3048                 cfg80211_scan_done(cfg_priv->scan_request, scan_abort);
3049                 brcmf_set_mpc(ndev, 1);
3050                 cfg_priv->scan_request = NULL;
3051         }
3052
3053         WL_TRACE("Exit\n");
3054
3055         return err;
3056 }
3057
3058 static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
3059 {
3060         conf->mode = (u32)-1;
3061         conf->frag_threshold = (u32)-1;
3062         conf->rts_threshold = (u32)-1;
3063         conf->retry_short = (u32)-1;
3064         conf->retry_long = (u32)-1;
3065         conf->tx_power = -1;
3066 }
3067
3068 static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof)
3069 {
3070         memset(prof, 0, sizeof(*prof));
3071 }
3072
3073 static void brcmf_init_eloop_handler(struct brcmf_cfg80211_event_loop *el)
3074 {
3075         memset(el, 0, sizeof(*el));
3076         el->handler[BRCMF_E_SCAN_COMPLETE] = brcmf_notify_scan_status;
3077         el->handler[BRCMF_E_LINK] = brcmf_notify_connect_status;
3078         el->handler[BRCMF_E_ROAM] = brcmf_notify_roaming_status;
3079         el->handler[BRCMF_E_MIC_ERROR] = brcmf_notify_mic_status;
3080         el->handler[BRCMF_E_SET_SSID] = brcmf_notify_connect_status;
3081 }
3082
3083 static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_priv *cfg_priv)
3084 {
3085         cfg_priv->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
3086         if (unlikely(!cfg_priv->scan_results)) {
3087                 WL_ERR("Scan results alloc failed\n");
3088                 goto init_priv_mem_out;
3089         }
3090         cfg_priv->conf = kzalloc(sizeof(*cfg_priv->conf), GFP_KERNEL);
3091         if (unlikely(!cfg_priv->conf)) {
3092                 WL_ERR("wl_conf alloc failed\n");
3093                 goto init_priv_mem_out;
3094         }
3095         cfg_priv->profile = kzalloc(sizeof(*cfg_priv->profile), GFP_KERNEL);
3096         if (unlikely(!cfg_priv->profile)) {
3097                 WL_ERR("wl_profile alloc failed\n");
3098                 goto init_priv_mem_out;
3099         }
3100         cfg_priv->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
3101         if (unlikely(!cfg_priv->bss_info)) {
3102                 WL_ERR("Bss information alloc failed\n");
3103                 goto init_priv_mem_out;
3104         }
3105         cfg_priv->scan_req_int = kzalloc(sizeof(*cfg_priv->scan_req_int),
3106                                          GFP_KERNEL);
3107         if (unlikely(!cfg_priv->scan_req_int)) {
3108                 WL_ERR("Scan req alloc failed\n");
3109                 goto init_priv_mem_out;
3110         }
3111         cfg_priv->ioctl_buf = kzalloc(WL_IOCTL_LEN_MAX, GFP_KERNEL);
3112         if (unlikely(!cfg_priv->ioctl_buf)) {
3113                 WL_ERR("Ioctl buf alloc failed\n");
3114                 goto init_priv_mem_out;
3115         }
3116         cfg_priv->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3117         if (unlikely(!cfg_priv->extra_buf)) {
3118                 WL_ERR("Extra buf alloc failed\n");
3119                 goto init_priv_mem_out;
3120         }
3121         cfg_priv->iscan = kzalloc(sizeof(*cfg_priv->iscan), GFP_KERNEL);
3122         if (unlikely(!cfg_priv->iscan)) {
3123                 WL_ERR("Iscan buf alloc failed\n");
3124                 goto init_priv_mem_out;
3125         }
3126         cfg_priv->pmk_list = kzalloc(sizeof(*cfg_priv->pmk_list), GFP_KERNEL);
3127         if (unlikely(!cfg_priv->pmk_list)) {
3128                 WL_ERR("pmk list alloc failed\n");
3129                 goto init_priv_mem_out;
3130         }
3131
3132         return 0;
3133
3134 init_priv_mem_out:
3135         brcmf_deinit_priv_mem(cfg_priv);
3136
3137         return -ENOMEM;
3138 }
3139
3140 static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_priv *cfg_priv)
3141 {
3142         kfree(cfg_priv->scan_results);
3143         cfg_priv->scan_results = NULL;
3144         kfree(cfg_priv->bss_info);
3145         cfg_priv->bss_info = NULL;
3146         kfree(cfg_priv->conf);
3147         cfg_priv->conf = NULL;
3148         kfree(cfg_priv->profile);
3149         cfg_priv->profile = NULL;
3150         kfree(cfg_priv->scan_req_int);
3151         cfg_priv->scan_req_int = NULL;
3152         kfree(cfg_priv->ioctl_buf);
3153         cfg_priv->ioctl_buf = NULL;
3154         kfree(cfg_priv->extra_buf);
3155         cfg_priv->extra_buf = NULL;
3156         kfree(cfg_priv->iscan);
3157         cfg_priv->iscan = NULL;
3158         kfree(cfg_priv->pmk_list);
3159         cfg_priv->pmk_list = NULL;
3160 }
3161
3162 static s32 brcmf_create_event_handler(struct brcmf_cfg80211_priv *cfg_priv)
3163 {
3164         init_waitqueue_head(&cfg_priv->event_waitq);
3165         cfg_priv->event_tsk = kthread_run(brcmf_event_handler, cfg_priv,
3166                                           "wl_event_handler");
3167         if (IS_ERR(cfg_priv->event_tsk)) {
3168                 cfg_priv->event_tsk = NULL;
3169                 WL_ERR("failed to create event thread\n");
3170                 return -ENOMEM;
3171         }
3172         return 0;
3173 }
3174
3175 static void brcmf_destroy_event_handler(struct brcmf_cfg80211_priv *cfg_priv)
3176 {
3177         if (cfg_priv->event_tsk) {
3178                 send_sig(SIGTERM, cfg_priv->event_tsk, 1);
3179                 kthread_stop(cfg_priv->event_tsk);
3180                 cfg_priv->event_tsk = NULL;
3181         }
3182 }
3183
3184 static void brcmf_term_iscan(struct brcmf_cfg80211_priv *cfg_priv)
3185 {
3186         struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
3187         struct brcmf_ssid ssid;
3188
3189         if (cfg_priv->iscan_on && iscan->tsk) {
3190                 iscan->state = WL_ISCAN_STATE_IDLE;
3191                 send_sig(SIGTERM, iscan->tsk, 1);
3192
3193                 /*
3194                  * The iscan task may want to acquire the rtnl_lock
3195                  * so release it here upon stopping the task.
3196                  */
3197                 rtnl_unlock();
3198                 kthread_stop(iscan->tsk);
3199                 rtnl_lock();
3200                 iscan->tsk = NULL;
3201
3202                 /* Abort iscan running in FW */
3203                 memset(&ssid, 0, sizeof(ssid));
3204                 brcmf_run_iscan(iscan, &ssid, WL_SCAN_ACTION_ABORT);
3205         }
3206 }
3207
3208 static void brcmf_notify_iscan_complete(struct brcmf_cfg80211_iscan_ctrl *iscan,
3209                                         bool aborted)
3210 {
3211         struct brcmf_cfg80211_priv *cfg_priv = iscan_to_cfg(iscan);
3212         struct net_device *ndev = cfg_to_ndev(cfg_priv);
3213
3214         if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING,
3215                                          &cfg_priv->status))) {
3216                 WL_ERR("Scan complete while device not scanning\n");
3217                 return;
3218         }
3219         if (likely(cfg_priv->scan_request)) {
3220                 WL_SCAN("ISCAN Completed scan: %s\n",
3221                                 aborted ? "Aborted" : "Done");
3222                 cfg80211_scan_done(cfg_priv->scan_request, aborted);
3223                 brcmf_set_mpc(ndev, 1);
3224                 cfg_priv->scan_request = NULL;
3225         }
3226         cfg_priv->iscan_kickstart = false;
3227 }
3228
3229 static s32 brcmf_wakeup_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan)
3230 {
3231         if (likely(iscan->state != WL_ISCAN_STATE_IDLE)) {
3232                 WL_SCAN("wake up iscan\n");
3233                 wake_up(&iscan->waitq);
3234                 return 0;
3235         }
3236
3237         return -EIO;
3238 }
3239
3240 static s32
3241 brcmf_get_iscan_results(struct brcmf_cfg80211_iscan_ctrl *iscan, u32 *status,
3242                      struct brcmf_scan_results **bss_list)
3243 {
3244         struct brcmf_iscan_results list;
3245         struct brcmf_scan_results *results;
3246         struct brcmf_iscan_results *list_buf;
3247         s32 err = 0;
3248
3249         memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
3250         list_buf = (struct brcmf_iscan_results *)iscan->scan_buf;
3251         results = &list_buf->results;
3252         results->buflen = BRCMF_ISCAN_RESULTS_FIXED_SIZE;
3253         results->version = 0;
3254         results->count = 0;
3255
3256         memset(&list, 0, sizeof(list));
3257         list.results.buflen = cpu_to_le32(WL_ISCAN_BUF_MAX);
3258         err = brcmf_dev_iovar_getbuf(iscan->dev, "iscanresults", &list,
3259                                 BRCMF_ISCAN_RESULTS_FIXED_SIZE, iscan->scan_buf,
3260                                 WL_ISCAN_BUF_MAX);
3261         if (unlikely(err)) {
3262                 WL_ERR("error (%d)\n", err);
3263                 return err;
3264         }
3265         results->buflen = le32_to_cpu(results->buflen);
3266         results->version = le32_to_cpu(results->version);
3267         results->count = le32_to_cpu(results->count);
3268         WL_SCAN("results->count = %d\n", results->count);
3269         WL_SCAN("results->buflen = %d\n", results->buflen);
3270         *status = le32_to_cpu(list_buf->status);
3271         WL_SCAN("status = %d\n", *status);
3272         *bss_list = results;
3273
3274         return err;
3275 }
3276
3277 static s32 brcmf_iscan_done(struct brcmf_cfg80211_priv *cfg_priv)
3278 {
3279         struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
3280         s32 err = 0;
3281
3282         iscan->state = WL_ISCAN_STATE_IDLE;
3283         rtnl_lock();
3284         brcmf_inform_bss(cfg_priv);
3285         brcmf_notify_iscan_complete(iscan, false);
3286         rtnl_unlock();
3287
3288         return err;
3289 }
3290
3291 static s32 brcmf_iscan_pending(struct brcmf_cfg80211_priv *cfg_priv)
3292 {
3293         struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
3294         s32 err = 0;
3295
3296         /* Reschedule the timer */
3297         mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3298         iscan->timer_on = 1;
3299
3300         return err;
3301 }
3302
3303 static s32 brcmf_iscan_inprogress(struct brcmf_cfg80211_priv *cfg_priv)
3304 {
3305         struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
3306         s32 err = 0;
3307
3308         rtnl_lock();
3309         brcmf_inform_bss(cfg_priv);
3310         brcmf_run_iscan(iscan, NULL, BRCMF_SCAN_ACTION_CONTINUE);
3311         rtnl_unlock();
3312         /* Reschedule the timer */
3313         mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3314         iscan->timer_on = 1;
3315
3316         return err;
3317 }
3318
3319 static s32 brcmf_iscan_aborted(struct brcmf_cfg80211_priv *cfg_priv)
3320 {
3321         struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
3322         s32 err = 0;
3323
3324         iscan->state = WL_ISCAN_STATE_IDLE;
3325         rtnl_lock();
3326         brcmf_notify_iscan_complete(iscan, true);
3327         rtnl_unlock();
3328
3329         return err;
3330 }
3331
3332 static s32 brcmf_iscan_thread(void *data)
3333 {
3334         struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3335         struct brcmf_cfg80211_iscan_ctrl *iscan =
3336                         (struct brcmf_cfg80211_iscan_ctrl *)data;
3337         struct brcmf_cfg80211_priv *cfg_priv = iscan_to_cfg(iscan);
3338         struct brcmf_cfg80211_iscan_eloop *el = &iscan->el;
3339         DECLARE_WAITQUEUE(wait, current);
3340         u32 status;
3341         int err = 0;
3342
3343         sched_setscheduler(current, SCHED_FIFO, &param);
3344         allow_signal(SIGTERM);
3345         status = BRCMF_SCAN_RESULTS_PARTIAL;
3346         add_wait_queue(&iscan->waitq, &wait);
3347         while (1) {
3348                 prepare_to_wait(&iscan->waitq, &wait, TASK_INTERRUPTIBLE);
3349
3350                 schedule();
3351
3352                 if (kthread_should_stop())
3353                         break;
3354                 if (iscan->timer_on) {
3355                         del_timer_sync(&iscan->timer);
3356                         iscan->timer_on = 0;
3357                 }
3358                 rtnl_lock();
3359                 err = brcmf_get_iscan_results(iscan, &status,
3360                                               &cfg_priv->bss_list);
3361                 if (unlikely(err)) {
3362                         status = BRCMF_SCAN_RESULTS_ABORTED;
3363                         WL_ERR("Abort iscan\n");
3364                 }
3365                 rtnl_unlock();
3366                 el->handler[status](cfg_priv);
3367         }
3368         finish_wait(&iscan->waitq, &wait);
3369         if (iscan->timer_on) {
3370                 del_timer_sync(&iscan->timer);
3371                 iscan->timer_on = 0;
3372         }
3373         WL_SCAN("ISCAN thread terminated\n");
3374
3375         return 0;
3376 }
3377
3378 static void brcmf_iscan_timer(unsigned long data)
3379 {
3380         struct brcmf_cfg80211_iscan_ctrl *iscan =
3381                         (struct brcmf_cfg80211_iscan_ctrl *)data;
3382
3383         if (iscan) {
3384                 iscan->timer_on = 0;
3385                 WL_SCAN("timer expired\n");
3386                 brcmf_wakeup_iscan(iscan);
3387         }
3388 }
3389
3390 static s32 brcmf_invoke_iscan(struct brcmf_cfg80211_priv *cfg_priv)
3391 {
3392         struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
3393
3394         if (cfg_priv->iscan_on && !iscan->tsk) {
3395                 iscan->state = WL_ISCAN_STATE_IDLE;
3396                 init_waitqueue_head(&iscan->waitq);
3397                 iscan->tsk = kthread_run(brcmf_iscan_thread, iscan, "wl_iscan");
3398                 if (IS_ERR(iscan->tsk)) {
3399                         WL_ERR("Could not create iscan thread\n");
3400                         iscan->tsk = NULL;
3401                         return -ENOMEM;
3402                 }
3403         }
3404
3405         return 0;
3406 }
3407
3408 static void brcmf_init_iscan_eloop(struct brcmf_cfg80211_iscan_eloop *el)
3409 {
3410         memset(el, 0, sizeof(*el));
3411         el->handler[BRCMF_SCAN_RESULTS_SUCCESS] = brcmf_iscan_done;
3412         el->handler[BRCMF_SCAN_RESULTS_PARTIAL] = brcmf_iscan_inprogress;
3413         el->handler[BRCMF_SCAN_RESULTS_PENDING] = brcmf_iscan_pending;
3414         el->handler[BRCMF_SCAN_RESULTS_ABORTED] = brcmf_iscan_aborted;
3415         el->handler[BRCMF_SCAN_RESULTS_NO_MEM] = brcmf_iscan_aborted;
3416 }
3417
3418 static s32 brcmf_init_iscan(struct brcmf_cfg80211_priv *cfg_priv)
3419 {
3420         struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
3421         int err = 0;
3422
3423         if (cfg_priv->iscan_on) {
3424                 iscan->dev = cfg_to_ndev(cfg_priv);
3425                 brcmf_init_iscan_eloop(&iscan->el);
3426                 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
3427                 init_timer(&iscan->timer);
3428                 iscan->timer.data = (unsigned long) iscan;
3429                 iscan->timer.function = brcmf_iscan_timer;
3430                 err = brcmf_invoke_iscan(cfg_priv);
3431                 if (!err)
3432                         iscan->data = cfg_priv;
3433         }
3434
3435         return err;
3436 }
3437
3438 static s32 wl_init_priv(struct brcmf_cfg80211_priv *cfg_priv)
3439 {
3440         s32 err = 0;
3441
3442         cfg_priv->scan_request = NULL;
3443 #ifndef WL_POWERSAVE_DISABLED
3444         cfg_priv->pwr_save = true;
3445 #endif /* WL_POWERSAVE_DISABLED */
3446         cfg_priv->iscan_on = true;      /* iscan on & off switch.
3447                                  we enable iscan per default */
3448         cfg_priv->roam_on = true;       /* roam on & off switch.
3449                                  we enable roam per default */
3450
3451         cfg_priv->iscan_kickstart = false;
3452         cfg_priv->active_scan = true;   /* we do active scan for
3453                                  specific scan per default */
3454         cfg_priv->dongle_up = false;    /* dongle is not up yet */
3455         brcmf_init_eq(cfg_priv);
3456         err = brcmf_init_priv_mem(cfg_priv);
3457         if (unlikely(err))
3458                 return err;
3459         if (unlikely(brcmf_create_event_handler(cfg_priv)))
3460                 return -ENOMEM;
3461         brcmf_init_eloop_handler(&cfg_priv->el);
3462         mutex_init(&cfg_priv->usr_sync);
3463         err = brcmf_init_iscan(cfg_priv);
3464         if (unlikely(err))
3465                 return err;
3466         brcmf_init_conf(cfg_priv->conf);
3467         brcmf_init_prof(cfg_priv->profile);
3468         brcmf_link_down(cfg_priv);
3469
3470         return err;
3471 }
3472
3473 static void wl_deinit_priv(struct brcmf_cfg80211_priv *cfg_priv)
3474 {
3475         brcmf_destroy_event_handler(cfg_priv);
3476         cfg_priv->dongle_up = false;    /* dongle down */
3477         brcmf_flush_eq(cfg_priv);
3478         brcmf_link_down(cfg_priv);
3479         brcmf_term_iscan(cfg_priv);
3480         brcmf_deinit_priv_mem(cfg_priv);
3481 }
3482
3483 s32 brcmf_cfg80211_attach(struct net_device *ndev, void *data)
3484 {
3485         struct wireless_dev *wdev;
3486         struct brcmf_cfg80211_priv *cfg_priv;
3487         struct brcmf_cfg80211_iface *ci;
3488         s32 err = 0;
3489
3490         if (unlikely(!ndev)) {
3491                 WL_ERR("ndev is invalid\n");
3492                 return -ENODEV;
3493         }
3494         cfg80211_dev = kzalloc(sizeof(struct brcmf_cfg80211_dev), GFP_KERNEL);
3495         if (unlikely(!cfg80211_dev)) {
3496                 WL_ERR("wl_cfg80211_dev is invalid\n");
3497                 return -ENOMEM;
3498         }
3499         WL_INFO("func %p\n", brcmf_cfg80211_get_sdio_func());
3500         wdev = brcmf_alloc_wdev(sizeof(struct brcmf_cfg80211_iface),
3501                                 &brcmf_cfg80211_get_sdio_func()->dev);
3502         if (IS_ERR(wdev))
3503                 return -ENOMEM;
3504
3505         wdev->iftype = brcmf_mode_to_nl80211_iftype(WL_MODE_BSS);
3506         cfg_priv = wdev_to_cfg(wdev);
3507         cfg_priv->wdev = wdev;
3508         cfg_priv->pub = data;
3509         ci = (struct brcmf_cfg80211_iface *)&cfg_priv->ci;
3510         ci->cfg_priv = cfg_priv;
3511         ndev->ieee80211_ptr = wdev;
3512         SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
3513         wdev->netdev = ndev;
3514         err = wl_init_priv(cfg_priv);
3515         if (unlikely(err)) {
3516                 WL_ERR("Failed to init iwm_priv (%d)\n", err);
3517                 goto cfg80211_attach_out;
3518         }
3519         brcmf_set_drvdata(cfg80211_dev, ci);
3520
3521         return err;
3522
3523 cfg80211_attach_out:
3524         brcmf_free_wdev(cfg_priv);
3525         return err;
3526 }
3527
3528 void brcmf_cfg80211_detach(void)
3529 {
3530         struct brcmf_cfg80211_priv *cfg_priv;
3531
3532         cfg_priv = WL_PRIV_GET();
3533
3534         wl_deinit_priv(cfg_priv);
3535         brcmf_free_wdev(cfg_priv);
3536         brcmf_set_drvdata(cfg80211_dev, NULL);
3537         kfree(cfg80211_dev);
3538         cfg80211_dev = NULL;
3539         brcmf_clear_sdio_func();
3540 }
3541
3542 static void brcmf_wakeup_event(struct brcmf_cfg80211_priv *cfg_priv)
3543 {
3544         wake_up(&cfg_priv->event_waitq);
3545 }
3546
3547 static s32 brcmf_event_handler(void *data)
3548 {
3549         struct brcmf_cfg80211_priv *cfg_priv =
3550                         (struct brcmf_cfg80211_priv *)data;
3551         struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3552         struct brcmf_cfg80211_event_q *e;
3553         DECLARE_WAITQUEUE(wait, current);
3554
3555         sched_setscheduler(current, SCHED_FIFO, &param);
3556         allow_signal(SIGTERM);
3557         add_wait_queue(&cfg_priv->event_waitq, &wait);
3558         while (1) {
3559                 prepare_to_wait(&cfg_priv->event_waitq, &wait,
3560                                 TASK_INTERRUPTIBLE);
3561
3562                 schedule();
3563
3564                 if (kthread_should_stop())
3565                         break;
3566
3567                 e = brcmf_deq_event(cfg_priv);
3568                 if (unlikely(!e)) {
3569                         WL_ERR("event queue empty...\n");
3570                         continue;
3571                 }
3572
3573                 do {
3574                         WL_INFO("event type (%d)\n", e->etype);
3575                         if (cfg_priv->el.handler[e->etype])
3576                                 cfg_priv->el.handler[e->etype](cfg_priv,
3577                                         cfg_to_ndev(cfg_priv),
3578                                         &e->emsg, e->edata);
3579                         else
3580                                 WL_INFO("Unknown Event (%d): ignoring\n",
3581                                         e->etype);
3582                         brcmf_put_event(e);
3583                 } while ((e = brcmf_deq_event(cfg_priv)));
3584         }
3585         finish_wait(&cfg_priv->event_waitq, &wait);
3586         WL_INFO("was terminated\n");
3587         return 0;
3588 }
3589
3590 void
3591 brcmf_cfg80211_event(struct net_device *ndev,
3592                   const struct brcmf_event_msg *e, void *data)
3593 {
3594         u32 event_type = be32_to_cpu(e->event_type);
3595         struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
3596
3597         if (likely(!brcmf_enq_event(cfg_priv, event_type, e)))
3598                 brcmf_wakeup_event(cfg_priv);
3599 }
3600
3601 static void brcmf_init_eq(struct brcmf_cfg80211_priv *cfg_priv)
3602 {
3603         brcmf_init_eq_lock(cfg_priv);
3604         INIT_LIST_HEAD(&cfg_priv->eq_list);
3605 }
3606
3607 static void brcmf_flush_eq(struct brcmf_cfg80211_priv *cfg_priv)
3608 {
3609         struct brcmf_cfg80211_event_q *e;
3610
3611         brcmf_lock_eq(cfg_priv);
3612         while (!list_empty(&cfg_priv->eq_list)) {
3613                 e = list_first_entry(&cfg_priv->eq_list,
3614                                      struct brcmf_cfg80211_event_q, eq_list);
3615                 list_del(&e->eq_list);
3616                 kfree(e);
3617         }
3618         brcmf_unlock_eq(cfg_priv);
3619 }
3620
3621 /*
3622 * retrieve first queued event from head
3623 */
3624
3625 static struct brcmf_cfg80211_event_q *brcmf_deq_event(
3626         struct brcmf_cfg80211_priv *cfg_priv)
3627 {
3628         struct brcmf_cfg80211_event_q *e = NULL;
3629
3630         brcmf_lock_eq(cfg_priv);
3631         if (likely(!list_empty(&cfg_priv->eq_list))) {
3632                 e = list_first_entry(&cfg_priv->eq_list,
3633                                      struct brcmf_cfg80211_event_q, eq_list);
3634                 list_del(&e->eq_list);
3635         }
3636         brcmf_unlock_eq(cfg_priv);
3637
3638         return e;
3639 }
3640
3641 /*
3642 ** push event to tail of the queue
3643 */
3644
3645 static s32
3646 brcmf_enq_event(struct brcmf_cfg80211_priv *cfg_priv, u32 event,
3647                 const struct brcmf_event_msg *msg)
3648 {
3649         struct brcmf_cfg80211_event_q *e;
3650         s32 err = 0;
3651
3652         e = kzalloc(sizeof(struct brcmf_cfg80211_event_q), GFP_KERNEL);
3653         if (unlikely(!e)) {
3654                 WL_ERR("event alloc failed\n");
3655                 return -ENOMEM;
3656         }
3657
3658         e->etype = event;
3659         memcpy(&e->emsg, msg, sizeof(struct brcmf_event_msg));
3660
3661         brcmf_lock_eq(cfg_priv);
3662         list_add_tail(&e->eq_list, &cfg_priv->eq_list);
3663         brcmf_unlock_eq(cfg_priv);
3664
3665         return err;
3666 }
3667
3668 static void brcmf_put_event(struct brcmf_cfg80211_event_q *e)
3669 {
3670         kfree(e);
3671 }
3672
3673 void brcmf_cfg80211_sdio_func(void *func)
3674 {
3675         cfg80211_sdio_func = (struct sdio_func *)func;
3676 }
3677
3678 static void brcmf_clear_sdio_func(void)
3679 {
3680         cfg80211_sdio_func = NULL;
3681 }
3682
3683 struct sdio_func *brcmf_cfg80211_get_sdio_func(void)
3684 {
3685         return cfg80211_sdio_func;
3686 }
3687
3688 static s32 brcmf_dongle_mode(struct net_device *ndev, s32 iftype)
3689 {
3690         s32 infra = 0;
3691         s32 err = 0;
3692
3693         switch (iftype) {
3694         case NL80211_IFTYPE_MONITOR:
3695         case NL80211_IFTYPE_WDS:
3696                 WL_ERR("type (%d) : currently we do not support this mode\n",
3697                        iftype);
3698                 err = -EINVAL;
3699                 return err;
3700         case NL80211_IFTYPE_ADHOC:
3701                 infra = 0;
3702                 break;
3703         case NL80211_IFTYPE_STATION:
3704                 infra = 1;
3705                 break;
3706         default:
3707                 err = -EINVAL;
3708                 WL_ERR("invalid type (%d)\n", iftype);
3709                 return err;
3710         }
3711         infra = cpu_to_le32(infra);
3712         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_INFRA, &infra, sizeof(infra));
3713         if (unlikely(err)) {
3714                 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
3715                 return err;
3716         }
3717
3718         return 0;
3719 }
3720
3721 static s32 brcmf_dongle_eventmsg(struct net_device *ndev)
3722 {
3723         /* Room for "event_msgs" + '\0' + bitvec */
3724         s8 iovbuf[BRCMF_EVENTING_MASK_LEN + 12];
3725         s8 eventmask[BRCMF_EVENTING_MASK_LEN];
3726         s32 err = 0;
3727
3728         WL_TRACE("Enter\n");
3729
3730         /* Setup event_msgs */
3731         brcmu_mkiovar("event_msgs", eventmask, BRCMF_EVENTING_MASK_LEN, iovbuf,
3732                     sizeof(iovbuf));
3733         err = brcmf_dev_ioctl(ndev, BRCMF_C_GET_VAR, iovbuf, sizeof(iovbuf));
3734         if (unlikely(err)) {
3735                 WL_ERR("Get event_msgs error (%d)\n", err);
3736                 goto dongle_eventmsg_out;
3737         }
3738         memcpy(eventmask, iovbuf, BRCMF_EVENTING_MASK_LEN);
3739
3740         setbit(eventmask, BRCMF_E_SET_SSID);
3741         setbit(eventmask, BRCMF_E_ROAM);
3742         setbit(eventmask, BRCMF_E_PRUNE);
3743         setbit(eventmask, BRCMF_E_AUTH);
3744         setbit(eventmask, BRCMF_E_REASSOC);
3745         setbit(eventmask, BRCMF_E_REASSOC_IND);
3746         setbit(eventmask, BRCMF_E_DEAUTH_IND);
3747         setbit(eventmask, BRCMF_E_DISASSOC_IND);
3748         setbit(eventmask, BRCMF_E_DISASSOC);
3749         setbit(eventmask, BRCMF_E_JOIN);
3750         setbit(eventmask, BRCMF_E_ASSOC_IND);
3751         setbit(eventmask, BRCMF_E_PSK_SUP);
3752         setbit(eventmask, BRCMF_E_LINK);
3753         setbit(eventmask, BRCMF_E_NDIS_LINK);
3754         setbit(eventmask, BRCMF_E_MIC_ERROR);
3755         setbit(eventmask, BRCMF_E_PMKID_CACHE);
3756         setbit(eventmask, BRCMF_E_TXFAIL);
3757         setbit(eventmask, BRCMF_E_JOIN_START);
3758         setbit(eventmask, BRCMF_E_SCAN_COMPLETE);
3759
3760         brcmu_mkiovar("event_msgs", eventmask, BRCMF_EVENTING_MASK_LEN, iovbuf,
3761                     sizeof(iovbuf));
3762         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3763         if (unlikely(err)) {
3764                 WL_ERR("Set event_msgs error (%d)\n", err);
3765                 goto dongle_eventmsg_out;
3766         }
3767
3768 dongle_eventmsg_out:
3769         WL_TRACE("Exit\n");
3770         return err;
3771 }
3772
3773 static s32
3774 brcmf_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
3775 {
3776         s8 iovbuf[32];
3777         s32 roamtrigger[2];
3778         s32 roam_delta[2];
3779         s32 err = 0;
3780
3781         /*
3782          * Setup timeout if Beacons are lost and roam is
3783          * off to report link down
3784          */
3785         if (roamvar) {
3786                 brcmu_mkiovar("bcn_timeout", (char *)&bcn_timeout,
3787                         sizeof(bcn_timeout), iovbuf, sizeof(iovbuf));
3788                 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_VAR,
3789                                    iovbuf, sizeof(iovbuf));
3790                 if (unlikely(err)) {
3791                         WL_ERR("bcn_timeout error (%d)\n", err);
3792                         goto dongle_rom_out;
3793                 }
3794         }
3795
3796         /*
3797          * Enable/Disable built-in roaming to allow supplicant
3798          * to take care of roaming
3799          */
3800         WL_INFO("Internal Roaming = %s\n", roamvar ? "Off" : "On");
3801         brcmu_mkiovar("roam_off", (char *)&roamvar,
3802                                 sizeof(roamvar), iovbuf, sizeof(iovbuf));
3803         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3804         if (unlikely(err)) {
3805                 WL_ERR("roam_off error (%d)\n", err);
3806                 goto dongle_rom_out;
3807         }
3808
3809         roamtrigger[0] = WL_ROAM_TRIGGER_LEVEL;
3810         roamtrigger[1] = BRCM_BAND_ALL;
3811         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_ROAM_TRIGGER,
3812                         (void *)roamtrigger, sizeof(roamtrigger));
3813         if (unlikely(err)) {
3814                 WL_ERR("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
3815                 goto dongle_rom_out;
3816         }
3817
3818         roam_delta[0] = WL_ROAM_DELTA;
3819         roam_delta[1] = BRCM_BAND_ALL;
3820         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_ROAM_DELTA,
3821                                 (void *)roam_delta, sizeof(roam_delta));
3822         if (unlikely(err)) {
3823                 WL_ERR("WLC_SET_ROAM_DELTA error (%d)\n", err);
3824                 goto dongle_rom_out;
3825         }
3826
3827 dongle_rom_out:
3828         return err;
3829 }
3830
3831 static s32
3832 brcmf_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
3833                 s32 scan_unassoc_time, s32 scan_passive_time)
3834 {
3835         s32 err = 0;
3836
3837         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_SCAN_CHANNEL_TIME,
3838                            &scan_assoc_time, sizeof(scan_assoc_time));
3839         if (err) {
3840                 if (err == -EOPNOTSUPP)
3841                         WL_INFO("Scan assoc time is not supported\n");
3842                 else
3843                         WL_ERR("Scan assoc time error (%d)\n", err);
3844                 goto dongle_scantime_out;
3845         }
3846         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_SCAN_UNASSOC_TIME,
3847                            &scan_unassoc_time, sizeof(scan_unassoc_time));
3848         if (err) {
3849                 if (err == -EOPNOTSUPP)
3850                         WL_INFO("Scan unassoc time is not supported\n");
3851                 else
3852                         WL_ERR("Scan unassoc time error (%d)\n", err);
3853                 goto dongle_scantime_out;
3854         }
3855
3856         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_SCAN_PASSIVE_TIME,
3857                            &scan_passive_time, sizeof(scan_passive_time));
3858         if (err) {
3859                 if (err == -EOPNOTSUPP)
3860                         WL_INFO("Scan passive time is not supported\n");
3861                 else
3862                         WL_ERR("Scan passive time error (%d)\n", err);
3863                 goto dongle_scantime_out;
3864         }
3865
3866 dongle_scantime_out:
3867         return err;
3868 }
3869
3870 s32 brcmf_config_dongle(struct brcmf_cfg80211_priv *cfg_priv, bool need_lock)
3871 {
3872         struct net_device *ndev;
3873         struct wireless_dev *wdev;
3874         s32 power_mode;
3875         s32 err = 0;
3876
3877         if (cfg_priv->dongle_up)
3878                 return err;
3879
3880         ndev = cfg_to_ndev(cfg_priv);
3881         wdev = ndev->ieee80211_ptr;
3882         if (need_lock)
3883                 rtnl_lock();
3884
3885         brcmf_dongle_scantime(ndev, WL_SCAN_CHANNEL_TIME,
3886                         WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
3887
3888         err = brcmf_dongle_eventmsg(ndev);
3889         if (unlikely(err))
3890                 goto default_conf_out;
3891
3892         power_mode = cfg_priv->pwr_save ? PM_FAST : PM_OFF;
3893         power_mode = cpu_to_le32(power_mode);
3894         err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_PM,
3895                                 &power_mode, sizeof(power_mode));
3896         if (err)
3897                 goto default_conf_out;
3898         WL_INFO("power save set to %s\n",
3899                 (power_mode ? "enabled" : "disabled"));
3900
3901         err = brcmf_dongle_roam(ndev, (cfg_priv->roam_on ? 0 : 1),
3902                                 WL_BEACON_TIMEOUT);
3903         if (unlikely(err))
3904                 goto default_conf_out;
3905         err = brcmf_dongle_mode(ndev, wdev->iftype);
3906         if (unlikely(err && err != -EINPROGRESS))
3907                 goto default_conf_out;
3908         err = brcmf_dongle_probecap(cfg_priv);
3909         if (unlikely(err))
3910                 goto default_conf_out;
3911
3912         /* -EINPROGRESS: Call commit handler */
3913
3914 default_conf_out:
3915         if (need_lock)
3916                 rtnl_unlock();
3917
3918         cfg_priv->dongle_up = true;
3919
3920         return err;
3921
3922 }
3923
3924 static s32 wl_update_wiphybands(struct brcmf_cfg80211_priv *cfg_priv)
3925 {
3926         struct wiphy *wiphy;
3927         s32 phy_list;
3928         s8 phy;
3929         s32 err = 0;
3930
3931         err = brcmf_dev_ioctl(cfg_to_ndev(cfg_priv), BRCM_GET_PHYLIST,
3932                               &phy_list, sizeof(phy_list));
3933         if (unlikely(err)) {
3934                 WL_ERR("error (%d)\n", err);
3935                 return err;
3936         }
3937
3938         phy = ((char *)&phy_list)[1];
3939         WL_INFO("%c phy\n", phy);
3940         if (phy == 'n' || phy == 'a') {
3941                 wiphy = cfg_to_wiphy(cfg_priv);
3942                 wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
3943         }
3944
3945         return err;
3946 }
3947
3948 static s32 __brcmf_cfg80211_up(struct brcmf_cfg80211_priv *cfg_priv)
3949 {
3950         s32 err = 0;
3951
3952         set_bit(WL_STATUS_READY, &cfg_priv->status);
3953
3954         brcmf_debugfs_add_netdev_params(cfg_priv);
3955
3956         err = brcmf_config_dongle(cfg_priv, false);
3957         if (unlikely(err))
3958                 return err;
3959
3960         brcmf_invoke_iscan(cfg_priv);
3961
3962         return err;
3963 }
3964
3965 static s32 __brcmf_cfg80211_down(struct brcmf_cfg80211_priv *cfg_priv)
3966 {
3967         /*
3968          * While going down, if associated with AP disassociate
3969          * from AP to save power
3970          */
3971         if ((test_bit(WL_STATUS_CONNECTED, &cfg_priv->status) ||
3972              test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) &&
3973              test_bit(WL_STATUS_READY, &cfg_priv->status)) {
3974                 WL_INFO("Disassociating from AP");
3975                 brcmf_link_down(cfg_priv);
3976
3977                 /* Make sure WPA_Supplicant receives all the event
3978                    generated due to DISASSOC call to the fw to keep
3979                    the state fw and WPA_Supplicant state consistent
3980                  */
3981                 rtnl_unlock();
3982                 brcmf_delay(500);
3983                 rtnl_lock();
3984         }
3985
3986         set_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
3987         brcmf_term_iscan(cfg_priv);
3988         if (cfg_priv->scan_request) {
3989                 cfg80211_scan_done(cfg_priv->scan_request, true);
3990                 /* May need to perform this to cover rmmod */
3991                 /* wl_set_mpc(cfg_to_ndev(wl), 1); */
3992                 cfg_priv->scan_request = NULL;
3993         }
3994         clear_bit(WL_STATUS_READY, &cfg_priv->status);
3995         clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
3996         clear_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
3997
3998         brcmf_debugfs_remove_netdev(cfg_priv);
3999
4000         return 0;
4001 }
4002
4003 s32 brcmf_cfg80211_up(void)
4004 {
4005         struct brcmf_cfg80211_priv *cfg_priv;
4006         s32 err = 0;
4007
4008         cfg_priv = WL_PRIV_GET();
4009         mutex_lock(&cfg_priv->usr_sync);
4010         err = __brcmf_cfg80211_up(cfg_priv);
4011         mutex_unlock(&cfg_priv->usr_sync);
4012
4013         return err;
4014 }
4015
4016 s32 brcmf_cfg80211_down(void)
4017 {
4018         struct brcmf_cfg80211_priv *cfg_priv;
4019         s32 err = 0;
4020
4021         cfg_priv = WL_PRIV_GET();
4022         mutex_lock(&cfg_priv->usr_sync);
4023         err = __brcmf_cfg80211_down(cfg_priv);
4024         mutex_unlock(&cfg_priv->usr_sync);
4025
4026         return err;
4027 }
4028
4029 static s32 brcmf_dongle_probecap(struct brcmf_cfg80211_priv *cfg_priv)
4030 {
4031         return wl_update_wiphybands(cfg_priv);
4032 }
4033
4034 static void *brcmf_read_prof(struct brcmf_cfg80211_priv *cfg_priv, s32 item)
4035 {
4036         switch (item) {
4037         case WL_PROF_SEC:
4038                 return &cfg_priv->profile->sec;
4039         case WL_PROF_BSSID:
4040                 return &cfg_priv->profile->bssid;
4041         case WL_PROF_SSID:
4042                 return &cfg_priv->profile->ssid;
4043         }
4044         WL_ERR("invalid item (%d)\n", item);
4045         return NULL;
4046 }
4047
4048 static s32
4049 brcmf_update_prof(struct brcmf_cfg80211_priv *cfg_priv,
4050                   const struct brcmf_event_msg *e, void *data, s32 item)
4051 {
4052         s32 err = 0;
4053         struct brcmf_ssid *ssid;
4054
4055         switch (item) {
4056         case WL_PROF_SSID:
4057                 ssid = (struct brcmf_ssid *) data;
4058                 memset(cfg_priv->profile->ssid.SSID, 0,
4059                        sizeof(cfg_priv->profile->ssid.SSID));
4060                 memcpy(cfg_priv->profile->ssid.SSID,
4061                        ssid->SSID, ssid->SSID_len);
4062                 cfg_priv->profile->ssid.SSID_len = ssid->SSID_len;
4063                 break;
4064         case WL_PROF_BSSID:
4065                 if (data)
4066                         memcpy(cfg_priv->profile->bssid, data, ETH_ALEN);
4067                 else
4068                         memset(cfg_priv->profile->bssid, 0, ETH_ALEN);
4069                 break;
4070         case WL_PROF_SEC:
4071                 memcpy(&cfg_priv->profile->sec, data,
4072                        sizeof(cfg_priv->profile->sec));
4073                 break;
4074         case WL_PROF_BEACONINT:
4075                 cfg_priv->profile->beacon_interval = *(u16 *)data;
4076                 break;
4077         case WL_PROF_DTIMPERIOD:
4078                 cfg_priv->profile->dtim_period = *(u8 *)data;
4079                 break;
4080         default:
4081                 WL_ERR("unsupported item (%d)\n", item);
4082                 err = -EOPNOTSUPP;
4083                 break;
4084         }
4085
4086         return err;
4087 }
4088
4089 static bool brcmf_is_ibssmode(struct brcmf_cfg80211_priv *cfg_priv)
4090 {
4091         return cfg_priv->conf->mode == WL_MODE_IBSS;
4092 }
4093
4094 static __used s32 brcmf_add_ie(struct brcmf_cfg80211_priv *cfg_priv,
4095                                u8 t, u8 l, u8 *v)
4096 {
4097         struct brcmf_cfg80211_ie *ie = &cfg_priv->ie;
4098         s32 err = 0;
4099
4100         if (unlikely(ie->offset + l + 2 > WL_TLV_INFO_MAX)) {
4101                 WL_ERR("ei crosses buffer boundary\n");
4102                 return -ENOSPC;
4103         }
4104         ie->buf[ie->offset] = t;
4105         ie->buf[ie->offset + 1] = l;
4106         memcpy(&ie->buf[ie->offset + 2], v, l);
4107         ie->offset += l + 2;
4108
4109         return err;
4110 }
4111
4112 static void brcmf_link_down(struct brcmf_cfg80211_priv *cfg_priv)
4113 {
4114         struct net_device *dev = NULL;
4115         s32 err = 0;
4116
4117         WL_TRACE("Enter\n");
4118
4119         if (cfg_priv->link_up) {
4120                 dev = cfg_to_ndev(cfg_priv);
4121                 WL_INFO("Call WLC_DISASSOC to stop excess roaming\n ");
4122                 err = brcmf_dev_ioctl(dev, BRCMF_C_DISASSOC, NULL, 0);
4123                 if (unlikely(err))
4124                         WL_ERR("WLC_DISASSOC failed (%d)\n", err);
4125                 cfg_priv->link_up = false;
4126         }
4127         WL_TRACE("Exit\n");
4128 }
4129
4130 static void brcmf_lock_eq(struct brcmf_cfg80211_priv *cfg_priv)
4131 {
4132         spin_lock_irq(&cfg_priv->eq_lock);
4133 }
4134
4135 static void brcmf_unlock_eq(struct brcmf_cfg80211_priv *cfg_priv)
4136 {
4137         spin_unlock_irq(&cfg_priv->eq_lock);
4138 }
4139
4140 static void brcmf_init_eq_lock(struct brcmf_cfg80211_priv *cfg_priv)
4141 {
4142         spin_lock_init(&cfg_priv->eq_lock);
4143 }
4144
4145 static void brcmf_delay(u32 ms)
4146 {
4147         if (ms < 1000 / HZ) {
4148                 cond_resched();
4149                 mdelay(ms);
4150         } else {
4151                 msleep(ms);
4152         }
4153 }
4154
4155 static void brcmf_set_drvdata(struct brcmf_cfg80211_dev *dev, void *data)
4156 {
4157         dev->driver_data = data;
4158 }
4159
4160 static void *brcmf_get_drvdata(struct brcmf_cfg80211_dev *dev)
4161 {
4162         void *data = NULL;
4163
4164         if (dev)
4165                 data = dev->driver_data;
4166         return data;
4167 }
4168
4169 static void brcmf_set_mpc(struct net_device *ndev, int mpc)
4170 {
4171         s32 err = 0;
4172         struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
4173
4174         if (test_bit(WL_STATUS_READY, &cfg_priv->status)) {
4175                 err = brcmf_dev_intvar_set(ndev, "mpc", mpc);
4176                 if (unlikely(err)) {
4177                         WL_ERR("fail to set mpc\n");
4178                         return;
4179                 }
4180                 WL_INFO("MPC : %d\n", mpc);
4181         }
4182 }
4183
4184 static int brcmf_debugfs_add_netdev_params(struct brcmf_cfg80211_priv *cfg_priv)
4185 {
4186         char buf[10+IFNAMSIZ];
4187         struct dentry *fd;
4188         s32 err = 0;
4189
4190         sprintf(buf, "netdev:%s", cfg_to_ndev(cfg_priv)->name);
4191         cfg_priv->debugfsdir = debugfs_create_dir(buf,
4192                                         cfg_to_wiphy(cfg_priv)->debugfsdir);
4193
4194         fd = debugfs_create_u16("beacon_int", S_IRUGO, cfg_priv->debugfsdir,
4195                 (u16 *)&cfg_priv->profile->beacon_interval);
4196         if (!fd) {
4197                 err = -ENOMEM;
4198                 goto err_out;
4199         }
4200
4201         fd = debugfs_create_u8("dtim_period", S_IRUGO, cfg_priv->debugfsdir,
4202                 (u8 *)&cfg_priv->profile->dtim_period);
4203         if (!fd) {
4204                 err = -ENOMEM;
4205                 goto err_out;
4206         }
4207
4208 err_out:
4209         return err;
4210 }
4211
4212 static void brcmf_debugfs_remove_netdev(struct brcmf_cfg80211_priv *cfg_priv)
4213 {
4214         debugfs_remove_recursive(cfg_priv->debugfsdir);
4215         cfg_priv->debugfsdir = NULL;
4216 }