drivers/staging/brcm80211/brcmfmac/wl_cfg80211.c

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