drivers/staging/brcm80211/brcmfmac/wl_cfg80211.c

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