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