2 * Copyright (c) 2010 Broadcom Corporation
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.
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.
17 #include <linux/kernel.h>
18 #include <linux/if_arp.h>
19 #include <linux/sched.h>
20 #include <linux/kthread.h>
21 #include <linux/netdevice.h>
22 #include <linux/sched.h>
23 #include <linux/etherdevice.h>
24 #include <linux/wireless.h>
25 #include <linux/ieee80211.h>
26 #include <linux/mmc/sdio_func.h>
27 #include <linux/firmware.h>
28 #include <linux/uaccess.h>
29 #include <net/cfg80211.h>
30 #include <net/rtnetlink.h>
32 #include <brcmu_utils.h>
34 #include <brcmu_wifi.h>
35 #include "dngl_stats.h"
37 #include "wl_cfg80211.h"
39 void brcmf_sdioh_set_host_pm_flags(int flag);
41 static struct sdio_func *cfg80211_sdio_func;
42 static struct wl_dev *wl_cfg80211_dev;
43 static const u8 ether_bcast[ETH_ALEN] = {255, 255, 255, 255, 255, 255};
45 u32 brcmf_dbg_level = WL_DBG_ERR;
47 #define WL_4329_FW_FILE "brcm/bcm4329-fullmac-4.bin"
48 #define WL_4329_NVRAM_FILE "brcm/bcm4329-fullmac-4.txt"
51 ** cfg80211_ops api/callback list
53 static s32 wl_cfg80211_change_iface(struct wiphy *wiphy,
54 struct net_device *ndev,
55 enum nl80211_iftype type, u32 *flags,
56 struct vif_params *params);
57 static s32 __wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
58 struct cfg80211_scan_request *request,
59 struct cfg80211_ssid *this_ssid);
60 static s32 wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
61 struct cfg80211_scan_request *request);
62 static s32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed);
63 static s32 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
64 struct cfg80211_ibss_params *params);
65 static s32 wl_cfg80211_leave_ibss(struct wiphy *wiphy,
66 struct net_device *dev);
67 static s32 wl_cfg80211_get_station(struct wiphy *wiphy,
68 struct net_device *dev, u8 *mac,
69 struct station_info *sinfo);
70 static s32 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
71 struct net_device *dev, bool enabled,
73 static s32 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
74 struct net_device *dev,
76 const struct cfg80211_bitrate_mask
78 static int wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
79 struct cfg80211_connect_params *sme);
80 static s32 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
82 static s32 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
83 enum nl80211_tx_power_setting type,
85 static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm);
86 static s32 wl_cfg80211_config_default_key(struct wiphy *wiphy,
87 struct net_device *dev, u8 key_idx,
88 bool unicast, bool multicast);
89 static s32 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
90 u8 key_idx, bool pairwise, const u8 *mac_addr,
91 struct key_params *params);
92 static s32 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
93 u8 key_idx, bool pairwise, const u8 *mac_addr);
94 static s32 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
95 u8 key_idx, bool pairwise, const u8 *mac_addr,
96 void *cookie, void (*callback) (void *cookie,
100 static s32 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
101 struct net_device *dev,
103 static s32 wl_cfg80211_resume(struct wiphy *wiphy);
104 static s32 wl_cfg80211_suspend(struct wiphy *wiphy,
105 struct cfg80211_wowlan *wow);
106 static s32 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
107 struct cfg80211_pmksa *pmksa);
108 static s32 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
109 struct cfg80211_pmksa *pmksa);
110 static s32 wl_cfg80211_flush_pmksa(struct wiphy *wiphy,
111 struct net_device *dev);
113 ** event & event Q handlers for cfg80211 interfaces
115 static s32 wl_create_event_handler(struct wl_priv *wl);
116 static void wl_destroy_event_handler(struct wl_priv *wl);
117 static s32 wl_event_handler(void *data);
118 static void wl_init_eq(struct wl_priv *wl);
119 static void wl_flush_eq(struct wl_priv *wl);
120 static void wl_lock_eq(struct wl_priv *wl);
121 static void wl_unlock_eq(struct wl_priv *wl);
122 static void wl_init_eq_lock(struct wl_priv *wl);
123 static void wl_init_eloop_handler(struct wl_event_loop *el);
124 static struct wl_event_q *wl_deq_event(struct wl_priv *wl);
125 static s32 wl_enq_event(struct wl_priv *wl, u32 type,
126 const brcmf_event_msg_t *msg, void *data);
127 static void wl_put_event(struct wl_event_q *e);
128 static void wl_wakeup_event(struct wl_priv *wl);
129 static s32 wl_notify_connect_status(struct wl_priv *wl,
130 struct net_device *ndev,
131 const brcmf_event_msg_t *e, void *data);
132 static s32 wl_notify_roaming_status(struct wl_priv *wl,
133 struct net_device *ndev,
134 const brcmf_event_msg_t *e, void *data);
135 static s32 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
136 const brcmf_event_msg_t *e, void *data);
137 static s32 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
138 const brcmf_event_msg_t *e, void *data,
140 static s32 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
141 const brcmf_event_msg_t *e, void *data);
142 static s32 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
143 const brcmf_event_msg_t *e, void *data);
146 ** register/deregister sdio function
148 struct sdio_func *wl_cfg80211_get_sdio_func(void);
149 static void wl_clear_sdio_func(void);
154 static s32 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
156 static __used s32 wl_dev_bufvar_set(struct net_device *dev, s8 *name,
158 static s32 wl_dev_intvar_set(struct net_device *dev, s8 *name, s32 val);
159 static s32 wl_dev_intvar_get(struct net_device *dev, s8 *name,
161 static s32 wl_dev_ioctl(struct net_device *dev, u32 cmd, void *arg,
165 ** cfg80211 set_wiphy_params utilities
167 static s32 wl_set_frag(struct net_device *dev, u32 frag_threshold);
168 static s32 wl_set_rts(struct net_device *dev, u32 frag_threshold);
169 static s32 wl_set_retry(struct net_device *dev, u32 retry, bool l);
172 ** wl profile utilities
174 static s32 wl_update_prof(struct wl_priv *wl, const brcmf_event_msg_t *e,
175 void *data, s32 item);
176 static void *wl_read_prof(struct wl_priv *wl, s32 item);
177 static void wl_init_prof(struct wl_profile *prof);
180 ** cfg80211 connect utilites
182 static s32 wl_set_wpa_version(struct net_device *dev,
183 struct cfg80211_connect_params *sme);
184 static s32 wl_set_auth_type(struct net_device *dev,
185 struct cfg80211_connect_params *sme);
186 static s32 wl_set_set_cipher(struct net_device *dev,
187 struct cfg80211_connect_params *sme);
188 static s32 wl_set_key_mgmt(struct net_device *dev,
189 struct cfg80211_connect_params *sme);
190 static s32 wl_set_set_sharedkey(struct net_device *dev,
191 struct cfg80211_connect_params *sme);
192 static s32 wl_get_assoc_ies(struct wl_priv *wl);
193 static void wl_clear_assoc_ies(struct wl_priv *wl);
194 static void wl_ch_to_chanspec(int ch,
195 struct wl_join_params *join_params, size_t *join_params_size);
198 ** information element utilities
200 static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v);
201 static s32 wl_mode_to_nl80211_iftype(s32 mode);
202 static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
204 static void wl_free_wdev(struct wl_priv *wl);
205 static s32 wl_inform_bss(struct wl_priv *wl);
206 static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi);
207 static s32 wl_update_bss_info(struct wl_priv *wl);
208 static s32 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
209 u8 key_idx, const u8 *mac_addr,
210 struct key_params *params);
213 ** key indianess swap utilities
215 static void swap_key_from_BE(struct wl_wsec_key *key);
216 static void swap_key_to_BE(struct wl_wsec_key *key);
219 ** wl_priv memory init/deinit utilities
221 static s32 wl_init_priv_mem(struct wl_priv *wl);
222 static void wl_deinit_priv_mem(struct wl_priv *wl);
224 static void wl_delay(u32 ms);
227 ** store/restore cfg80211 instance data
229 static void wl_set_drvdata(struct wl_dev *dev, void *data);
230 static void *wl_get_drvdata(struct wl_dev *dev);
233 ** ibss mode utilities
235 static bool wl_is_ibssmode(struct wl_priv *wl);
238 ** dongle up/down , default configuration utilities
240 static bool wl_is_linkdown(struct wl_priv *wl, const brcmf_event_msg_t *e);
241 static bool wl_is_linkup(struct wl_priv *wl, const brcmf_event_msg_t *e);
242 static bool wl_is_nonetwork(struct wl_priv *wl, const brcmf_event_msg_t *e);
243 static void wl_link_down(struct wl_priv *wl);
244 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
245 static s32 __wl_cfg80211_up(struct wl_priv *wl);
246 static s32 __wl_cfg80211_down(struct wl_priv *wl);
247 static s32 wl_dongle_probecap(struct wl_priv *wl);
248 static void wl_init_conf(struct wl_conf *conf);
251 ** dongle configuration utilities
253 #ifndef EMBEDDED_PLATFORM
254 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
255 static s32 wl_dongle_country(struct net_device *ndev, u8 ccode);
256 static s32 wl_dongle_up(struct net_device *ndev, u32 up);
257 static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode);
258 static s32 wl_dongle_glom(struct net_device *ndev, u32 glom,
260 static s32 wl_dongle_offload(struct net_device *ndev, s32 arpoe,
262 static s32 wl_pattern_atoh(s8 *src, s8 *dst);
263 static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode);
264 static s32 wl_update_wiphybands(struct wl_priv *wl);
265 #endif /* !EMBEDDED_PLATFORM */
267 static s32 wl_dongle_eventmsg(struct net_device *ndev);
268 static s32 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
269 s32 scan_unassoc_time, s32 scan_passive_time);
270 static s32 wl_config_dongle(struct wl_priv *wl, bool need_lock);
271 static s32 wl_dongle_roam(struct net_device *ndev, u32 roamvar,
277 static void wl_iscan_timer(unsigned long data);
278 static void wl_term_iscan(struct wl_priv *wl);
279 static s32 wl_init_iscan(struct wl_priv *wl);
280 static s32 wl_iscan_thread(void *data);
281 static s32 wl_dev_iovar_setbuf(struct net_device *dev, s8 *iovar,
282 void *param, s32 paramlen, void *bufptr,
284 static s32 wl_dev_iovar_getbuf(struct net_device *dev, s8 *iovar,
285 void *param, s32 paramlen, void *bufptr,
287 static s32 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid,
289 static s32 wl_do_iscan(struct wl_priv *wl);
290 static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan);
291 static s32 wl_invoke_iscan(struct wl_priv *wl);
292 static s32 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
293 struct wl_scan_results **bss_list);
294 static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted);
295 static void wl_init_iscan_eloop(struct wl_iscan_eloop *el);
296 static s32 wl_iscan_done(struct wl_priv *wl);
297 static s32 wl_iscan_pending(struct wl_priv *wl);
298 static s32 wl_iscan_inprogress(struct wl_priv *wl);
299 static s32 wl_iscan_aborted(struct wl_priv *wl);
302 ** fw/nvram downloading handler
304 static void wl_init_fw(struct wl_fw_ctrl *fw);
307 * find most significant bit set
309 static __used u32 wl_find_msb(u16 bit16);
312 * update pmklist to dongle
314 static __used s32 wl_update_pmklist(struct net_device *dev,
315 struct wl_pmk_list *pmk_list, s32 err);
317 static void wl_set_mpc(struct net_device *ndev, int mpc);
322 static int wl_debugfs_add_netdev_params(struct wl_priv *wl);
323 static void wl_debugfs_remove_netdev(struct wl_priv *wl);
325 #define WL_PRIV_GET() \
327 struct wl_iface *ci = wl_get_drvdata(wl_cfg80211_dev); \
328 if (unlikely(!ci)) { \
329 WL_ERR("wl_cfg80211_dev is unavailable\n"); \
335 #define CHECK_SYS_UP() \
337 struct wl_priv *wl = wiphy_to_wl(wiphy); \
338 if (unlikely(!test_bit(WL_STATUS_READY, &wl->status))) { \
339 WL_INFO("device is not ready : status (%d)\n", \
345 #define CHAN2G(_channel, _freq, _flags) { \
346 .band = IEEE80211_BAND_2GHZ, \
347 .center_freq = (_freq), \
348 .hw_value = (_channel), \
350 .max_antenna_gain = 0, \
354 #define CHAN5G(_channel, _flags) { \
355 .band = IEEE80211_BAND_5GHZ, \
356 .center_freq = 5000 + (5 * (_channel)), \
357 .hw_value = (_channel), \
359 .max_antenna_gain = 0, \
363 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
364 #define RATETAB_ENT(_rateid, _flags) \
366 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
367 .hw_value = (_rateid), \
371 static struct ieee80211_rate __wl_rates[] = {
372 RATETAB_ENT(WLC_RATE_1M, 0),
373 RATETAB_ENT(WLC_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
374 RATETAB_ENT(WLC_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
375 RATETAB_ENT(WLC_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
376 RATETAB_ENT(WLC_RATE_6M, 0),
377 RATETAB_ENT(WLC_RATE_9M, 0),
378 RATETAB_ENT(WLC_RATE_12M, 0),
379 RATETAB_ENT(WLC_RATE_18M, 0),
380 RATETAB_ENT(WLC_RATE_24M, 0),
381 RATETAB_ENT(WLC_RATE_36M, 0),
382 RATETAB_ENT(WLC_RATE_48M, 0),
383 RATETAB_ENT(WLC_RATE_54M, 0),
386 #define wl_a_rates (__wl_rates + 4)
387 #define wl_a_rates_size 8
388 #define wl_g_rates (__wl_rates + 0)
389 #define wl_g_rates_size 12
391 static struct ieee80211_channel __wl_2ghz_channels[] = {
408 static struct ieee80211_channel __wl_5ghz_a_channels[] = {
409 CHAN5G(34, 0), CHAN5G(36, 0),
410 CHAN5G(38, 0), CHAN5G(40, 0),
411 CHAN5G(42, 0), CHAN5G(44, 0),
412 CHAN5G(46, 0), CHAN5G(48, 0),
413 CHAN5G(52, 0), CHAN5G(56, 0),
414 CHAN5G(60, 0), CHAN5G(64, 0),
415 CHAN5G(100, 0), CHAN5G(104, 0),
416 CHAN5G(108, 0), CHAN5G(112, 0),
417 CHAN5G(116, 0), CHAN5G(120, 0),
418 CHAN5G(124, 0), CHAN5G(128, 0),
419 CHAN5G(132, 0), CHAN5G(136, 0),
420 CHAN5G(140, 0), CHAN5G(149, 0),
421 CHAN5G(153, 0), CHAN5G(157, 0),
422 CHAN5G(161, 0), CHAN5G(165, 0),
423 CHAN5G(184, 0), CHAN5G(188, 0),
424 CHAN5G(192, 0), CHAN5G(196, 0),
425 CHAN5G(200, 0), CHAN5G(204, 0),
426 CHAN5G(208, 0), CHAN5G(212, 0),
430 static struct ieee80211_channel __wl_5ghz_n_channels[] = {
431 CHAN5G(32, 0), CHAN5G(34, 0),
432 CHAN5G(36, 0), CHAN5G(38, 0),
433 CHAN5G(40, 0), CHAN5G(42, 0),
434 CHAN5G(44, 0), CHAN5G(46, 0),
435 CHAN5G(48, 0), CHAN5G(50, 0),
436 CHAN5G(52, 0), CHAN5G(54, 0),
437 CHAN5G(56, 0), CHAN5G(58, 0),
438 CHAN5G(60, 0), CHAN5G(62, 0),
439 CHAN5G(64, 0), CHAN5G(66, 0),
440 CHAN5G(68, 0), CHAN5G(70, 0),
441 CHAN5G(72, 0), CHAN5G(74, 0),
442 CHAN5G(76, 0), CHAN5G(78, 0),
443 CHAN5G(80, 0), CHAN5G(82, 0),
444 CHAN5G(84, 0), CHAN5G(86, 0),
445 CHAN5G(88, 0), CHAN5G(90, 0),
446 CHAN5G(92, 0), CHAN5G(94, 0),
447 CHAN5G(96, 0), CHAN5G(98, 0),
448 CHAN5G(100, 0), CHAN5G(102, 0),
449 CHAN5G(104, 0), CHAN5G(106, 0),
450 CHAN5G(108, 0), CHAN5G(110, 0),
451 CHAN5G(112, 0), CHAN5G(114, 0),
452 CHAN5G(116, 0), CHAN5G(118, 0),
453 CHAN5G(120, 0), CHAN5G(122, 0),
454 CHAN5G(124, 0), CHAN5G(126, 0),
455 CHAN5G(128, 0), CHAN5G(130, 0),
456 CHAN5G(132, 0), CHAN5G(134, 0),
457 CHAN5G(136, 0), CHAN5G(138, 0),
458 CHAN5G(140, 0), CHAN5G(142, 0),
459 CHAN5G(144, 0), CHAN5G(145, 0),
460 CHAN5G(146, 0), CHAN5G(147, 0),
461 CHAN5G(148, 0), CHAN5G(149, 0),
462 CHAN5G(150, 0), CHAN5G(151, 0),
463 CHAN5G(152, 0), CHAN5G(153, 0),
464 CHAN5G(154, 0), CHAN5G(155, 0),
465 CHAN5G(156, 0), CHAN5G(157, 0),
466 CHAN5G(158, 0), CHAN5G(159, 0),
467 CHAN5G(160, 0), CHAN5G(161, 0),
468 CHAN5G(162, 0), CHAN5G(163, 0),
469 CHAN5G(164, 0), CHAN5G(165, 0),
470 CHAN5G(166, 0), CHAN5G(168, 0),
471 CHAN5G(170, 0), CHAN5G(172, 0),
472 CHAN5G(174, 0), CHAN5G(176, 0),
473 CHAN5G(178, 0), CHAN5G(180, 0),
474 CHAN5G(182, 0), CHAN5G(184, 0),
475 CHAN5G(186, 0), CHAN5G(188, 0),
476 CHAN5G(190, 0), CHAN5G(192, 0),
477 CHAN5G(194, 0), CHAN5G(196, 0),
478 CHAN5G(198, 0), CHAN5G(200, 0),
479 CHAN5G(202, 0), CHAN5G(204, 0),
480 CHAN5G(206, 0), CHAN5G(208, 0),
481 CHAN5G(210, 0), CHAN5G(212, 0),
482 CHAN5G(214, 0), CHAN5G(216, 0),
483 CHAN5G(218, 0), CHAN5G(220, 0),
484 CHAN5G(222, 0), CHAN5G(224, 0),
485 CHAN5G(226, 0), CHAN5G(228, 0),
488 static struct ieee80211_supported_band __wl_band_2ghz = {
489 .band = IEEE80211_BAND_2GHZ,
490 .channels = __wl_2ghz_channels,
491 .n_channels = ARRAY_SIZE(__wl_2ghz_channels),
492 .bitrates = wl_g_rates,
493 .n_bitrates = wl_g_rates_size,
496 static struct ieee80211_supported_band __wl_band_5ghz_a = {
497 .band = IEEE80211_BAND_5GHZ,
498 .channels = __wl_5ghz_a_channels,
499 .n_channels = ARRAY_SIZE(__wl_5ghz_a_channels),
500 .bitrates = wl_a_rates,
501 .n_bitrates = wl_a_rates_size,
504 static struct ieee80211_supported_band __wl_band_5ghz_n = {
505 .band = IEEE80211_BAND_5GHZ,
506 .channels = __wl_5ghz_n_channels,
507 .n_channels = ARRAY_SIZE(__wl_5ghz_n_channels),
508 .bitrates = wl_a_rates,
509 .n_bitrates = wl_a_rates_size,
512 static const u32 __wl_cipher_suites[] = {
513 WLAN_CIPHER_SUITE_WEP40,
514 WLAN_CIPHER_SUITE_WEP104,
515 WLAN_CIPHER_SUITE_TKIP,
516 WLAN_CIPHER_SUITE_CCMP,
517 WLAN_CIPHER_SUITE_AES_CMAC,
520 static void swap_key_from_BE(struct wl_wsec_key *key)
522 key->index = cpu_to_le32(key->index);
523 key->len = cpu_to_le32(key->len);
524 key->algo = cpu_to_le32(key->algo);
525 key->flags = cpu_to_le32(key->flags);
526 key->rxiv.hi = cpu_to_le32(key->rxiv.hi);
527 key->rxiv.lo = cpu_to_le16(key->rxiv.lo);
528 key->iv_initialized = cpu_to_le32(key->iv_initialized);
531 static void swap_key_to_BE(struct wl_wsec_key *key)
533 key->index = le32_to_cpu(key->index);
534 key->len = le32_to_cpu(key->len);
535 key->algo = le32_to_cpu(key->algo);
536 key->flags = le32_to_cpu(key->flags);
537 key->rxiv.hi = le32_to_cpu(key->rxiv.hi);
538 key->rxiv.lo = le16_to_cpu(key->rxiv.lo);
539 key->iv_initialized = le32_to_cpu(key->iv_initialized);
543 wl_dev_ioctl(struct net_device *dev, u32 cmd, void *arg, u32 len)
550 memset(&ioc, 0, sizeof(ioc));
554 strcpy(ifr.ifr_name, dev->name);
555 ifr.ifr_data = (caddr_t)&ioc;
559 err = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
566 wl_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
567 enum nl80211_iftype type, u32 *flags,
568 struct vif_params *params)
570 struct wl_priv *wl = wiphy_to_wl(wiphy);
571 struct wireless_dev *wdev;
579 case NL80211_IFTYPE_MONITOR:
580 case NL80211_IFTYPE_WDS:
581 WL_ERR("type (%d) : currently we do not support this type\n",
584 case NL80211_IFTYPE_ADHOC:
585 wl->conf->mode = WL_MODE_IBSS;
588 case NL80211_IFTYPE_STATION:
589 wl->conf->mode = WL_MODE_BSS;
597 infra = cpu_to_le32(infra);
598 err = wl_dev_ioctl(ndev, BRCMF_C_SET_INFRA, &infra, sizeof(infra));
600 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
603 wdev = ndev->ieee80211_ptr;
607 WL_INFO("IF Type = %s\n",
608 (wl->conf->mode == WL_MODE_IBSS) ? "Adhoc" : "Infra");
616 static void wl_iscan_prep(struct wl_scan_params *params, struct wlc_ssid *ssid)
618 memcpy(params->bssid, ether_bcast, ETH_ALEN);
619 params->bss_type = DOT11_BSSTYPE_ANY;
620 params->scan_type = 0;
621 params->nprobes = -1;
622 params->active_time = -1;
623 params->passive_time = -1;
624 params->home_time = -1;
625 params->channel_num = 0;
627 params->nprobes = cpu_to_le32(params->nprobes);
628 params->active_time = cpu_to_le32(params->active_time);
629 params->passive_time = cpu_to_le32(params->passive_time);
630 params->home_time = cpu_to_le32(params->home_time);
631 if (ssid && ssid->SSID_len)
632 memcpy(¶ms->ssid, ssid, sizeof(wlc_ssid_t));
637 wl_dev_iovar_setbuf(struct net_device *dev, s8 * iovar, void *param,
638 s32 paramlen, void *bufptr, s32 buflen)
642 iolen = brcmu_mkiovar(iovar, param, paramlen, bufptr, buflen);
645 return wl_dev_ioctl(dev, BRCMF_C_SET_VAR, bufptr, iolen);
649 wl_dev_iovar_getbuf(struct net_device *dev, s8 * iovar, void *param,
650 s32 paramlen, void *bufptr, s32 buflen)
654 iolen = brcmu_mkiovar(iovar, param, paramlen, bufptr, buflen);
657 return wl_dev_ioctl(dev, BRCMF_C_GET_VAR, bufptr, buflen);
661 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid, u16 action)
664 (WL_SCAN_PARAMS_FIXED_SIZE + offsetof(wl_iscan_params_t, params));
665 struct wl_iscan_params *params;
668 if (ssid && ssid->SSID_len)
669 params_size += sizeof(struct wlc_ssid);
670 params = kzalloc(params_size, GFP_KERNEL);
671 if (unlikely(!params))
673 BUG_ON(params_size >= BRCMF_C_IOCTL_SMLEN);
675 wl_iscan_prep(¶ms->params, ssid);
677 params->version = cpu_to_le32(ISCAN_REQ_VERSION);
678 params->action = cpu_to_le16(action);
679 params->scan_duration = cpu_to_le16(0);
681 /* params_size += offsetof(wl_iscan_params_t, params); */
682 err = wl_dev_iovar_setbuf(iscan->dev, "iscan", params, params_size,
683 iscan->ioctl_buf, BRCMF_C_IOCTL_SMLEN);
686 WL_INFO("system busy : iscan canceled\n");
688 WL_ERR("error (%d)\n", err);
695 static s32 wl_do_iscan(struct wl_priv *wl)
697 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
698 struct net_device *ndev = wl_to_ndev(wl);
699 struct wlc_ssid ssid;
703 /* Broadcast scan by default */
704 memset(&ssid, 0, sizeof(ssid));
706 iscan->state = WL_ISCAN_STATE_SCANING;
708 passive_scan = wl->active_scan ? 0 : 1;
709 err = wl_dev_ioctl(wl_to_ndev(wl), BRCMF_C_SET_PASSIVE_SCAN,
710 &passive_scan, sizeof(passive_scan));
712 WL_ERR("error (%d)\n", err);
716 wl->iscan_kickstart = true;
717 wl_run_iscan(iscan, &ssid, WL_SCAN_ACTION_START);
718 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
725 __wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
726 struct cfg80211_scan_request *request,
727 struct cfg80211_ssid *this_ssid)
729 struct wl_priv *wl = ndev_to_wl(ndev);
730 struct cfg80211_ssid *ssids;
731 struct wl_scan_req *sr = wl_to_sr(wl);
737 if (unlikely(test_bit(WL_STATUS_SCANNING, &wl->status))) {
738 WL_ERR("Scanning already : status (%d)\n", (int)wl->status);
741 if (unlikely(test_bit(WL_STATUS_SCAN_ABORTING, &wl->status))) {
742 WL_ERR("Scanning being aborted : status (%d)\n",
746 if (test_bit(WL_STATUS_CONNECTING, &wl->status)) {
747 WL_ERR("Connecting : status (%d)\n",
756 ssids = request->ssids;
757 if (wl->iscan_on && (!ssids || !ssids->ssid_len))
761 /* we don't do iscan in ibss */
765 wl->scan_request = request;
766 set_bit(WL_STATUS_SCANNING, &wl->status);
768 err = wl_do_iscan(wl);
774 WL_SCAN("ssid \"%s\", ssid_len (%d)\n",
775 ssids->ssid, ssids->ssid_len);
776 memset(&sr->ssid, 0, sizeof(sr->ssid));
778 min_t(u8, sizeof(sr->ssid.SSID), ssids->ssid_len);
779 if (sr->ssid.SSID_len) {
780 memcpy(sr->ssid.SSID, ssids->ssid, sr->ssid.SSID_len);
781 sr->ssid.SSID_len = cpu_to_le32(sr->ssid.SSID_len);
784 WL_SCAN("Broadcast scan\n");
787 passive_scan = wl->active_scan ? 0 : 1;
788 err = wl_dev_ioctl(ndev, BRCMF_C_SET_PASSIVE_SCAN,
789 &passive_scan, sizeof(passive_scan));
791 WL_ERR("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
795 err = wl_dev_ioctl(ndev, BRCMF_C_SCAN, &sr->ssid,
799 WL_INFO("system busy : scan for \"%s\" canceled\n",
802 WL_ERR("WLC_SCAN error (%d)\n", err);
812 clear_bit(WL_STATUS_SCANNING, &wl->status);
813 wl->scan_request = NULL;
818 wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
819 struct cfg80211_scan_request *request)
827 err = __wl_cfg80211_scan(wiphy, ndev, request, NULL);
829 WL_ERR("scan error (%d)\n", err);
835 static s32 wl_dev_intvar_set(struct net_device *dev, s8 *name, s32 val)
837 s8 buf[BRCMF_C_IOCTL_SMLEN];
841 val = cpu_to_le32(val);
842 len = brcmu_mkiovar(name, (char *)(&val), sizeof(val), buf,
846 err = wl_dev_ioctl(dev, BRCMF_C_SET_VAR, buf, len);
848 WL_ERR("error (%d)\n", err);
854 wl_dev_intvar_get(struct net_device *dev, s8 *name, s32 *retval)
857 s8 buf[BRCMF_C_IOCTL_SMLEN];
865 brcmu_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
868 err = wl_dev_ioctl(dev, BRCMF_C_GET_VAR, &var, len);
870 WL_ERR("error (%d)\n", err);
872 *retval = le32_to_cpu(var.val);
877 static s32 wl_set_rts(struct net_device *dev, u32 rts_threshold)
881 err = wl_dev_intvar_set(dev, "rtsthresh", rts_threshold);
883 WL_ERR("Error (%d)\n", err);
888 static s32 wl_set_frag(struct net_device *dev, u32 frag_threshold)
892 err = wl_dev_intvar_set(dev, "fragthresh", frag_threshold);
894 WL_ERR("Error (%d)\n", err);
899 static s32 wl_set_retry(struct net_device *dev, u32 retry, bool l)
902 u32 cmd = (l ? WLC_SET_LRL : WLC_SET_SRL);
904 retry = cpu_to_le32(retry);
905 err = wl_dev_ioctl(dev, cmd, &retry, sizeof(retry));
907 WL_ERR("cmd (%d) , error (%d)\n", cmd, err);
913 static s32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
915 struct wl_priv *wl = wiphy_to_wl(wiphy);
916 struct net_device *ndev = wl_to_ndev(wl);
922 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
923 (wl->conf->rts_threshold != wiphy->rts_threshold)) {
924 wl->conf->rts_threshold = wiphy->rts_threshold;
925 err = wl_set_rts(ndev, wl->conf->rts_threshold);
929 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
930 (wl->conf->frag_threshold != wiphy->frag_threshold)) {
931 wl->conf->frag_threshold = wiphy->frag_threshold;
932 err = wl_set_frag(ndev, wl->conf->frag_threshold);
936 if (changed & WIPHY_PARAM_RETRY_LONG
937 && (wl->conf->retry_long != wiphy->retry_long)) {
938 wl->conf->retry_long = wiphy->retry_long;
939 err = wl_set_retry(ndev, wl->conf->retry_long, true);
943 if (changed & WIPHY_PARAM_RETRY_SHORT
944 && (wl->conf->retry_short != wiphy->retry_short)) {
945 wl->conf->retry_short = wiphy->retry_short;
946 err = wl_set_retry(ndev, wl->conf->retry_short, false);
957 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
958 struct cfg80211_ibss_params *params)
960 struct wl_priv *wl = wiphy_to_wl(wiphy);
961 struct wl_join_params join_params;
962 size_t join_params_size = 0;
971 WL_CONN("SSID: %s\n", params->ssid);
973 WL_CONN("SSID: NULL, Not supported\n");
977 set_bit(WL_STATUS_CONNECTING, &wl->status);
980 WL_CONN("BSSID: %02X %02X %02X %02X %02X %02X\n",
981 params->bssid[0], params->bssid[1], params->bssid[2],
982 params->bssid[3], params->bssid[4], params->bssid[5]);
984 WL_CONN("No BSSID specified\n");
987 WL_CONN("channel: %d\n", params->channel->center_freq);
989 WL_CONN("no channel specified\n");
991 if (params->channel_fixed)
992 WL_CONN("fixed channel required\n");
994 WL_CONN("no fixed channel required\n");
996 if (params->ie && params->ie_len)
997 WL_CONN("ie len: %d\n", params->ie_len);
999 WL_CONN("no ie specified\n");
1001 if (params->beacon_interval)
1002 WL_CONN("beacon interval: %d\n", params->beacon_interval);
1004 WL_CONN("no beacon interval specified\n");
1006 if (params->basic_rates)
1007 WL_CONN("basic rates: %08X\n", params->basic_rates);
1009 WL_CONN("no basic rates specified\n");
1011 if (params->privacy)
1012 WL_CONN("privacy required\n");
1014 WL_CONN("no privacy required\n");
1016 /* Configure Privacy for starter */
1017 if (params->privacy)
1018 wsec |= WEP_ENABLED;
1020 err = wl_dev_intvar_set(dev, "wsec", wsec);
1021 if (unlikely(err)) {
1022 WL_ERR("wsec failed (%d)\n", err);
1026 /* Configure Beacon Interval for starter */
1027 if (params->beacon_interval)
1028 bcnprd = cpu_to_le32(params->beacon_interval);
1030 bcnprd = cpu_to_le32(100);
1032 err = wl_dev_ioctl(dev, WLC_SET_BCNPRD, &bcnprd, sizeof(bcnprd));
1033 if (unlikely(err)) {
1034 WL_ERR("WLC_SET_BCNPRD failed (%d)\n", err);
1038 /* Configure required join parameter */
1039 memset(&join_params, 0, sizeof(wl_join_params_t));
1042 join_params.ssid.SSID_len =
1043 (params->ssid_len > 32) ? 32 : params->ssid_len;
1044 memcpy(join_params.ssid.SSID, params->ssid, join_params.ssid.SSID_len);
1045 join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1046 join_params_size = sizeof(join_params.ssid);
1047 wl_update_prof(wl, NULL, &join_params.ssid, WL_PROF_SSID);
1050 if (params->bssid) {
1051 memcpy(join_params.params.bssid, params->bssid, ETH_ALEN);
1053 sizeof(join_params.ssid) + WL_ASSOC_PARAMS_FIXED_SIZE;
1055 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1057 wl_update_prof(wl, NULL, &join_params.params.bssid, WL_PROF_BSSID);
1060 if (params->channel) {
1064 ieee80211_frequency_to_channel(
1065 params->channel->center_freq);
1066 if (params->channel_fixed) {
1067 /* adding chanspec */
1068 wl_ch_to_chanspec(wl->channel,
1069 &join_params, &join_params_size);
1072 /* set channel for starter */
1073 target_channel = cpu_to_le32(wl->channel);
1074 err = wl_dev_ioctl(dev, WLC_SET_CHANNEL,
1075 &target_channel, sizeof(target_channel));
1076 if (unlikely(err)) {
1077 WL_ERR("WLC_SET_CHANNEL failed (%d)\n", err);
1083 wl->ibss_starter = false;
1086 err = wl_dev_ioctl(dev, BRCMF_C_SET_SSID,
1087 &join_params, join_params_size);
1088 if (unlikely(err)) {
1089 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1095 clear_bit(WL_STATUS_CONNECTING, &wl->status);
1100 static s32 wl_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1102 struct wl_priv *wl = wiphy_to_wl(wiphy);
1105 WL_TRACE("Enter\n");
1116 wl_set_wpa_version(struct net_device *dev, struct cfg80211_connect_params *sme)
1118 struct wl_priv *wl = ndev_to_wl(dev);
1119 struct wl_security *sec;
1123 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1124 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1125 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1126 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1128 val = WPA_AUTH_DISABLED;
1129 WL_CONN("setting wpa_auth to 0x%0x\n", val);
1130 err = wl_dev_intvar_set(dev, "wpa_auth", val);
1131 if (unlikely(err)) {
1132 WL_ERR("set wpa_auth failed (%d)\n", err);
1135 sec = wl_read_prof(wl, WL_PROF_SEC);
1136 sec->wpa_versions = sme->crypto.wpa_versions;
1141 wl_set_auth_type(struct net_device *dev, struct cfg80211_connect_params *sme)
1143 struct wl_priv *wl = ndev_to_wl(dev);
1144 struct wl_security *sec;
1148 switch (sme->auth_type) {
1149 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1151 WL_CONN("open system\n");
1153 case NL80211_AUTHTYPE_SHARED_KEY:
1155 WL_CONN("shared key\n");
1157 case NL80211_AUTHTYPE_AUTOMATIC:
1159 WL_CONN("automatic\n");
1161 case NL80211_AUTHTYPE_NETWORK_EAP:
1162 WL_CONN("network eap\n");
1165 WL_ERR("invalid auth type (%d)\n", sme->auth_type);
1169 err = wl_dev_intvar_set(dev, "auth", val);
1170 if (unlikely(err)) {
1171 WL_ERR("set auth failed (%d)\n", err);
1174 sec = wl_read_prof(wl, WL_PROF_SEC);
1175 sec->auth_type = sme->auth_type;
1180 wl_set_set_cipher(struct net_device *dev, struct cfg80211_connect_params *sme)
1182 struct wl_priv *wl = ndev_to_wl(dev);
1183 struct wl_security *sec;
1188 if (sme->crypto.n_ciphers_pairwise) {
1189 switch (sme->crypto.ciphers_pairwise[0]) {
1190 case WLAN_CIPHER_SUITE_WEP40:
1191 case WLAN_CIPHER_SUITE_WEP104:
1194 case WLAN_CIPHER_SUITE_TKIP:
1195 pval = TKIP_ENABLED;
1197 case WLAN_CIPHER_SUITE_CCMP:
1200 case WLAN_CIPHER_SUITE_AES_CMAC:
1204 WL_ERR("invalid cipher pairwise (%d)\n",
1205 sme->crypto.ciphers_pairwise[0]);
1209 if (sme->crypto.cipher_group) {
1210 switch (sme->crypto.cipher_group) {
1211 case WLAN_CIPHER_SUITE_WEP40:
1212 case WLAN_CIPHER_SUITE_WEP104:
1215 case WLAN_CIPHER_SUITE_TKIP:
1216 gval = TKIP_ENABLED;
1218 case WLAN_CIPHER_SUITE_CCMP:
1221 case WLAN_CIPHER_SUITE_AES_CMAC:
1225 WL_ERR("invalid cipher group (%d)\n",
1226 sme->crypto.cipher_group);
1231 WL_CONN("pval (%d) gval (%d)\n", pval, gval);
1232 err = wl_dev_intvar_set(dev, "wsec", pval | gval);
1233 if (unlikely(err)) {
1234 WL_ERR("error (%d)\n", err);
1238 sec = wl_read_prof(wl, WL_PROF_SEC);
1239 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1240 sec->cipher_group = sme->crypto.cipher_group;
1246 wl_set_key_mgmt(struct net_device *dev, struct cfg80211_connect_params *sme)
1248 struct wl_priv *wl = ndev_to_wl(dev);
1249 struct wl_security *sec;
1253 if (sme->crypto.n_akm_suites) {
1254 err = wl_dev_intvar_get(dev, "wpa_auth", &val);
1255 if (unlikely(err)) {
1256 WL_ERR("could not get wpa_auth (%d)\n", err);
1259 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1260 switch (sme->crypto.akm_suites[0]) {
1261 case WLAN_AKM_SUITE_8021X:
1262 val = WPA_AUTH_UNSPECIFIED;
1264 case WLAN_AKM_SUITE_PSK:
1268 WL_ERR("invalid cipher group (%d)\n",
1269 sme->crypto.cipher_group);
1272 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1273 switch (sme->crypto.akm_suites[0]) {
1274 case WLAN_AKM_SUITE_8021X:
1275 val = WPA2_AUTH_UNSPECIFIED;
1277 case WLAN_AKM_SUITE_PSK:
1278 val = WPA2_AUTH_PSK;
1281 WL_ERR("invalid cipher group (%d)\n",
1282 sme->crypto.cipher_group);
1287 WL_CONN("setting wpa_auth to %d\n", val);
1288 err = wl_dev_intvar_set(dev, "wpa_auth", val);
1289 if (unlikely(err)) {
1290 WL_ERR("could not set wpa_auth (%d)\n", err);
1294 sec = wl_read_prof(wl, WL_PROF_SEC);
1295 sec->wpa_auth = sme->crypto.akm_suites[0];
1301 wl_set_set_sharedkey(struct net_device *dev,
1302 struct cfg80211_connect_params *sme)
1304 struct wl_priv *wl = ndev_to_wl(dev);
1305 struct wl_security *sec;
1306 struct wl_wsec_key key;
1310 WL_CONN("key len (%d)\n", sme->key_len);
1312 sec = wl_read_prof(wl, WL_PROF_SEC);
1313 WL_CONN("wpa_versions 0x%x cipher_pairwise 0x%x\n",
1314 sec->wpa_versions, sec->cipher_pairwise);
1316 (sec->wpa_versions & (NL80211_WPA_VERSION_1 |
1317 NL80211_WPA_VERSION_2))
1318 && (sec->cipher_pairwise & (WLAN_CIPHER_SUITE_WEP40 |
1319 WLAN_CIPHER_SUITE_WEP104))) {
1320 memset(&key, 0, sizeof(key));
1321 key.len = (u32) sme->key_len;
1322 key.index = (u32) sme->key_idx;
1323 if (unlikely(key.len > sizeof(key.data))) {
1324 WL_ERR("Too long key length (%u)\n", key.len);
1327 memcpy(key.data, sme->key, key.len);
1328 key.flags = WL_PRIMARY_KEY;
1329 switch (sec->cipher_pairwise) {
1330 case WLAN_CIPHER_SUITE_WEP40:
1331 key.algo = CRYPTO_ALGO_WEP1;
1333 case WLAN_CIPHER_SUITE_WEP104:
1334 key.algo = CRYPTO_ALGO_WEP128;
1337 WL_ERR("Invalid algorithm (%d)\n",
1338 sme->crypto.ciphers_pairwise[0]);
1341 /* Set the new key/index */
1342 WL_CONN("key length (%d) key index (%d) algo (%d)\n",
1343 key.len, key.index, key.algo);
1344 WL_CONN("key \"%s\"\n", key.data);
1345 swap_key_from_BE(&key);
1346 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY, &key,
1348 if (unlikely(err)) {
1349 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1352 if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
1353 WL_CONN("set auth_type to shared key\n");
1354 val = 1; /* shared key */
1355 err = wl_dev_intvar_set(dev, "auth", val);
1356 if (unlikely(err)) {
1357 WL_ERR("set auth failed (%d)\n", err);
1367 wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
1368 struct cfg80211_connect_params *sme)
1370 struct wl_priv *wl = wiphy_to_wl(wiphy);
1371 struct ieee80211_channel *chan = sme->channel;
1372 struct wl_join_params join_params;
1373 size_t join_params_size;
1377 WL_TRACE("Enter\n");
1380 if (unlikely(!sme->ssid)) {
1381 WL_ERR("Invalid ssid\n");
1385 set_bit(WL_STATUS_CONNECTING, &wl->status);
1389 ieee80211_frequency_to_channel(chan->center_freq);
1390 WL_CONN("channel (%d), center_req (%d)\n",
1391 wl->channel, chan->center_freq);
1395 WL_INFO("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1397 err = wl_set_wpa_version(dev, sme);
1399 WL_ERR("wl_set_wpa_version failed (%d)\n", err);
1403 err = wl_set_auth_type(dev, sme);
1405 WL_ERR("wl_set_auth_type failed (%d)\n", err);
1409 err = wl_set_set_cipher(dev, sme);
1411 WL_ERR("wl_set_set_cipher failed (%d)\n", err);
1415 err = wl_set_key_mgmt(dev, sme);
1417 WL_ERR("wl_set_key_mgmt failed (%d)\n", err);
1421 err = wl_set_set_sharedkey(dev, sme);
1423 WL_ERR("wl_set_set_sharedkey failed (%d)\n", err);
1427 wl_update_prof(wl, NULL, sme->bssid, WL_PROF_BSSID);
1429 ** Join with specific BSSID and cached SSID
1430 ** If SSID is zero join based on BSSID only
1432 memset(&join_params, 0, sizeof(join_params));
1433 join_params_size = sizeof(join_params.ssid);
1435 join_params.ssid.SSID_len = min(sizeof(join_params.ssid.SSID), sme->ssid_len);
1436 memcpy(&join_params.ssid.SSID, sme->ssid, join_params.ssid.SSID_len);
1437 join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1438 wl_update_prof(wl, NULL, &join_params.ssid, WL_PROF_SSID);
1441 memcpy(join_params.params.bssid, sme->bssid, ETH_ALEN);
1443 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1445 if (join_params.ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
1446 WL_CONN("ssid \"%s\", len (%d)\n",
1447 join_params.ssid.SSID, join_params.ssid.SSID_len);
1450 wl_ch_to_chanspec(wl->channel, &join_params, &join_params_size);
1451 err = wl_dev_ioctl(dev, BRCMF_C_SET_SSID,
1452 &join_params, join_params_size);
1454 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1458 clear_bit(WL_STATUS_CONNECTING, &wl->status);
1464 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1467 struct wl_priv *wl = wiphy_to_wl(wiphy);
1471 WL_TRACE("Enter. Reason code = %d\n", reason_code);
1474 clear_bit(WL_STATUS_CONNECTED, &wl->status);
1476 scbval.val = reason_code;
1477 memcpy(&scbval.ea, wl_read_prof(wl, WL_PROF_BSSID), ETH_ALEN);
1478 scbval.val = cpu_to_le32(scbval.val);
1479 err = wl_dev_ioctl(dev, BRCMF_C_DISASSOC, &scbval,
1482 WL_ERR("error (%d)\n", err);
1484 wl->link_up = false;
1491 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
1492 enum nl80211_tx_power_setting type, s32 dbm)
1495 struct wl_priv *wl = wiphy_to_wl(wiphy);
1496 struct net_device *ndev = wl_to_ndev(wl);
1501 WL_TRACE("Enter\n");
1505 case NL80211_TX_POWER_AUTOMATIC:
1507 case NL80211_TX_POWER_LIMITED:
1509 WL_ERR("TX_POWER_LIMITED - dbm is negative\n");
1514 case NL80211_TX_POWER_FIXED:
1516 WL_ERR("TX_POWER_FIXED - dbm is negative\n");
1522 /* Make sure radio is off or on as far as software is concerned */
1523 disable = WL_RADIO_SW_DISABLE << 16;
1524 disable = cpu_to_le32(disable);
1525 err = wl_dev_ioctl(ndev, BRCMF_C_SET_RADIO, &disable, sizeof(disable));
1527 WL_ERR("WLC_SET_RADIO error (%d)\n", err);
1532 txpwrmw = (u16) dbm;
1533 err = wl_dev_intvar_set(ndev, "qtxpower",
1534 (s32) (brcmu_mw_to_qdbm(txpwrmw)));
1536 WL_ERR("qtxpower error (%d)\n", err);
1537 wl->conf->tx_power = dbm;
1544 static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1546 struct wl_priv *wl = wiphy_to_wl(wiphy);
1547 struct net_device *ndev = wl_to_ndev(wl);
1552 WL_TRACE("Enter\n");
1555 err = wl_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1556 if (unlikely(err)) {
1557 WL_ERR("error (%d)\n", err);
1561 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1562 *dbm = (s32) brcmu_qdbm_to_mw(result);
1570 wl_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
1571 u8 key_idx, bool unicast, bool multicast)
1577 WL_TRACE("Enter\n");
1578 WL_CONN("key index (%d)\n", key_idx);
1581 err = wl_dev_ioctl(dev, BRCMF_C_GET_WSEC, &wsec, sizeof(wsec));
1582 if (unlikely(err)) {
1583 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1587 wsec = le32_to_cpu(wsec);
1588 if (wsec & WEP_ENABLED) {
1589 /* Just select a new current key */
1590 index = (u32) key_idx;
1591 index = cpu_to_le32(index);
1592 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY_PRIMARY, &index,
1595 WL_ERR("error (%d)\n", err);
1603 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
1604 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1606 struct wl_wsec_key key;
1609 memset(&key, 0, sizeof(key));
1610 key.index = (u32) key_idx;
1611 /* Instead of bcast for ea address for default wep keys,
1612 driver needs it to be Null */
1613 if (!is_multicast_ether_addr(mac_addr))
1614 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1615 key.len = (u32) params->key_len;
1616 /* check for key index change */
1619 swap_key_from_BE(&key);
1620 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1621 if (unlikely(err)) {
1622 WL_ERR("key delete error (%d)\n", err);
1626 if (key.len > sizeof(key.data)) {
1627 WL_ERR("Invalid key length (%d)\n", key.len);
1631 WL_CONN("Setting the key index %d\n", key.index);
1632 memcpy(key.data, params->key, key.len);
1634 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1636 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1637 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1638 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1641 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1642 if (params->seq && params->seq_len == 6) {
1645 ivptr = (u8 *) params->seq;
1646 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1647 (ivptr[3] << 8) | ivptr[2];
1648 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1649 key.iv_initialized = true;
1652 switch (params->cipher) {
1653 case WLAN_CIPHER_SUITE_WEP40:
1654 key.algo = CRYPTO_ALGO_WEP1;
1655 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1657 case WLAN_CIPHER_SUITE_WEP104:
1658 key.algo = CRYPTO_ALGO_WEP128;
1659 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1661 case WLAN_CIPHER_SUITE_TKIP:
1662 key.algo = CRYPTO_ALGO_TKIP;
1663 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1665 case WLAN_CIPHER_SUITE_AES_CMAC:
1666 key.algo = CRYPTO_ALGO_AES_CCM;
1667 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1669 case WLAN_CIPHER_SUITE_CCMP:
1670 key.algo = CRYPTO_ALGO_AES_CCM;
1671 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1674 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1677 swap_key_from_BE(&key);
1679 brcmf_netdev_wait_pend8021x(dev);
1680 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1681 if (unlikely(err)) {
1682 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1690 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
1691 u8 key_idx, bool pairwise, const u8 *mac_addr,
1692 struct key_params *params)
1694 struct wl_wsec_key key;
1700 WL_TRACE("Enter\n");
1701 WL_CONN("key index (%d)\n", key_idx);
1706 return wl_add_keyext(wiphy, dev, key_idx, mac_addr, params);
1708 memset(&key, 0, sizeof(key));
1710 key.len = (u32) params->key_len;
1711 key.index = (u32) key_idx;
1713 if (unlikely(key.len > sizeof(key.data))) {
1714 WL_ERR("Too long key length (%u)\n", key.len);
1718 memcpy(key.data, params->key, key.len);
1720 key.flags = WL_PRIMARY_KEY;
1721 switch (params->cipher) {
1722 case WLAN_CIPHER_SUITE_WEP40:
1723 key.algo = CRYPTO_ALGO_WEP1;
1724 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1726 case WLAN_CIPHER_SUITE_WEP104:
1727 key.algo = CRYPTO_ALGO_WEP128;
1728 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1730 case WLAN_CIPHER_SUITE_TKIP:
1731 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1732 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1733 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1734 key.algo = CRYPTO_ALGO_TKIP;
1735 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1737 case WLAN_CIPHER_SUITE_AES_CMAC:
1738 key.algo = CRYPTO_ALGO_AES_CCM;
1739 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1741 case WLAN_CIPHER_SUITE_CCMP:
1742 key.algo = CRYPTO_ALGO_AES_CCM;
1743 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1746 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1751 /* Set the new key/index */
1752 swap_key_from_BE(&key);
1753 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1754 if (unlikely(err)) {
1755 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1760 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1761 if (unlikely(err)) {
1762 WL_ERR("get wsec error (%d)\n", err);
1765 wsec &= ~(WEP_ENABLED);
1767 err = wl_dev_intvar_set(dev, "wsec", wsec);
1768 if (unlikely(err)) {
1769 WL_ERR("set wsec error (%d)\n", err);
1773 val = 1; /* assume shared key. otherwise 0 */
1774 val = cpu_to_le32(val);
1775 err = wl_dev_ioctl(dev, BRCMF_C_SET_AUTH, &val, sizeof(val));
1777 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1784 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
1785 u8 key_idx, bool pairwise, const u8 *mac_addr)
1787 struct wl_wsec_key key;
1792 WL_TRACE("Enter\n");
1794 memset(&key, 0, sizeof(key));
1796 key.index = (u32) key_idx;
1797 key.flags = WL_PRIMARY_KEY;
1798 key.algo = CRYPTO_ALGO_OFF;
1800 WL_CONN("key index (%d)\n", key_idx);
1801 /* Set the new key/index */
1802 swap_key_from_BE(&key);
1803 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1804 if (unlikely(err)) {
1805 if (err == -EINVAL) {
1806 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
1807 /* we ignore this key index in this case */
1808 WL_ERR("invalid key index (%d)\n", key_idx);
1810 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1812 /* Ignore this error, may happen during DISASSOC */
1818 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1819 if (unlikely(err)) {
1820 WL_ERR("get wsec error (%d)\n", err);
1821 /* Ignore this error, may happen during DISASSOC */
1825 wsec &= ~(WEP_ENABLED);
1827 err = wl_dev_intvar_set(dev, "wsec", wsec);
1828 if (unlikely(err)) {
1829 WL_ERR("set wsec error (%d)\n", err);
1830 /* Ignore this error, may happen during DISASSOC */
1835 val = 0; /* assume open key. otherwise 1 */
1836 val = cpu_to_le32(val);
1837 err = wl_dev_ioctl(dev, BRCMF_C_SET_AUTH, &val, sizeof(val));
1838 if (unlikely(err)) {
1839 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1840 /* Ignore this error, may happen during DISASSOC */
1849 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
1850 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
1851 void (*callback) (void *cookie, struct key_params * params))
1853 struct key_params params;
1854 struct wl_wsec_key key;
1855 struct wl_priv *wl = wiphy_to_wl(wiphy);
1856 struct wl_security *sec;
1860 WL_TRACE("Enter\n");
1861 WL_CONN("key index (%d)\n", key_idx);
1864 memset(&key, 0, sizeof(key));
1865 key.index = key_idx;
1866 swap_key_to_BE(&key);
1867 memset(¶ms, 0, sizeof(params));
1868 params.key_len = (u8) min_t(u8, WLAN_MAX_KEY_LEN, key.len);
1869 memcpy(params.key, key.data, params.key_len);
1871 err = wl_dev_ioctl(dev, BRCMF_C_GET_WSEC, &wsec, sizeof(wsec));
1872 if (unlikely(err)) {
1873 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1874 /* Ignore this error, may happen during DISASSOC */
1878 wsec = le32_to_cpu(wsec);
1881 sec = wl_read_prof(wl, WL_PROF_SEC);
1882 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1883 params.cipher = WLAN_CIPHER_SUITE_WEP40;
1884 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1885 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1886 params.cipher = WLAN_CIPHER_SUITE_WEP104;
1887 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1891 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1892 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1895 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1896 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1899 WL_ERR("Invalid algo (0x%x)\n", wsec);
1903 callback(cookie, ¶ms);
1911 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1912 struct net_device *dev, u8 key_idx)
1914 WL_INFO("Not supported\n");
1921 wl_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
1922 u8 *mac, struct station_info *sinfo)
1924 struct wl_priv *wl = wiphy_to_wl(wiphy);
1929 u8 *bssid = wl_read_prof(wl, WL_PROF_BSSID);
1931 WL_TRACE("Enter\n");
1935 (memcmp(mac, bssid, ETH_ALEN))) {
1936 WL_ERR("Wrong Mac address cfg_mac-%X:%X:%X:%X:%X:%X"
1937 "wl_bssid-%X:%X:%X:%X:%X:%X\n",
1938 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
1939 bssid[0], bssid[1], bssid[2], bssid[3],
1940 bssid[4], bssid[5]);
1945 /* Report the current tx rate */
1946 err = wl_dev_ioctl(dev, BRCMF_C_GET_RATE, &rate, sizeof(rate));
1948 WL_ERR("Could not get rate (%d)\n", err);
1950 rate = le32_to_cpu(rate);
1951 sinfo->filled |= STATION_INFO_TX_BITRATE;
1952 sinfo->txrate.legacy = rate * 5;
1953 WL_CONN("Rate %d Mbps\n", rate / 2);
1956 if (test_bit(WL_STATUS_CONNECTED, &wl->status)) {
1958 err = wl_dev_ioctl(dev, BRCMF_C_GET_RSSI, &scb_val,
1960 if (unlikely(err)) {
1961 WL_ERR("Could not get rssi (%d)\n", err);
1963 rssi = le32_to_cpu(scb_val.val);
1964 sinfo->filled |= STATION_INFO_SIGNAL;
1965 sinfo->signal = rssi;
1966 WL_CONN("RSSI %d dBm\n", rssi);
1975 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1976 bool enabled, s32 timeout)
1981 WL_TRACE("Enter\n");
1984 pm = enabled ? PM_FAST : PM_OFF;
1985 pm = cpu_to_le32(pm);
1986 WL_INFO("power save %s\n", (pm ? "enabled" : "disabled"));
1988 err = wl_dev_ioctl(dev, BRCMF_C_SET_PM, &pm, sizeof(pm));
1989 if (unlikely(err)) {
1991 WL_ERR("net_device is not ready yet\n");
1993 WL_ERR("error (%d)\n", err);
1999 static __used u32 wl_find_msb(u16 bit16)
2003 if (bit16 & 0xff00) {
2027 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
2029 const struct cfg80211_bitrate_mask *mask)
2031 struct wl_rateset rateset;
2039 WL_TRACE("Enter\n");
2042 /* addr param is always NULL. ignore it */
2043 /* Get current rateset */
2044 err = wl_dev_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
2046 if (unlikely(err)) {
2047 WL_ERR("could not get current rateset (%d)\n", err);
2051 rateset.count = le32_to_cpu(rateset.count);
2053 legacy = wl_find_msb(mask->control[IEEE80211_BAND_2GHZ].legacy);
2055 legacy = wl_find_msb(mask->control[IEEE80211_BAND_5GHZ].legacy);
2057 val = wl_g_rates[legacy - 1].bitrate * 100000;
2059 if (val < rateset.count)
2060 /* Select rate by rateset index */
2061 rate = rateset.rates[val] & 0x7f;
2063 /* Specified rate in bps */
2064 rate = val / 500000;
2066 WL_CONN("rate %d mbps\n", rate / 2);
2070 * Set rate override,
2071 * Since the is a/b/g-blind, both a/bg_rate are enforced.
2073 err_bg = wl_dev_intvar_set(dev, "bg_rate", rate);
2074 err_a = wl_dev_intvar_set(dev, "a_rate", rate);
2075 if (unlikely(err_bg && err_a)) {
2076 WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
2077 err = err_bg | err_a;
2085 static s32 wl_cfg80211_resume(struct wiphy *wiphy)
2087 struct wl_priv *wl = wiphy_to_wl(wiphy);
2088 struct net_device *ndev = wl_to_ndev(wl);
2091 * Check for WL_STATUS_READY before any function call which
2092 * could result is bus access. Don't block the resume for
2093 * any driver error conditions
2095 WL_TRACE("Enter\n");
2097 #if defined(CONFIG_PM_SLEEP)
2098 atomic_set(&dhd_mmc_suspend, false);
2099 #endif /* defined(CONFIG_PM_SLEEP) */
2101 if (test_bit(WL_STATUS_READY, &wl->status)) {
2102 /* Turn on Watchdog timer */
2103 brcmf_netdev_os_wd_timer(ndev, brcmf_watchdog_ms);
2104 wl_invoke_iscan(wiphy_to_wl(wiphy));
2111 static s32 wl_cfg80211_suspend(struct wiphy *wiphy, struct cfg80211_wowlan *wow)
2113 struct wl_priv *wl = wiphy_to_wl(wiphy);
2114 struct net_device *ndev = wl_to_ndev(wl);
2116 WL_TRACE("Enter\n");
2119 * Check for WL_STATUS_READY before any function call which
2120 * could result is bus access. Don't block the suspend for
2121 * any driver error conditions
2125 * While going to suspend if associated with AP disassociate
2126 * from AP to save power while system is in suspended state
2128 if ((test_bit(WL_STATUS_CONNECTED, &wl->status) ||
2129 test_bit(WL_STATUS_CONNECTING, &wl->status)) &&
2130 test_bit(WL_STATUS_READY, &wl->status)) {
2131 WL_INFO("Disassociating from AP"
2132 " while entering suspend state\n");
2136 * Make sure WPA_Supplicant receives all the event
2137 * generated due to DISASSOC call to the fw to keep
2138 * the state fw and WPA_Supplicant state consistent
2145 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
2146 if (test_bit(WL_STATUS_READY, &wl->status))
2149 if (wl->scan_request) {
2150 /* Indidate scan abort to cfg80211 layer */
2151 WL_INFO("Terminating scan in progress\n");
2152 cfg80211_scan_done(wl->scan_request, true);
2153 wl->scan_request = NULL;
2155 clear_bit(WL_STATUS_SCANNING, &wl->status);
2156 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
2158 /* Inform SDIO stack not to switch off power to the chip */
2159 brcmf_sdioh_set_host_pm_flags(MMC_PM_KEEP_POWER);
2161 /* Turn off watchdog timer */
2162 if (test_bit(WL_STATUS_READY, &wl->status)) {
2163 WL_INFO("Terminate watchdog timer and enable MPC\n");
2164 wl_set_mpc(ndev, 1);
2165 brcmf_netdev_os_wd_timer(ndev, 0);
2168 #if defined(CONFIG_PM_SLEEP)
2169 atomic_set(&dhd_mmc_suspend, true);
2170 #endif /* defined(CONFIG_PM_SLEEP) */
2178 wl_update_pmklist(struct net_device *dev, struct wl_pmk_list *pmk_list,
2183 WL_CONN("No of elements %d\n", pmk_list->pmkids.npmkid);
2184 for (i = 0; i < pmk_list->pmkids.npmkid; i++) {
2185 WL_CONN("PMKID[%d]: %pM =\n", i,
2186 &pmk_list->pmkids.pmkid[i].BSSID);
2187 for (j = 0; j < WLAN_PMKID_LEN; j++)
2188 WL_CONN("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
2192 wl_dev_bufvar_set(dev, "pmkid_info", (char *)pmk_list,
2199 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
2200 struct cfg80211_pmksa *pmksa)
2202 struct wl_priv *wl = wiphy_to_wl(wiphy);
2206 WL_TRACE("Enter\n");
2209 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2210 if (!memcmp(pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2213 if (i < WL_NUM_PMKIDS_MAX) {
2214 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID, pmksa->bssid,
2216 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID, pmksa->pmkid,
2218 if (i == wl->pmk_list->pmkids.npmkid)
2219 wl->pmk_list->pmkids.npmkid++;
2223 WL_CONN("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
2224 &wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].BSSID);
2225 for (i = 0; i < WLAN_PMKID_LEN; i++)
2227 wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].
2230 err = wl_update_pmklist(dev, wl->pmk_list, err);
2237 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
2238 struct cfg80211_pmksa *pmksa)
2240 struct wl_priv *wl = wiphy_to_wl(wiphy);
2241 struct _pmkid_list pmkid;
2245 WL_TRACE("Enter\n");
2247 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2248 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2250 WL_CONN("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2251 &pmkid.pmkid[0].BSSID);
2252 for (i = 0; i < WLAN_PMKID_LEN; i++)
2253 WL_CONN("%02x\n", pmkid.pmkid[0].PMKID[i]);
2255 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2257 (pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2261 if ((wl->pmk_list->pmkids.npmkid > 0)
2262 && (i < wl->pmk_list->pmkids.npmkid)) {
2263 memset(&wl->pmk_list->pmkids.pmkid[i], 0, sizeof(pmkid_t));
2264 for (; i < (wl->pmk_list->pmkids.npmkid - 1); i++) {
2265 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID,
2266 &wl->pmk_list->pmkids.pmkid[i + 1].BSSID,
2268 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID,
2269 &wl->pmk_list->pmkids.pmkid[i + 1].PMKID,
2272 wl->pmk_list->pmkids.npmkid--;
2276 err = wl_update_pmklist(dev, wl->pmk_list, err);
2284 wl_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *dev)
2286 struct wl_priv *wl = wiphy_to_wl(wiphy);
2289 WL_TRACE("Enter\n");
2292 memset(wl->pmk_list, 0, sizeof(*wl->pmk_list));
2293 err = wl_update_pmklist(dev, wl->pmk_list, err);
2300 static struct cfg80211_ops wl_cfg80211_ops = {
2301 .change_virtual_intf = wl_cfg80211_change_iface,
2302 .scan = wl_cfg80211_scan,
2303 .set_wiphy_params = wl_cfg80211_set_wiphy_params,
2304 .join_ibss = wl_cfg80211_join_ibss,
2305 .leave_ibss = wl_cfg80211_leave_ibss,
2306 .get_station = wl_cfg80211_get_station,
2307 .set_tx_power = wl_cfg80211_set_tx_power,
2308 .get_tx_power = wl_cfg80211_get_tx_power,
2309 .add_key = wl_cfg80211_add_key,
2310 .del_key = wl_cfg80211_del_key,
2311 .get_key = wl_cfg80211_get_key,
2312 .set_default_key = wl_cfg80211_config_default_key,
2313 .set_default_mgmt_key = wl_cfg80211_config_default_mgmt_key,
2314 .set_power_mgmt = wl_cfg80211_set_power_mgmt,
2315 .set_bitrate_mask = wl_cfg80211_set_bitrate_mask,
2316 .connect = wl_cfg80211_connect,
2317 .disconnect = wl_cfg80211_disconnect,
2318 .suspend = wl_cfg80211_suspend,
2319 .resume = wl_cfg80211_resume,
2320 .set_pmksa = wl_cfg80211_set_pmksa,
2321 .del_pmksa = wl_cfg80211_del_pmksa,
2322 .flush_pmksa = wl_cfg80211_flush_pmksa
2325 static s32 wl_mode_to_nl80211_iftype(s32 mode)
2331 return NL80211_IFTYPE_STATION;
2333 return NL80211_IFTYPE_ADHOC;
2335 return NL80211_IFTYPE_UNSPECIFIED;
2341 static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
2344 struct wireless_dev *wdev;
2347 wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2348 if (unlikely(!wdev)) {
2349 WL_ERR("Could not allocate wireless device\n");
2350 return ERR_PTR(-ENOMEM);
2353 wiphy_new(&wl_cfg80211_ops, sizeof(struct wl_priv) + sizeof_iface);
2354 if (unlikely(!wdev->wiphy)) {
2355 WL_ERR("Couldn not allocate wiphy device\n");
2359 set_wiphy_dev(wdev->wiphy, dev);
2360 wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2361 wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2362 wdev->wiphy->interface_modes =
2363 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2364 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2365 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a; /* Set
2366 * it as 11a by default.
2367 * This will be updated with
2370 * if phy has 11n capability
2372 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2373 wdev->wiphy->cipher_suites = __wl_cipher_suites;
2374 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2375 #ifndef WL_POWERSAVE_DISABLED
2376 wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; /* enable power
2381 wdev->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
2382 #endif /* !WL_POWERSAVE_DISABLED */
2383 err = wiphy_register(wdev->wiphy);
2384 if (unlikely(err < 0)) {
2385 WL_ERR("Couldn not register wiphy device (%d)\n", err);
2386 goto wiphy_register_out;
2391 wiphy_free(wdev->wiphy);
2396 return ERR_PTR(err);
2399 static void wl_free_wdev(struct wl_priv *wl)
2401 struct wireless_dev *wdev = wl_to_wdev(wl);
2403 if (unlikely(!wdev)) {
2404 WL_ERR("wdev is invalid\n");
2407 wiphy_unregister(wdev->wiphy);
2408 wiphy_free(wdev->wiphy);
2410 wl_to_wdev(wl) = NULL;
2413 static s32 wl_inform_bss(struct wl_priv *wl)
2415 struct wl_scan_results *bss_list;
2416 struct wl_bss_info *bi = NULL; /* must be initialized */
2420 bss_list = wl->bss_list;
2421 if (unlikely(bss_list->version != WL_BSS_INFO_VERSION)) {
2422 WL_ERR("Version %d != WL_BSS_INFO_VERSION\n",
2426 WL_SCAN("scanned AP count (%d)\n", bss_list->count);
2427 bi = next_bss(bss_list, bi);
2428 for_each_bss(bss_list, bi, i) {
2429 err = wl_inform_single_bss(wl, bi);
2437 static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
2439 struct wiphy *wiphy = wl_to_wiphy(wl);
2440 struct ieee80211_channel *notify_channel;
2441 struct cfg80211_bss *bss;
2442 struct ieee80211_supported_band *band;
2446 u64 notify_timestamp;
2447 u16 notify_capability;
2448 u16 notify_interval;
2450 size_t notify_ielen;
2453 if (unlikely(le32_to_cpu(bi->length) > WL_BSS_INFO_MAX)) {
2454 WL_ERR("Bss info is larger than buffer. Discarding\n");
2458 channel = bi->ctl_ch ? bi->ctl_ch :
2459 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2461 if (channel <= CH_MAX_2G_CHANNEL)
2462 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2464 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2466 freq = ieee80211_channel_to_frequency(channel, band->band);
2467 notify_channel = ieee80211_get_channel(wiphy, freq);
2469 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2470 notify_capability = le16_to_cpu(bi->capability);
2471 notify_interval = le16_to_cpu(bi->beacon_period);
2472 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2473 notify_ielen = le16_to_cpu(bi->ie_length);
2474 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2476 WL_CONN("bssid: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2477 bi->BSSID[0], bi->BSSID[1], bi->BSSID[2],
2478 bi->BSSID[3], bi->BSSID[4], bi->BSSID[5]);
2479 WL_CONN("Channel: %d(%d)\n", channel, freq);
2480 WL_CONN("Capability: %X\n", notify_capability);
2481 WL_CONN("Beacon interval: %d\n", notify_interval);
2482 WL_CONN("Signal: %d\n", notify_signal);
2483 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2485 bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
2486 notify_timestamp, notify_capability, notify_interval, notify_ie,
2487 notify_ielen, notify_signal, GFP_KERNEL);
2489 if (unlikely(!bss)) {
2490 WL_ERR("cfg80211_inform_bss_frame error\n");
2498 wl_inform_ibss(struct wl_priv *wl, struct net_device *dev, const u8 *bssid)
2500 struct wiphy *wiphy = wl_to_wiphy(wl);
2501 struct ieee80211_channel *notify_channel;
2502 struct wl_bss_info *bi = NULL;
2503 struct ieee80211_supported_band *band;
2508 u64 notify_timestamp;
2509 u16 notify_capability;
2510 u16 notify_interval;
2512 size_t notify_ielen;
2515 WL_TRACE("Enter\n");
2517 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2519 WL_ERR("kzalloc() failed\n");
2524 *(u32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2526 err = wl_dev_ioctl(dev, BRCMF_C_GET_BSS_INFO, buf, WL_BSS_INFO_MAX);
2527 if (unlikely(err)) {
2528 WL_ERR("WLC_GET_BSS_INFO failed: %d\n", err);
2532 bi = (wl_bss_info_t *)(buf + 4);
2534 channel = bi->ctl_ch ? bi->ctl_ch :
2535 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2537 if (channel <= CH_MAX_2G_CHANNEL)
2538 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2540 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2542 freq = ieee80211_channel_to_frequency(channel, band->band);
2543 notify_channel = ieee80211_get_channel(wiphy, freq);
2545 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2546 notify_capability = le16_to_cpu(bi->capability);
2547 notify_interval = le16_to_cpu(bi->beacon_period);
2548 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2549 notify_ielen = le16_to_cpu(bi->ie_length);
2550 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2552 WL_CONN("channel: %d(%d)\n", channel, freq);
2553 WL_CONN("capability: %X\n", notify_capability);
2554 WL_CONN("beacon interval: %d\n", notify_interval);
2555 WL_CONN("signal: %d\n", notify_signal);
2556 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2558 cfg80211_inform_bss(wiphy, notify_channel, bssid,
2559 notify_timestamp, notify_capability, notify_interval,
2560 notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
2571 static bool wl_is_linkup(struct wl_priv *wl, const brcmf_event_msg_t *e)
2573 u32 event = be32_to_cpu(e->event_type);
2574 u32 status = be32_to_cpu(e->status);
2576 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
2577 WL_CONN("Processing set ssid\n");
2585 static bool wl_is_linkdown(struct wl_priv *wl, const brcmf_event_msg_t *e)
2587 u32 event = be32_to_cpu(e->event_type);
2588 u16 flags = be16_to_cpu(e->flags);
2590 if (event == BRCMF_E_LINK && (!(flags & BRCMF_EVENT_MSG_LINK))) {
2591 WL_CONN("Processing link down\n");
2597 static bool wl_is_nonetwork(struct wl_priv *wl, const brcmf_event_msg_t *e)
2599 u32 event = be32_to_cpu(e->event_type);
2600 u32 status = be32_to_cpu(e->status);
2602 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
2603 WL_CONN("Processing Link %s & no network found\n",
2604 be16_to_cpu(e->flags) & BRCMF_EVENT_MSG_LINK ?
2609 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
2610 WL_CONN("Processing connecting & no network found\n");
2618 wl_notify_connect_status(struct wl_priv *wl, struct net_device *ndev,
2619 const brcmf_event_msg_t *e, void *data)
2623 if (wl_is_linkup(wl, e)) {
2624 WL_CONN("Linkup\n");
2625 if (wl_is_ibssmode(wl)) {
2626 wl_update_prof(wl, NULL, (void *)e->addr,
2628 wl_inform_ibss(wl, ndev, e->addr);
2629 cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
2630 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2631 set_bit(WL_STATUS_CONNECTED, &wl->status);
2633 wl_bss_connect_done(wl, ndev, e, data, true);
2634 } else if (wl_is_linkdown(wl, e)) {
2635 WL_CONN("Linkdown\n");
2636 if (wl_is_ibssmode(wl)) {
2637 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2638 if (test_and_clear_bit(WL_STATUS_CONNECTED,
2642 wl_bss_connect_done(wl, ndev, e, data, false);
2643 if (test_and_clear_bit(WL_STATUS_CONNECTED,
2645 cfg80211_disconnected(ndev, 0, NULL, 0,
2650 wl_init_prof(wl->profile);
2651 } else if (wl_is_nonetwork(wl, e)) {
2652 if (wl_is_ibssmode(wl))
2653 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2655 wl_bss_connect_done(wl, ndev, e, data, false);
2662 wl_notify_roaming_status(struct wl_priv *wl, struct net_device *ndev,
2663 const brcmf_event_msg_t *e, void *data)
2666 u32 event = be32_to_cpu(e->event_type);
2667 u32 status = be32_to_cpu(e->status);
2669 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
2670 if (test_bit(WL_STATUS_CONNECTED, &wl->status))
2671 wl_bss_roaming_done(wl, ndev, e, data);
2673 wl_bss_connect_done(wl, ndev, e, data, true);
2680 wl_dev_bufvar_set(struct net_device *dev, s8 *name, s8 *buf, s32 len)
2682 struct wl_priv *wl = ndev_to_wl(dev);
2685 buflen = brcmu_mkiovar(name, buf, len, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2688 return wl_dev_ioctl(dev, BRCMF_C_SET_VAR, wl->ioctl_buf, buflen);
2692 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
2695 struct wl_priv *wl = ndev_to_wl(dev);
2699 len = brcmu_mkiovar(name, NULL, 0, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2701 err = wl_dev_ioctl(dev, BRCMF_C_GET_VAR, (void *)wl->ioctl_buf,
2703 if (unlikely(err)) {
2704 WL_ERR("error (%d)\n", err);
2707 memcpy(buf, wl->ioctl_buf, buf_len);
2712 static s32 wl_get_assoc_ies(struct wl_priv *wl)
2714 struct net_device *ndev = wl_to_ndev(wl);
2715 struct wl_assoc_ielen *assoc_info;
2716 struct wl_connect_info *conn_info = wl_to_conn(wl);
2721 wl_clear_assoc_ies(wl);
2723 err = wl_dev_bufvar_get(ndev, "assoc_info", wl->extra_buf,
2725 if (unlikely(err)) {
2726 WL_ERR("could not get assoc info (%d)\n", err);
2729 assoc_info = (struct wl_assoc_ielen *)wl->extra_buf;
2730 req_len = assoc_info->req_len;
2731 resp_len = assoc_info->resp_len;
2733 err = wl_dev_bufvar_get(ndev, "assoc_req_ies", wl->extra_buf,
2735 if (unlikely(err)) {
2736 WL_ERR("could not get assoc req (%d)\n", err);
2739 conn_info->req_ie_len = req_len;
2741 kmemdup(wl->extra_buf, conn_info->req_ie_len, GFP_KERNEL);
2743 conn_info->req_ie_len = 0;
2744 conn_info->req_ie = NULL;
2747 err = wl_dev_bufvar_get(ndev, "assoc_resp_ies", wl->extra_buf,
2749 if (unlikely(err)) {
2750 WL_ERR("could not get assoc resp (%d)\n", err);
2753 conn_info->resp_ie_len = resp_len;
2754 conn_info->resp_ie =
2755 kmemdup(wl->extra_buf, conn_info->resp_ie_len, GFP_KERNEL);
2757 conn_info->resp_ie_len = 0;
2758 conn_info->resp_ie = NULL;
2760 WL_CONN("req len (%d) resp len (%d)\n",
2761 conn_info->req_ie_len, conn_info->resp_ie_len);
2766 static void wl_clear_assoc_ies(struct wl_priv *wl)
2768 struct wl_connect_info *conn_info = wl_to_conn(wl);
2770 kfree(conn_info->req_ie);
2771 conn_info->req_ie = NULL;
2772 conn_info->req_ie_len = 0;
2773 kfree(conn_info->resp_ie);
2774 conn_info->resp_ie = NULL;
2775 conn_info->resp_ie_len = 0;
2779 static void wl_ch_to_chanspec(int ch, struct wl_join_params *join_params,
2780 size_t *join_params_size)
2782 chanspec_t chanspec = 0;
2785 join_params->params.chanspec_num = 1;
2786 join_params->params.chanspec_list[0] = ch;
2788 if (join_params->params.chanspec_list[0] <= CH_MAX_2G_CHANNEL)
2789 chanspec |= WL_CHANSPEC_BAND_2G;
2791 chanspec |= WL_CHANSPEC_BAND_5G;
2793 chanspec |= WL_CHANSPEC_BW_20;
2794 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
2796 *join_params_size += WL_ASSOC_PARAMS_FIXED_SIZE +
2797 join_params->params.chanspec_num * sizeof(chanspec_t);
2799 join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
2800 join_params->params.chanspec_list[0] |= chanspec;
2801 join_params->params.chanspec_list[0] =
2802 cpu_to_le16(join_params->params.chanspec_list[0]);
2804 join_params->params.chanspec_num =
2805 cpu_to_le32(join_params->params.chanspec_num);
2807 WL_CONN("join_params->params.chanspec_list[0]= %#X,"
2808 "channel %d, chanspec %#X\n",
2809 join_params->params.chanspec_list[0], ch, chanspec);
2813 static s32 wl_update_bss_info(struct wl_priv *wl)
2815 struct wl_bss_info *bi;
2816 struct wlc_ssid *ssid;
2817 struct brcmu_tlv *tim;
2818 u16 beacon_interval;
2824 WL_TRACE("Enter\n");
2825 if (wl_is_ibssmode(wl))
2828 ssid = (struct wlc_ssid *)wl_read_prof(wl, WL_PROF_SSID);
2830 *(u32 *)wl->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2831 err = wl_dev_ioctl(wl_to_ndev(wl), BRCMF_C_GET_BSS_INFO,
2832 wl->extra_buf, WL_EXTRA_BUF_MAX);
2833 if (unlikely(err)) {
2834 WL_ERR("Could not get bss info %d\n", err);
2835 goto update_bss_info_out;
2838 bi = (struct wl_bss_info *)(wl->extra_buf + 4);
2839 err = wl_inform_single_bss(wl, bi);
2841 goto update_bss_info_out;
2843 ie = ((u8 *)bi) + bi->ie_offset;
2844 ie_len = bi->ie_length;
2845 beacon_interval = cpu_to_le16(bi->beacon_period);
2847 tim = brcmu_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2849 dtim_period = tim->data[1];
2852 * active scan was done so we could not get dtim
2853 * information out of probe response.
2854 * so we speficially query dtim information to dongle.
2857 err = wl_dev_intvar_get(wl_to_ndev(wl), "dtim_assoc", &var);
2858 if (unlikely(err)) {
2859 WL_ERR("wl dtim_assoc failed (%d)\n", err);
2860 goto update_bss_info_out;
2862 dtim_period = (u8)var;
2865 wl_update_prof(wl, NULL, &beacon_interval, WL_PROF_BEACONINT);
2866 wl_update_prof(wl, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
2868 update_bss_info_out:
2874 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
2875 const brcmf_event_msg_t *e, void *data)
2877 struct wl_connect_info *conn_info = wl_to_conn(wl);
2880 WL_TRACE("Enter\n");
2882 wl_get_assoc_ies(wl);
2883 wl_update_prof(wl, NULL, &e->addr, WL_PROF_BSSID);
2884 wl_update_bss_info(wl);
2886 cfg80211_roamed(ndev, NULL,
2887 (u8 *)wl_read_prof(wl, WL_PROF_BSSID),
2888 conn_info->req_ie, conn_info->req_ie_len,
2889 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
2890 WL_CONN("Report roaming result\n");
2892 set_bit(WL_STATUS_CONNECTED, &wl->status);
2898 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
2899 const brcmf_event_msg_t *e, void *data, bool completed)
2901 struct wl_connect_info *conn_info = wl_to_conn(wl);
2904 WL_TRACE("Enter\n");
2906 if (test_and_clear_bit(WL_STATUS_CONNECTING, &wl->status)) {
2908 wl_get_assoc_ies(wl);
2909 wl_update_prof(wl, NULL, &e->addr, WL_PROF_BSSID);
2910 wl_update_bss_info(wl);
2912 cfg80211_connect_result(ndev,
2913 (u8 *)wl_read_prof(wl, WL_PROF_BSSID),
2915 conn_info->req_ie_len,
2917 conn_info->resp_ie_len,
2918 completed ? WLAN_STATUS_SUCCESS : WLAN_STATUS_AUTH_TIMEOUT,
2921 set_bit(WL_STATUS_CONNECTED, &wl->status);
2922 WL_CONN("Report connect result - connection %s\n",
2923 completed ? "succeeded" : "failed");
2930 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
2931 const brcmf_event_msg_t *e, void *data)
2933 u16 flags = be16_to_cpu(e->flags);
2934 enum nl80211_key_type key_type;
2937 if (flags & BRCMF_EVENT_MSG_GROUP)
2938 key_type = NL80211_KEYTYPE_GROUP;
2940 key_type = NL80211_KEYTYPE_PAIRWISE;
2942 cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
2950 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
2951 const brcmf_event_msg_t *e, void *data)
2953 struct channel_info channel_inform;
2954 struct wl_scan_results *bss_list;
2955 u32 len = WL_SCAN_BUF_MAX;
2957 bool scan_abort = false;
2959 WL_TRACE("Enter\n");
2961 if (wl->iscan_on && wl->iscan_kickstart) {
2963 return wl_wakeup_iscan(wl_to_iscan(wl));
2966 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
2967 WL_ERR("Scan complete while device not scanning\n");
2973 err = wl_dev_ioctl(ndev, BRCMF_C_GET_CHANNEL, &channel_inform,
2974 sizeof(channel_inform));
2975 if (unlikely(err)) {
2976 WL_ERR("scan busy (%d)\n", err);
2980 channel_inform.scan_channel = le32_to_cpu(channel_inform.scan_channel);
2981 if (unlikely(channel_inform.scan_channel)) {
2983 WL_CONN("channel_inform.scan_channel (%d)\n",
2984 channel_inform.scan_channel);
2986 wl->bss_list = wl->scan_results;
2987 bss_list = wl->bss_list;
2988 memset(bss_list, 0, len);
2989 bss_list->buflen = cpu_to_le32(len);
2991 err = wl_dev_ioctl(ndev, BRCMF_C_SCAN_RESULTS, bss_list, len);
2992 if (unlikely(err)) {
2993 WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
2998 bss_list->buflen = le32_to_cpu(bss_list->buflen);
2999 bss_list->version = le32_to_cpu(bss_list->version);
3000 bss_list->count = le32_to_cpu(bss_list->count);
3002 err = wl_inform_bss(wl);
3009 if (wl->scan_request) {
3010 WL_SCAN("calling cfg80211_scan_done\n");
3011 cfg80211_scan_done(wl->scan_request, scan_abort);
3012 wl_set_mpc(ndev, 1);
3013 wl->scan_request = NULL;
3021 static void wl_init_conf(struct wl_conf *conf)
3023 conf->mode = (u32)-1;
3024 conf->frag_threshold = (u32)-1;
3025 conf->rts_threshold = (u32)-1;
3026 conf->retry_short = (u32)-1;
3027 conf->retry_long = (u32)-1;
3028 conf->tx_power = -1;
3031 static void wl_init_prof(struct wl_profile *prof)
3033 memset(prof, 0, sizeof(*prof));
3036 static void wl_init_eloop_handler(struct wl_event_loop *el)
3038 memset(el, 0, sizeof(*el));
3039 el->handler[BRCMF_E_SCAN_COMPLETE] = wl_notify_scan_status;
3040 el->handler[BRCMF_E_LINK] = wl_notify_connect_status;
3041 el->handler[BRCMF_E_ROAM] = wl_notify_roaming_status;
3042 el->handler[BRCMF_E_MIC_ERROR] = wl_notify_mic_status;
3043 el->handler[BRCMF_E_SET_SSID] = wl_notify_connect_status;
3046 static s32 wl_init_priv_mem(struct wl_priv *wl)
3048 wl->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
3049 if (unlikely(!wl->scan_results)) {
3050 WL_ERR("Scan results alloc failed\n");
3051 goto init_priv_mem_out;
3053 wl->conf = kzalloc(sizeof(*wl->conf), GFP_KERNEL);
3054 if (unlikely(!wl->conf)) {
3055 WL_ERR("wl_conf alloc failed\n");
3056 goto init_priv_mem_out;
3058 wl->profile = kzalloc(sizeof(*wl->profile), GFP_KERNEL);
3059 if (unlikely(!wl->profile)) {
3060 WL_ERR("wl_profile alloc failed\n");
3061 goto init_priv_mem_out;
3063 wl->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
3064 if (unlikely(!wl->bss_info)) {
3065 WL_ERR("Bss information alloc failed\n");
3066 goto init_priv_mem_out;
3068 wl->scan_req_int = kzalloc(sizeof(*wl->scan_req_int), GFP_KERNEL);
3069 if (unlikely(!wl->scan_req_int)) {
3070 WL_ERR("Scan req alloc failed\n");
3071 goto init_priv_mem_out;
3073 wl->ioctl_buf = kzalloc(WL_IOCTL_LEN_MAX, GFP_KERNEL);
3074 if (unlikely(!wl->ioctl_buf)) {
3075 WL_ERR("Ioctl buf alloc failed\n");
3076 goto init_priv_mem_out;
3078 wl->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3079 if (unlikely(!wl->extra_buf)) {
3080 WL_ERR("Extra buf alloc failed\n");
3081 goto init_priv_mem_out;
3083 wl->iscan = kzalloc(sizeof(*wl->iscan), GFP_KERNEL);
3084 if (unlikely(!wl->iscan)) {
3085 WL_ERR("Iscan buf alloc failed\n");
3086 goto init_priv_mem_out;
3088 wl->fw = kzalloc(sizeof(*wl->fw), GFP_KERNEL);
3089 if (unlikely(!wl->fw)) {
3090 WL_ERR("fw object alloc failed\n");
3091 goto init_priv_mem_out;
3093 wl->pmk_list = kzalloc(sizeof(*wl->pmk_list), GFP_KERNEL);
3094 if (unlikely(!wl->pmk_list)) {
3095 WL_ERR("pmk list alloc failed\n");
3096 goto init_priv_mem_out;
3102 wl_deinit_priv_mem(wl);
3107 static void wl_deinit_priv_mem(struct wl_priv *wl)
3109 kfree(wl->scan_results);
3110 wl->scan_results = NULL;
3111 kfree(wl->bss_info);
3112 wl->bss_info = NULL;
3117 kfree(wl->scan_req_int);
3118 wl->scan_req_int = NULL;
3119 kfree(wl->ioctl_buf);
3120 wl->ioctl_buf = NULL;
3121 kfree(wl->extra_buf);
3122 wl->extra_buf = NULL;
3127 kfree(wl->pmk_list);
3128 wl->pmk_list = NULL;
3131 static s32 wl_create_event_handler(struct wl_priv *wl)
3133 sema_init(&wl->event_sync, 0);
3134 wl->event_tsk = kthread_run(wl_event_handler, wl, "wl_event_handler");
3135 if (IS_ERR(wl->event_tsk)) {
3136 wl->event_tsk = NULL;
3137 WL_ERR("failed to create event thread\n");
3143 static void wl_destroy_event_handler(struct wl_priv *wl)
3145 if (wl->event_tsk) {
3146 send_sig(SIGTERM, wl->event_tsk, 1);
3147 kthread_stop(wl->event_tsk);
3148 wl->event_tsk = NULL;
3152 static void wl_term_iscan(struct wl_priv *wl)
3154 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3156 if (wl->iscan_on && iscan->tsk) {
3157 iscan->state = WL_ISCAN_STATE_IDLE;
3158 send_sig(SIGTERM, iscan->tsk, 1);
3159 kthread_stop(iscan->tsk);
3164 static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted)
3166 struct wl_priv *wl = iscan_to_wl(iscan);
3167 struct net_device *ndev = wl_to_ndev(wl);
3169 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
3170 WL_ERR("Scan complete while device not scanning\n");
3173 if (likely(wl->scan_request)) {
3174 WL_SCAN("ISCAN Completed scan: %s\n",
3175 aborted ? "Aborted" : "Done");
3176 cfg80211_scan_done(wl->scan_request, aborted);
3177 wl_set_mpc(ndev, 1);
3178 wl->scan_request = NULL;
3180 wl->iscan_kickstart = false;
3183 static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan)
3185 if (likely(iscan->state != WL_ISCAN_STATE_IDLE)) {
3186 WL_SCAN("wake up iscan\n");
3195 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
3196 struct wl_scan_results **bss_list)
3198 struct wl_iscan_results list;
3199 struct wl_scan_results *results;
3200 struct wl_iscan_results *list_buf;
3203 memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
3204 list_buf = (struct wl_iscan_results *)iscan->scan_buf;
3205 results = &list_buf->results;
3206 results->buflen = WL_ISCAN_RESULTS_FIXED_SIZE;
3207 results->version = 0;
3210 memset(&list, 0, sizeof(list));
3211 list.results.buflen = cpu_to_le32(WL_ISCAN_BUF_MAX);
3212 err = wl_dev_iovar_getbuf(iscan->dev, "iscanresults", &list,
3213 WL_ISCAN_RESULTS_FIXED_SIZE, iscan->scan_buf,
3215 if (unlikely(err)) {
3216 WL_ERR("error (%d)\n", err);
3219 results->buflen = le32_to_cpu(results->buflen);
3220 results->version = le32_to_cpu(results->version);
3221 results->count = le32_to_cpu(results->count);
3222 WL_SCAN("results->count = %d\n", results->count);
3223 WL_SCAN("results->buflen = %d\n", results->buflen);
3224 *status = le32_to_cpu(list_buf->status);
3225 *bss_list = results;
3230 static s32 wl_iscan_done(struct wl_priv *wl)
3232 struct wl_iscan_ctrl *iscan = wl->iscan;
3235 iscan->state = WL_ISCAN_STATE_IDLE;
3238 wl_notify_iscan_complete(iscan, false);
3244 static s32 wl_iscan_pending(struct wl_priv *wl)
3246 struct wl_iscan_ctrl *iscan = wl->iscan;
3249 /* Reschedule the timer */
3250 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3251 iscan->timer_on = 1;
3256 static s32 wl_iscan_inprogress(struct wl_priv *wl)
3258 struct wl_iscan_ctrl *iscan = wl->iscan;
3263 wl_run_iscan(iscan, NULL, WL_SCAN_ACTION_CONTINUE);
3265 /* Reschedule the timer */
3266 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3267 iscan->timer_on = 1;
3272 static s32 wl_iscan_aborted(struct wl_priv *wl)
3274 struct wl_iscan_ctrl *iscan = wl->iscan;
3277 iscan->state = WL_ISCAN_STATE_IDLE;
3279 wl_notify_iscan_complete(iscan, true);
3285 static s32 wl_iscan_thread(void *data)
3287 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3288 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
3289 struct wl_priv *wl = iscan_to_wl(iscan);
3290 struct wl_iscan_eloop *el = &iscan->el;
3294 sched_setscheduler(current, SCHED_FIFO, ¶m);
3295 allow_signal(SIGTERM);
3296 status = WL_SCAN_RESULTS_PARTIAL;
3297 while (likely(!down_interruptible(&iscan->sync))) {
3298 if (kthread_should_stop())
3300 if (iscan->timer_on) {
3301 del_timer_sync(&iscan->timer);
3302 iscan->timer_on = 0;
3305 err = wl_get_iscan_results(iscan, &status, &wl->bss_list);
3306 if (unlikely(err)) {
3307 status = WL_SCAN_RESULTS_ABORTED;
3308 WL_ERR("Abort iscan\n");
3311 el->handler[status] (wl);
3313 if (iscan->timer_on) {
3314 del_timer_sync(&iscan->timer);
3315 iscan->timer_on = 0;
3317 WL_SCAN("ISCAN thread terminated\n");
3322 static void wl_iscan_timer(unsigned long data)
3324 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
3327 iscan->timer_on = 0;
3328 WL_SCAN("timer expired\n");
3329 wl_wakeup_iscan(iscan);
3333 static s32 wl_invoke_iscan(struct wl_priv *wl)
3335 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3338 if (wl->iscan_on && !iscan->tsk) {
3339 iscan->state = WL_ISCAN_STATE_IDLE;
3340 sema_init(&iscan->sync, 0);
3341 iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
3342 if (IS_ERR(iscan->tsk)) {
3343 WL_ERR("Could not create iscan thread\n");
3352 static void wl_init_iscan_eloop(struct wl_iscan_eloop *el)
3354 memset(el, 0, sizeof(*el));
3355 el->handler[WL_SCAN_RESULTS_SUCCESS] = wl_iscan_done;
3356 el->handler[WL_SCAN_RESULTS_PARTIAL] = wl_iscan_inprogress;
3357 el->handler[WL_SCAN_RESULTS_PENDING] = wl_iscan_pending;
3358 el->handler[WL_SCAN_RESULTS_ABORTED] = wl_iscan_aborted;
3359 el->handler[WL_SCAN_RESULTS_NO_MEM] = wl_iscan_aborted;
3362 static s32 wl_init_iscan(struct wl_priv *wl)
3364 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3368 iscan->dev = wl_to_ndev(wl);
3369 iscan->state = WL_ISCAN_STATE_IDLE;
3370 wl_init_iscan_eloop(&iscan->el);
3371 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
3372 init_timer(&iscan->timer);
3373 iscan->timer.data = (unsigned long) iscan;
3374 iscan->timer.function = wl_iscan_timer;
3375 sema_init(&iscan->sync, 0);
3376 iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
3377 if (IS_ERR(iscan->tsk)) {
3378 WL_ERR("Could not create iscan thread\n");
3388 static void wl_init_fw(struct wl_fw_ctrl *fw)
3390 fw->status = 0; /* init fw loading status.
3391 0 means nothing was loaded yet */
3394 static s32 wl_init_priv(struct wl_priv *wl)
3396 struct wiphy *wiphy = wl_to_wiphy(wl);
3399 wl->scan_request = NULL;
3400 wl->pwr_save = !!(wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT);
3401 wl->iscan_on = true; /* iscan on & off switch.
3402 we enable iscan per default */
3403 wl->roam_on = false; /* roam on & off switch.
3404 we enable roam per default */
3406 wl->iscan_kickstart = false;
3407 wl->active_scan = true; /* we do active scan for
3408 specific scan per default */
3409 wl->dongle_up = false; /* dongle is not up yet */
3411 err = wl_init_priv_mem(wl);
3414 if (unlikely(wl_create_event_handler(wl)))
3416 wl_init_eloop_handler(&wl->el);
3417 mutex_init(&wl->usr_sync);
3418 err = wl_init_iscan(wl);
3422 wl_init_conf(wl->conf);
3423 wl_init_prof(wl->profile);
3429 static void wl_deinit_priv(struct wl_priv *wl)
3431 wl_destroy_event_handler(wl);
3432 wl->dongle_up = false; /* dongle down */
3436 wl_deinit_priv_mem(wl);
3439 s32 wl_cfg80211_attach(struct net_device *ndev, void *data)
3441 struct wireless_dev *wdev;
3443 struct wl_iface *ci;
3446 if (unlikely(!ndev)) {
3447 WL_ERR("ndev is invalid\n");
3450 wl_cfg80211_dev = kzalloc(sizeof(struct wl_dev), GFP_KERNEL);
3451 if (unlikely(!wl_cfg80211_dev)) {
3452 WL_ERR("wl_cfg80211_dev is invalid\n");
3455 WL_INFO("func %p\n", wl_cfg80211_get_sdio_func());
3456 wdev = wl_alloc_wdev(sizeof(struct wl_iface), &wl_cfg80211_get_sdio_func()->dev);
3460 wdev->iftype = wl_mode_to_nl80211_iftype(WL_MODE_BSS);
3461 wl = wdev_to_wl(wdev);
3464 ci = (struct wl_iface *)wl_to_ci(wl);
3466 ndev->ieee80211_ptr = wdev;
3467 SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
3468 wdev->netdev = ndev;
3469 err = wl_init_priv(wl);
3470 if (unlikely(err)) {
3471 WL_ERR("Failed to init iwm_priv (%d)\n", err);
3472 goto cfg80211_attach_out;
3474 wl_set_drvdata(wl_cfg80211_dev, ci);
3478 cfg80211_attach_out:
3483 void wl_cfg80211_detach(void)
3491 wl_set_drvdata(wl_cfg80211_dev, NULL);
3492 kfree(wl_cfg80211_dev);
3493 wl_cfg80211_dev = NULL;
3494 wl_clear_sdio_func();
3497 static void wl_wakeup_event(struct wl_priv *wl)
3499 up(&wl->event_sync);
3502 static s32 wl_event_handler(void *data)
3504 struct wl_priv *wl = (struct wl_priv *)data;
3505 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3506 struct wl_event_q *e;
3508 sched_setscheduler(current, SCHED_FIFO, ¶m);
3509 allow_signal(SIGTERM);
3510 while (likely(!down_interruptible(&wl->event_sync))) {
3511 if (kthread_should_stop())
3513 e = wl_deq_event(wl);
3515 WL_ERR("event queue empty...\n");
3518 WL_INFO("event type (%d)\n", e->etype);
3519 if (wl->el.handler[e->etype]) {
3520 wl->el.handler[e->etype] (wl, wl_to_ndev(wl), &e->emsg,
3523 WL_INFO("Unknown Event (%d): ignoring\n", e->etype);
3527 WL_INFO("was terminated\n");
3532 wl_cfg80211_event(struct net_device *ndev,
3533 const brcmf_event_msg_t *e, void *data)
3535 u32 event_type = be32_to_cpu(e->event_type);
3536 struct wl_priv *wl = ndev_to_wl(ndev);
3538 if (likely(!wl_enq_event(wl, event_type, e, data)))
3539 wl_wakeup_event(wl);
3542 static void wl_init_eq(struct wl_priv *wl)
3544 wl_init_eq_lock(wl);
3545 INIT_LIST_HEAD(&wl->eq_list);
3548 static void wl_flush_eq(struct wl_priv *wl)
3550 struct wl_event_q *e;
3553 while (!list_empty(&wl->eq_list)) {
3554 e = list_first_entry(&wl->eq_list, struct wl_event_q, eq_list);
3555 list_del(&e->eq_list);
3562 * retrieve first queued event from head
3565 static struct wl_event_q *wl_deq_event(struct wl_priv *wl)
3567 struct wl_event_q *e = NULL;
3570 if (likely(!list_empty(&wl->eq_list))) {
3571 e = list_first_entry(&wl->eq_list, struct wl_event_q, eq_list);
3572 list_del(&e->eq_list);
3580 ** push event to tail of the queue
3584 wl_enq_event(struct wl_priv *wl, u32 event, const brcmf_event_msg_t *msg,
3587 struct wl_event_q *e;
3590 e = kzalloc(sizeof(struct wl_event_q), GFP_KERNEL);
3592 WL_ERR("event alloc failed\n");
3597 memcpy(&e->emsg, msg, sizeof(brcmf_event_msg_t));
3601 list_add_tail(&e->eq_list, &wl->eq_list);
3607 static void wl_put_event(struct wl_event_q *e)
3612 void wl_cfg80211_sdio_func(void *func)
3614 cfg80211_sdio_func = (struct sdio_func *)func;
3617 static void wl_clear_sdio_func(void)
3619 cfg80211_sdio_func = NULL;
3622 struct sdio_func *wl_cfg80211_get_sdio_func(void)
3624 return cfg80211_sdio_func;
3627 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype)
3633 case NL80211_IFTYPE_MONITOR:
3634 case NL80211_IFTYPE_WDS:
3635 WL_ERR("type (%d) : currently we do not support this mode\n",
3639 case NL80211_IFTYPE_ADHOC:
3642 case NL80211_IFTYPE_STATION:
3647 WL_ERR("invalid type (%d)\n", iftype);
3650 infra = cpu_to_le32(infra);
3651 err = wl_dev_ioctl(ndev, BRCMF_C_SET_INFRA, &infra, sizeof(infra));
3652 if (unlikely(err)) {
3653 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
3660 #ifndef EMBEDDED_PLATFORM
3661 static s32 wl_dongle_country(struct net_device *ndev, u8 ccode)
3669 static s32 wl_dongle_up(struct net_device *ndev, u32 up)
3673 err = wl_dev_ioctl(ndev, BRCMF_C_UP, &up, sizeof(up));
3674 if (unlikely(err)) {
3675 WL_ERR("WLC_UP error (%d)\n", err);
3680 static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode)
3684 err = wl_dev_ioctl(ndev, BRCMF_C_SET_PM,
3685 &power_mode, sizeof(power_mode));
3686 if (unlikely(err)) {
3687 WL_ERR("WLC_SET_PM error (%d)\n", err);
3693 wl_dongle_glom(struct net_device *ndev, u32 glom, u32 dongle_align)
3695 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3699 /* Match Host and Dongle rx alignment */
3700 brcmu_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf,
3702 err = wl_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3703 if (unlikely(err)) {
3704 WL_ERR("txglomalign error (%d)\n", err);
3705 goto dongle_glom_out;
3707 /* disable glom option per default */
3708 brcmu_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));
3709 err = wl_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3710 if (unlikely(err)) {
3711 WL_ERR("txglom error (%d)\n", err);
3712 goto dongle_glom_out;
3719 wl_dongle_offload(struct net_device *ndev, s32 arpoe, s32 arp_ol)
3721 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3725 /* Set ARP offload */
3726 brcmu_mkiovar("arpoe", (char *)&arpoe, 4, iovbuf, sizeof(iovbuf));
3727 err = wl_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3729 if (err == -EOPNOTSUPP)
3730 WL_INFO("arpoe is not supported\n");
3732 WL_ERR("arpoe error (%d)\n", err);
3734 goto dongle_offload_out;
3736 brcmu_mkiovar("arp_ol", (char *)&arp_ol, 4, iovbuf, sizeof(iovbuf));
3737 err = wl_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3739 if (err == -EOPNOTSUPP)
3740 WL_INFO("arp_ol is not supported\n");
3742 WL_ERR("arp_ol error (%d)\n", err);
3744 goto dongle_offload_out;
3751 static s32 wl_pattern_atoh(s8 *src, s8 *dst)
3754 if (strncmp(src, "0x", 2) != 0 && strncmp(src, "0X", 2) != 0) {
3755 WL_ERR("Mask invalid format. Needs to start with 0x\n");
3758 src = src + 2; /* Skip past 0x */
3759 if (strlen(src) % 2 != 0) {
3760 WL_ERR("Mask invalid format. Needs to be of even length\n");
3763 for (i = 0; *src != '\0'; i++) {
3765 strncpy(num, src, 2);
3767 dst[i] = (u8) simple_strtoul(num, NULL, 16);
3773 static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode)
3775 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3778 struct wl_pkt_filter pkt_filter;
3779 struct wl_pkt_filter *pkt_filterp;
3787 /* add a default packet filter pattern */
3788 str = "pkt_filter_add";
3789 str_len = strlen(str);
3790 strncpy(buf, str, str_len);
3791 buf[str_len] = '\0';
3792 buf_len = str_len + 1;
3794 pkt_filterp = (struct wl_pkt_filter *)(buf + str_len + 1);
3796 /* Parse packet filter id. */
3797 pkt_filter.id = cpu_to_le32(100);
3799 /* Parse filter polarity. */
3800 pkt_filter.negate_match = cpu_to_le32(0);
3802 /* Parse filter type. */
3803 pkt_filter.type = cpu_to_le32(0);
3805 /* Parse pattern filter offset. */
3806 pkt_filter.u.pattern.offset = cpu_to_le32(0);
3808 /* Parse pattern filter mask. */
3809 mask_size = cpu_to_le32(wl_pattern_atoh("0xff",
3810 (char *)pkt_filterp->u.pattern.
3813 /* Parse pattern filter pattern. */
3814 pattern_size = cpu_to_le32(wl_pattern_atoh("0x00",
3815 (char *)&pkt_filterp->u.
3820 if (mask_size != pattern_size) {
3821 WL_ERR("Mask and pattern not the same size\n");
3823 goto dongle_filter_out;
3826 pkt_filter.u.pattern.size_bytes = mask_size;
3827 buf_len += WL_PKT_FILTER_FIXED_LEN;
3828 buf_len += (WL_PKT_FILTER_PATTERN_FIXED_LEN + 2 * mask_size);
3830 /* Keep-alive attributes are set in local
3831 * variable (keep_alive_pkt), and
3832 * then memcpy'ed into buffer (keep_alive_pktp) since there is no
3833 * guarantee that the buffer is properly aligned.
3835 memcpy((char *)pkt_filterp, &pkt_filter,
3836 WL_PKT_FILTER_FIXED_LEN + WL_PKT_FILTER_PATTERN_FIXED_LEN);
3838 err = wl_dev_ioctl(ndev, BRCMF_C_SET_VAR, buf, buf_len);
3840 if (err == -EOPNOTSUPP) {
3841 WL_INFO("filter not supported\n");
3843 WL_ERR("filter (%d)\n", err);
3845 goto dongle_filter_out;
3848 /* set mode to allow pattern */
3849 brcmu_mkiovar("pkt_filter_mode", (char *)&filter_mode, 4, iovbuf,
3851 err = wl_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3853 if (err == -EOPNOTSUPP) {
3854 WL_INFO("filter_mode not supported\n");
3856 WL_ERR("filter_mode (%d)\n", err);
3858 goto dongle_filter_out;
3864 #endif /* !EMBEDDED_PLATFORM */
3866 static s32 wl_dongle_eventmsg(struct net_device *ndev)
3868 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3870 s8 eventmask[WL_EVENTING_MASK_LEN];
3873 WL_TRACE("Enter\n");
3875 /* Setup event_msgs */
3876 brcmu_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
3878 err = wl_dev_ioctl(ndev, BRCMF_C_GET_VAR, iovbuf, sizeof(iovbuf));
3879 if (unlikely(err)) {
3880 WL_ERR("Get event_msgs error (%d)\n", err);
3881 goto dongle_eventmsg_out;
3883 memcpy(eventmask, iovbuf, WL_EVENTING_MASK_LEN);
3885 setbit(eventmask, BRCMF_E_SET_SSID);
3886 setbit(eventmask, BRCMF_E_ROAM);
3887 setbit(eventmask, BRCMF_E_PRUNE);
3888 setbit(eventmask, BRCMF_E_AUTH);
3889 setbit(eventmask, BRCMF_E_REASSOC);
3890 setbit(eventmask, BRCMF_E_REASSOC_IND);
3891 setbit(eventmask, BRCMF_E_DEAUTH_IND);
3892 setbit(eventmask, BRCMF_E_DISASSOC_IND);
3893 setbit(eventmask, BRCMF_E_DISASSOC);
3894 setbit(eventmask, BRCMF_E_JOIN);
3895 setbit(eventmask, BRCMF_E_ASSOC_IND);
3896 setbit(eventmask, BRCMF_E_PSK_SUP);
3897 setbit(eventmask, BRCMF_E_LINK);
3898 setbit(eventmask, BRCMF_E_NDIS_LINK);
3899 setbit(eventmask, BRCMF_E_MIC_ERROR);
3900 setbit(eventmask, BRCMF_E_PMKID_CACHE);
3901 setbit(eventmask, BRCMF_E_TXFAIL);
3902 setbit(eventmask, BRCMF_E_JOIN_START);
3903 setbit(eventmask, BRCMF_E_SCAN_COMPLETE);
3905 brcmu_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
3907 err = wl_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3908 if (unlikely(err)) {
3909 WL_ERR("Set event_msgs error (%d)\n", err);
3910 goto dongle_eventmsg_out;
3913 dongle_eventmsg_out:
3919 wl_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
3927 * Setup timeout if Beacons are lost and roam is
3928 * off to report link down
3931 brcmu_mkiovar("bcn_timeout", (char *)&bcn_timeout,
3932 sizeof(bcn_timeout), iovbuf, sizeof(iovbuf));
3933 err = wl_dev_ioctl(ndev, BRCMF_C_SET_VAR,
3934 iovbuf, sizeof(iovbuf));
3935 if (unlikely(err)) {
3936 WL_ERR("bcn_timeout error (%d)\n", err);
3937 goto dongle_rom_out;
3942 * Enable/Disable built-in roaming to allow supplicant
3943 * to take care of roaming
3945 WL_INFO("Internal Roaming = %s\n", roamvar ? "Off" : "On");
3946 brcmu_mkiovar("roam_off", (char *)&roamvar,
3947 sizeof(roamvar), iovbuf, sizeof(iovbuf));
3948 err = wl_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3949 if (unlikely(err)) {
3950 WL_ERR("roam_off error (%d)\n", err);
3951 goto dongle_rom_out;
3954 roamtrigger[0] = WL_ROAM_TRIGGER_LEVEL;
3955 roamtrigger[1] = WLC_BAND_ALL;
3956 err = wl_dev_ioctl(ndev, BRCMF_C_SET_ROAM_TRIGGER,
3957 (void *)roamtrigger, sizeof(roamtrigger));
3958 if (unlikely(err)) {
3959 WL_ERR("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
3960 goto dongle_rom_out;
3963 roam_delta[0] = WL_ROAM_DELTA;
3964 roam_delta[1] = WLC_BAND_ALL;
3965 err = wl_dev_ioctl(ndev, BRCMF_C_SET_ROAM_DELTA,
3966 (void *)roam_delta, sizeof(roam_delta));
3967 if (unlikely(err)) {
3968 WL_ERR("WLC_SET_ROAM_DELTA error (%d)\n", err);
3969 goto dongle_rom_out;
3977 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
3978 s32 scan_unassoc_time, s32 scan_passive_time)
3982 err = wl_dev_ioctl(ndev, BRCMF_C_SET_SCAN_CHANNEL_TIME,
3983 &scan_assoc_time, sizeof(scan_assoc_time));
3985 if (err == -EOPNOTSUPP)
3986 WL_INFO("Scan assoc time is not supported\n");
3988 WL_ERR("Scan assoc time error (%d)\n", err);
3989 goto dongle_scantime_out;
3991 err = wl_dev_ioctl(ndev, BRCMF_C_SET_SCAN_UNASSOC_TIME,
3992 &scan_unassoc_time, sizeof(scan_unassoc_time));
3994 if (err == -EOPNOTSUPP)
3995 WL_INFO("Scan unassoc time is not supported\n");
3997 WL_ERR("Scan unassoc time error (%d)\n", err);
3998 goto dongle_scantime_out;
4001 err = wl_dev_ioctl(ndev, BRCMF_C_SET_SCAN_PASSIVE_TIME,
4002 &scan_passive_time, sizeof(scan_passive_time));
4004 if (err == -EOPNOTSUPP)
4005 WL_INFO("Scan passive time is not supported\n");
4007 WL_ERR("Scan passive time error (%d)\n", err);
4008 goto dongle_scantime_out;
4011 dongle_scantime_out:
4015 s32 wl_config_dongle(struct wl_priv *wl, bool need_lock)
4018 #define DHD_SDALIGN 32
4020 struct net_device *ndev;
4021 struct wireless_dev *wdev;
4027 ndev = wl_to_ndev(wl);
4028 wdev = ndev->ieee80211_ptr;
4032 #ifndef EMBEDDED_PLATFORM
4033 err = wl_dongle_up(ndev, 0);
4035 goto default_conf_out;
4036 err = wl_dongle_country(ndev, 0);
4038 goto default_conf_out;
4039 err = wl_dongle_power(ndev, PM_FAST);
4041 goto default_conf_out;
4042 err = wl_dongle_glom(ndev, 0, DHD_SDALIGN);
4044 goto default_conf_out;
4046 wl_dongle_offload(ndev, 1, 0xf);
4047 wl_dongle_filter(ndev, 1);
4048 #endif /* !EMBEDDED_PLATFORM */
4050 wl_dongle_scantime(ndev, WL_SCAN_CHANNEL_TIME,
4051 WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
4053 err = wl_dongle_eventmsg(ndev);
4055 goto default_conf_out;
4056 err = wl_dongle_roam(ndev, (wl->roam_on ? 0 : 1), WL_BEACON_TIMEOUT);
4058 goto default_conf_out;
4059 err = wl_dongle_mode(ndev, wdev->iftype);
4060 if (unlikely(err && err != -EINPROGRESS))
4061 goto default_conf_out;
4062 err = wl_dongle_probecap(wl);
4064 goto default_conf_out;
4066 /* -EINPROGRESS: Call commit handler */
4072 wl->dongle_up = true;
4078 static s32 wl_update_wiphybands(struct wl_priv *wl)
4080 struct wiphy *wiphy;
4085 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_PHYLIST, &phy_list,
4087 if (unlikely(err)) {
4088 WL_ERR("error (%d)\n", err);
4092 phy = ((char *)&phy_list)[1];
4093 WL_INFO("%c phy\n", phy);
4094 if (phy == 'n' || phy == 'a') {
4095 wiphy = wl_to_wiphy(wl);
4096 wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
4102 static s32 __wl_cfg80211_up(struct wl_priv *wl)
4106 set_bit(WL_STATUS_READY, &wl->status);
4108 wl_debugfs_add_netdev_params(wl);
4110 err = wl_config_dongle(wl, false);
4114 wl_invoke_iscan(wl);
4119 static s32 __wl_cfg80211_down(struct wl_priv *wl)
4122 * While going down, if associated with AP disassociate
4123 * from AP to save power
4125 if ((test_bit(WL_STATUS_CONNECTED, &wl->status) ||
4126 test_bit(WL_STATUS_CONNECTING, &wl->status)) &&
4127 test_bit(WL_STATUS_READY, &wl->status)) {
4128 WL_INFO("Disassociating from AP");
4131 /* Make sure WPA_Supplicant receives all the event
4132 generated due to DISASSOC call to the fw to keep
4133 the state fw and WPA_Supplicant state consistent
4140 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
4142 if (wl->scan_request) {
4143 cfg80211_scan_done(wl->scan_request, true);
4144 /* May need to perform this to cover rmmod */
4145 /* wl_set_mpc(wl_to_ndev(wl), 1); */
4146 wl->scan_request = NULL;
4148 clear_bit(WL_STATUS_READY, &wl->status);
4149 clear_bit(WL_STATUS_SCANNING, &wl->status);
4150 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
4152 wl_debugfs_remove_netdev(wl);
4157 s32 wl_cfg80211_up(void)
4163 mutex_lock(&wl->usr_sync);
4164 err = __wl_cfg80211_up(wl);
4165 mutex_unlock(&wl->usr_sync);
4170 s32 wl_cfg80211_down(void)
4176 mutex_lock(&wl->usr_sync);
4177 err = __wl_cfg80211_down(wl);
4178 mutex_unlock(&wl->usr_sync);
4183 static s32 wl_dongle_probecap(struct wl_priv *wl)
4185 return wl_update_wiphybands(wl);
4188 static void *wl_read_prof(struct wl_priv *wl, s32 item)
4192 return &wl->profile->sec;
4194 return &wl->profile->bssid;
4196 return &wl->profile->ssid;
4198 WL_ERR("invalid item (%d)\n", item);
4203 wl_update_prof(struct wl_priv *wl, const brcmf_event_msg_t *e, void *data,
4207 struct wlc_ssid *ssid;
4211 ssid = (wlc_ssid_t *) data;
4212 memset(wl->profile->ssid.SSID, 0,
4213 sizeof(wl->profile->ssid.SSID));
4214 memcpy(wl->profile->ssid.SSID, ssid->SSID, ssid->SSID_len);
4215 wl->profile->ssid.SSID_len = ssid->SSID_len;
4219 memcpy(wl->profile->bssid, data, ETH_ALEN);
4221 memset(wl->profile->bssid, 0, ETH_ALEN);
4224 memcpy(&wl->profile->sec, data, sizeof(wl->profile->sec));
4226 case WL_PROF_BEACONINT:
4227 wl->profile->beacon_interval = *(u16 *)data;
4229 case WL_PROF_DTIMPERIOD:
4230 wl->profile->dtim_period = *(u8 *)data;
4233 WL_ERR("unsupported item (%d)\n", item);
4241 static bool wl_is_ibssmode(struct wl_priv *wl)
4243 return wl->conf->mode == WL_MODE_IBSS;
4246 static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v)
4248 struct wl_ie *ie = wl_to_ie(wl);
4251 if (unlikely(ie->offset + l + 2 > WL_TLV_INFO_MAX)) {
4252 WL_ERR("ei crosses buffer boundary\n");
4255 ie->buf[ie->offset] = t;
4256 ie->buf[ie->offset + 1] = l;
4257 memcpy(&ie->buf[ie->offset + 2], v, l);
4258 ie->offset += l + 2;
4263 static void wl_link_down(struct wl_priv *wl)
4265 struct net_device *dev = NULL;
4268 WL_TRACE("Enter\n");
4271 dev = wl_to_ndev(wl);
4272 WL_INFO("Call WLC_DISASSOC to stop excess roaming\n ");
4273 err = wl_dev_ioctl(dev, BRCMF_C_DISASSOC, NULL, 0);
4275 WL_ERR("WLC_DISASSOC failed (%d)\n", err);
4276 wl->link_up = false;
4281 static void wl_lock_eq(struct wl_priv *wl)
4283 spin_lock_irq(&wl->eq_lock);
4286 static void wl_unlock_eq(struct wl_priv *wl)
4288 spin_unlock_irq(&wl->eq_lock);
4291 static void wl_init_eq_lock(struct wl_priv *wl)
4293 spin_lock_init(&wl->eq_lock);
4296 static void wl_delay(u32 ms)
4298 if (ms < 1000 / HZ) {
4306 static void wl_set_drvdata(struct wl_dev *dev, void *data)
4308 dev->driver_data = data;
4311 static void *wl_get_drvdata(struct wl_dev *dev)
4316 data = dev->driver_data;
4320 s32 wl_cfg80211_read_fw(s8 *buf, u32 size)
4322 const struct firmware *fw_entry;
4327 fw_entry = wl->fw->fw_entry;
4329 if (fw_entry->size < wl->fw->ptr + size)
4330 size = fw_entry->size - wl->fw->ptr;
4332 memcpy(buf, &fw_entry->data[wl->fw->ptr], size);
4333 wl->fw->ptr += size;
4337 void wl_cfg80211_release_fw(void)
4342 release_firmware(wl->fw->fw_entry);
4346 void *wl_cfg80211_request_fw(s8 *file_name)
4349 const struct firmware *fw_entry = NULL;
4352 WL_INFO("file name : \"%s\"\n", file_name);
4355 if (!test_bit(WL_FW_LOADING_DONE, &wl->fw->status)) {
4356 err = request_firmware(&wl->fw->fw_entry, file_name,
4357 &wl_cfg80211_get_sdio_func()->dev);
4358 if (unlikely(err)) {
4359 WL_ERR("Could not download fw (%d)\n", err);
4362 set_bit(WL_FW_LOADING_DONE, &wl->fw->status);
4363 fw_entry = wl->fw->fw_entry;
4365 WL_INFO("fw size (%zd), data (%p)\n",
4366 fw_entry->size, fw_entry->data);
4368 } else if (!test_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status)) {
4369 err = request_firmware(&wl->fw->fw_entry, file_name,
4370 &wl_cfg80211_get_sdio_func()->dev);
4371 if (unlikely(err)) {
4372 WL_ERR("Could not download nvram (%d)\n", err);
4375 set_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status);
4376 fw_entry = wl->fw->fw_entry;
4378 WL_INFO("nvram size (%zd), data (%p)\n",
4379 fw_entry->size, fw_entry->data);
4382 WL_INFO("Downloading already done. Nothing to do more\n");
4387 if (unlikely(err)) {
4391 return (void *)fw_entry->data;
4394 s8 *wl_cfg80211_get_fwname(void)
4399 strcpy(wl->fw->fw_name, WL_4329_FW_FILE);
4400 return wl->fw->fw_name;
4403 s8 *wl_cfg80211_get_nvramname(void)
4408 strcpy(wl->fw->nvram_name, WL_4329_NVRAM_FILE);
4409 return wl->fw->nvram_name;
4412 static void wl_set_mpc(struct net_device *ndev, int mpc)
4415 struct wl_priv *wl = ndev_to_wl(ndev);
4417 if (test_bit(WL_STATUS_READY, &wl->status)) {
4418 err = wl_dev_intvar_set(ndev, "mpc", mpc);
4419 if (unlikely(err)) {
4420 WL_ERR("fail to set mpc\n");
4423 WL_INFO("MPC : %d\n", mpc);
4427 static int wl_debugfs_add_netdev_params(struct wl_priv *wl)
4429 char buf[10+IFNAMSIZ];
4433 sprintf(buf, "netdev:%s", wl_to_ndev(wl)->name);
4434 wl->debugfsdir = debugfs_create_dir(buf, wl_to_wiphy(wl)->debugfsdir);
4436 fd = debugfs_create_u16("beacon_int", S_IRUGO, wl->debugfsdir,
4437 (u16 *)&wl->profile->beacon_interval);
4443 fd = debugfs_create_u8("dtim_period", S_IRUGO, wl->debugfsdir,
4444 (u8 *)&wl->profile->dtim_period);
4454 static void wl_debugfs_remove_netdev(struct wl_priv *wl)
4456 debugfs_remove_recursive(wl->debugfsdir);
4457 wl->debugfsdir = NULL;