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