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