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 wl_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 wl_event_msg_t *e, void *data);
132 static s32 wl_notify_roaming_status(struct wl_priv *wl,
133 struct net_device *ndev,
134 const wl_event_msg_t *e, void *data);
135 static s32 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
136 const wl_event_msg_t *e, void *data);
137 static s32 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
138 const wl_event_msg_t *e, void *data,
140 static s32 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
141 const wl_event_msg_t *e, void *data);
142 static s32 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
143 const wl_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 wl_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 wl_event_msg_t *e);
241 static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e);
242 static bool wl_is_nonetwork(struct wl_priv *wl, const wl_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 extern int dhd_wait_pend8021x(struct net_device *dev);
346 #define CHAN2G(_channel, _freq, _flags) { \
347 .band = IEEE80211_BAND_2GHZ, \
348 .center_freq = (_freq), \
349 .hw_value = (_channel), \
351 .max_antenna_gain = 0, \
355 #define CHAN5G(_channel, _flags) { \
356 .band = IEEE80211_BAND_5GHZ, \
357 .center_freq = 5000 + (5 * (_channel)), \
358 .hw_value = (_channel), \
360 .max_antenna_gain = 0, \
364 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
365 #define RATETAB_ENT(_rateid, _flags) \
367 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
368 .hw_value = (_rateid), \
372 static struct ieee80211_rate __wl_rates[] = {
373 RATETAB_ENT(WLC_RATE_1M, 0),
374 RATETAB_ENT(WLC_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
375 RATETAB_ENT(WLC_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
376 RATETAB_ENT(WLC_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
377 RATETAB_ENT(WLC_RATE_6M, 0),
378 RATETAB_ENT(WLC_RATE_9M, 0),
379 RATETAB_ENT(WLC_RATE_12M, 0),
380 RATETAB_ENT(WLC_RATE_18M, 0),
381 RATETAB_ENT(WLC_RATE_24M, 0),
382 RATETAB_ENT(WLC_RATE_36M, 0),
383 RATETAB_ENT(WLC_RATE_48M, 0),
384 RATETAB_ENT(WLC_RATE_54M, 0),
387 #define wl_a_rates (__wl_rates + 4)
388 #define wl_a_rates_size 8
389 #define wl_g_rates (__wl_rates + 0)
390 #define wl_g_rates_size 12
392 static struct ieee80211_channel __wl_2ghz_channels[] = {
409 static struct ieee80211_channel __wl_5ghz_a_channels[] = {
410 CHAN5G(34, 0), CHAN5G(36, 0),
411 CHAN5G(38, 0), CHAN5G(40, 0),
412 CHAN5G(42, 0), CHAN5G(44, 0),
413 CHAN5G(46, 0), CHAN5G(48, 0),
414 CHAN5G(52, 0), CHAN5G(56, 0),
415 CHAN5G(60, 0), CHAN5G(64, 0),
416 CHAN5G(100, 0), CHAN5G(104, 0),
417 CHAN5G(108, 0), CHAN5G(112, 0),
418 CHAN5G(116, 0), CHAN5G(120, 0),
419 CHAN5G(124, 0), CHAN5G(128, 0),
420 CHAN5G(132, 0), CHAN5G(136, 0),
421 CHAN5G(140, 0), CHAN5G(149, 0),
422 CHAN5G(153, 0), CHAN5G(157, 0),
423 CHAN5G(161, 0), CHAN5G(165, 0),
424 CHAN5G(184, 0), CHAN5G(188, 0),
425 CHAN5G(192, 0), CHAN5G(196, 0),
426 CHAN5G(200, 0), CHAN5G(204, 0),
427 CHAN5G(208, 0), CHAN5G(212, 0),
431 static struct ieee80211_channel __wl_5ghz_n_channels[] = {
432 CHAN5G(32, 0), CHAN5G(34, 0),
433 CHAN5G(36, 0), CHAN5G(38, 0),
434 CHAN5G(40, 0), CHAN5G(42, 0),
435 CHAN5G(44, 0), CHAN5G(46, 0),
436 CHAN5G(48, 0), CHAN5G(50, 0),
437 CHAN5G(52, 0), CHAN5G(54, 0),
438 CHAN5G(56, 0), CHAN5G(58, 0),
439 CHAN5G(60, 0), CHAN5G(62, 0),
440 CHAN5G(64, 0), CHAN5G(66, 0),
441 CHAN5G(68, 0), CHAN5G(70, 0),
442 CHAN5G(72, 0), CHAN5G(74, 0),
443 CHAN5G(76, 0), CHAN5G(78, 0),
444 CHAN5G(80, 0), CHAN5G(82, 0),
445 CHAN5G(84, 0), CHAN5G(86, 0),
446 CHAN5G(88, 0), CHAN5G(90, 0),
447 CHAN5G(92, 0), CHAN5G(94, 0),
448 CHAN5G(96, 0), CHAN5G(98, 0),
449 CHAN5G(100, 0), CHAN5G(102, 0),
450 CHAN5G(104, 0), CHAN5G(106, 0),
451 CHAN5G(108, 0), CHAN5G(110, 0),
452 CHAN5G(112, 0), CHAN5G(114, 0),
453 CHAN5G(116, 0), CHAN5G(118, 0),
454 CHAN5G(120, 0), CHAN5G(122, 0),
455 CHAN5G(124, 0), CHAN5G(126, 0),
456 CHAN5G(128, 0), CHAN5G(130, 0),
457 CHAN5G(132, 0), CHAN5G(134, 0),
458 CHAN5G(136, 0), CHAN5G(138, 0),
459 CHAN5G(140, 0), CHAN5G(142, 0),
460 CHAN5G(144, 0), CHAN5G(145, 0),
461 CHAN5G(146, 0), CHAN5G(147, 0),
462 CHAN5G(148, 0), CHAN5G(149, 0),
463 CHAN5G(150, 0), CHAN5G(151, 0),
464 CHAN5G(152, 0), CHAN5G(153, 0),
465 CHAN5G(154, 0), CHAN5G(155, 0),
466 CHAN5G(156, 0), CHAN5G(157, 0),
467 CHAN5G(158, 0), CHAN5G(159, 0),
468 CHAN5G(160, 0), CHAN5G(161, 0),
469 CHAN5G(162, 0), CHAN5G(163, 0),
470 CHAN5G(164, 0), CHAN5G(165, 0),
471 CHAN5G(166, 0), CHAN5G(168, 0),
472 CHAN5G(170, 0), CHAN5G(172, 0),
473 CHAN5G(174, 0), CHAN5G(176, 0),
474 CHAN5G(178, 0), CHAN5G(180, 0),
475 CHAN5G(182, 0), CHAN5G(184, 0),
476 CHAN5G(186, 0), CHAN5G(188, 0),
477 CHAN5G(190, 0), CHAN5G(192, 0),
478 CHAN5G(194, 0), CHAN5G(196, 0),
479 CHAN5G(198, 0), CHAN5G(200, 0),
480 CHAN5G(202, 0), CHAN5G(204, 0),
481 CHAN5G(206, 0), CHAN5G(208, 0),
482 CHAN5G(210, 0), CHAN5G(212, 0),
483 CHAN5G(214, 0), CHAN5G(216, 0),
484 CHAN5G(218, 0), CHAN5G(220, 0),
485 CHAN5G(222, 0), CHAN5G(224, 0),
486 CHAN5G(226, 0), CHAN5G(228, 0),
489 static struct ieee80211_supported_band __wl_band_2ghz = {
490 .band = IEEE80211_BAND_2GHZ,
491 .channels = __wl_2ghz_channels,
492 .n_channels = ARRAY_SIZE(__wl_2ghz_channels),
493 .bitrates = wl_g_rates,
494 .n_bitrates = wl_g_rates_size,
497 static struct ieee80211_supported_band __wl_band_5ghz_a = {
498 .band = IEEE80211_BAND_5GHZ,
499 .channels = __wl_5ghz_a_channels,
500 .n_channels = ARRAY_SIZE(__wl_5ghz_a_channels),
501 .bitrates = wl_a_rates,
502 .n_bitrates = wl_a_rates_size,
505 static struct ieee80211_supported_band __wl_band_5ghz_n = {
506 .band = IEEE80211_BAND_5GHZ,
507 .channels = __wl_5ghz_n_channels,
508 .n_channels = ARRAY_SIZE(__wl_5ghz_n_channels),
509 .bitrates = wl_a_rates,
510 .n_bitrates = wl_a_rates_size,
513 static const u32 __wl_cipher_suites[] = {
514 WLAN_CIPHER_SUITE_WEP40,
515 WLAN_CIPHER_SUITE_WEP104,
516 WLAN_CIPHER_SUITE_TKIP,
517 WLAN_CIPHER_SUITE_CCMP,
518 WLAN_CIPHER_SUITE_AES_CMAC,
521 static void swap_key_from_BE(struct wl_wsec_key *key)
523 key->index = cpu_to_le32(key->index);
524 key->len = cpu_to_le32(key->len);
525 key->algo = cpu_to_le32(key->algo);
526 key->flags = cpu_to_le32(key->flags);
527 key->rxiv.hi = cpu_to_le32(key->rxiv.hi);
528 key->rxiv.lo = cpu_to_le16(key->rxiv.lo);
529 key->iv_initialized = cpu_to_le32(key->iv_initialized);
532 static void swap_key_to_BE(struct wl_wsec_key *key)
534 key->index = le32_to_cpu(key->index);
535 key->len = le32_to_cpu(key->len);
536 key->algo = le32_to_cpu(key->algo);
537 key->flags = le32_to_cpu(key->flags);
538 key->rxiv.hi = le32_to_cpu(key->rxiv.hi);
539 key->rxiv.lo = le16_to_cpu(key->rxiv.lo);
540 key->iv_initialized = le32_to_cpu(key->iv_initialized);
544 wl_dev_ioctl(struct net_device *dev, u32 cmd, void *arg, u32 len)
551 memset(&ioc, 0, sizeof(ioc));
555 strcpy(ifr.ifr_name, dev->name);
556 ifr.ifr_data = (caddr_t)&ioc;
560 err = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
567 wl_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
568 enum nl80211_iftype type, u32 *flags,
569 struct vif_params *params)
571 struct wl_priv *wl = wiphy_to_wl(wiphy);
572 struct wireless_dev *wdev;
580 case NL80211_IFTYPE_MONITOR:
581 case NL80211_IFTYPE_WDS:
582 WL_ERR("type (%d) : currently we do not support this type\n",
585 case NL80211_IFTYPE_ADHOC:
586 wl->conf->mode = WL_MODE_IBSS;
589 case NL80211_IFTYPE_STATION:
590 wl->conf->mode = WL_MODE_BSS;
598 infra = cpu_to_le32(infra);
599 err = wl_dev_ioctl(ndev, BRCMF_C_SET_INFRA, &infra, sizeof(infra));
601 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
604 wdev = ndev->ieee80211_ptr;
608 WL_INFO("IF Type = %s\n",
609 (wl->conf->mode == WL_MODE_IBSS) ? "Adhoc" : "Infra");
617 static void wl_iscan_prep(struct wl_scan_params *params, struct wlc_ssid *ssid)
619 memcpy(params->bssid, ether_bcast, ETH_ALEN);
620 params->bss_type = DOT11_BSSTYPE_ANY;
621 params->scan_type = 0;
622 params->nprobes = -1;
623 params->active_time = -1;
624 params->passive_time = -1;
625 params->home_time = -1;
626 params->channel_num = 0;
628 params->nprobes = cpu_to_le32(params->nprobes);
629 params->active_time = cpu_to_le32(params->active_time);
630 params->passive_time = cpu_to_le32(params->passive_time);
631 params->home_time = cpu_to_le32(params->home_time);
632 if (ssid && ssid->SSID_len)
633 memcpy(¶ms->ssid, ssid, sizeof(wlc_ssid_t));
638 wl_dev_iovar_setbuf(struct net_device *dev, s8 * iovar, void *param,
639 s32 paramlen, void *bufptr, s32 buflen)
643 iolen = brcmu_mkiovar(iovar, param, paramlen, bufptr, buflen);
646 return wl_dev_ioctl(dev, BRCMF_C_SET_VAR, bufptr, iolen);
650 wl_dev_iovar_getbuf(struct net_device *dev, s8 * iovar, void *param,
651 s32 paramlen, void *bufptr, s32 buflen)
655 iolen = brcmu_mkiovar(iovar, param, paramlen, bufptr, buflen);
658 return wl_dev_ioctl(dev, BRCMF_C_GET_VAR, bufptr, buflen);
662 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid, u16 action)
665 (WL_SCAN_PARAMS_FIXED_SIZE + offsetof(wl_iscan_params_t, params));
666 struct wl_iscan_params *params;
669 if (ssid && ssid->SSID_len)
670 params_size += sizeof(struct wlc_ssid);
671 params = kzalloc(params_size, GFP_KERNEL);
672 if (unlikely(!params))
674 BUG_ON(params_size >= BRCMF_C_IOCTL_SMLEN);
676 wl_iscan_prep(¶ms->params, ssid);
678 params->version = cpu_to_le32(ISCAN_REQ_VERSION);
679 params->action = cpu_to_le16(action);
680 params->scan_duration = cpu_to_le16(0);
682 /* params_size += offsetof(wl_iscan_params_t, params); */
683 err = wl_dev_iovar_setbuf(iscan->dev, "iscan", params, params_size,
684 iscan->ioctl_buf, BRCMF_C_IOCTL_SMLEN);
687 WL_INFO("system busy : iscan canceled\n");
689 WL_ERR("error (%d)\n", err);
696 static s32 wl_do_iscan(struct wl_priv *wl)
698 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
699 struct net_device *ndev = wl_to_ndev(wl);
700 struct wlc_ssid ssid;
704 /* Broadcast scan by default */
705 memset(&ssid, 0, sizeof(ssid));
707 iscan->state = WL_ISCAN_STATE_SCANING;
709 passive_scan = wl->active_scan ? 0 : 1;
710 err = wl_dev_ioctl(wl_to_ndev(wl), BRCMF_C_SET_PASSIVE_SCAN,
711 &passive_scan, sizeof(passive_scan));
713 WL_ERR("error (%d)\n", err);
717 wl->iscan_kickstart = true;
718 wl_run_iscan(iscan, &ssid, WL_SCAN_ACTION_START);
719 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
726 __wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
727 struct cfg80211_scan_request *request,
728 struct cfg80211_ssid *this_ssid)
730 struct wl_priv *wl = ndev_to_wl(ndev);
731 struct cfg80211_ssid *ssids;
732 struct wl_scan_req *sr = wl_to_sr(wl);
738 if (unlikely(test_bit(WL_STATUS_SCANNING, &wl->status))) {
739 WL_ERR("Scanning already : status (%d)\n", (int)wl->status);
742 if (unlikely(test_bit(WL_STATUS_SCAN_ABORTING, &wl->status))) {
743 WL_ERR("Scanning being aborted : status (%d)\n",
747 if (test_bit(WL_STATUS_CONNECTING, &wl->status)) {
748 WL_ERR("Connecting : status (%d)\n",
757 ssids = request->ssids;
758 if (wl->iscan_on && (!ssids || !ssids->ssid_len))
762 /* we don't do iscan in ibss */
766 wl->scan_request = request;
767 set_bit(WL_STATUS_SCANNING, &wl->status);
769 err = wl_do_iscan(wl);
775 WL_SCAN("ssid \"%s\", ssid_len (%d)\n",
776 ssids->ssid, ssids->ssid_len);
777 memset(&sr->ssid, 0, sizeof(sr->ssid));
779 min_t(u8, sizeof(sr->ssid.SSID), ssids->ssid_len);
780 if (sr->ssid.SSID_len) {
781 memcpy(sr->ssid.SSID, ssids->ssid, sr->ssid.SSID_len);
782 sr->ssid.SSID_len = cpu_to_le32(sr->ssid.SSID_len);
785 WL_SCAN("Broadcast scan\n");
788 passive_scan = wl->active_scan ? 0 : 1;
789 err = wl_dev_ioctl(ndev, BRCMF_C_SET_PASSIVE_SCAN,
790 &passive_scan, sizeof(passive_scan));
792 WL_ERR("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
796 err = wl_dev_ioctl(ndev, BRCMF_C_SCAN, &sr->ssid,
800 WL_INFO("system busy : scan for \"%s\" canceled\n",
803 WL_ERR("WLC_SCAN error (%d)\n", err);
813 clear_bit(WL_STATUS_SCANNING, &wl->status);
814 wl->scan_request = NULL;
819 wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
820 struct cfg80211_scan_request *request)
828 err = __wl_cfg80211_scan(wiphy, ndev, request, NULL);
830 WL_ERR("scan error (%d)\n", err);
836 static s32 wl_dev_intvar_set(struct net_device *dev, s8 *name, s32 val)
838 s8 buf[BRCMF_C_IOCTL_SMLEN];
842 val = cpu_to_le32(val);
843 len = brcmu_mkiovar(name, (char *)(&val), sizeof(val), buf,
847 err = wl_dev_ioctl(dev, BRCMF_C_SET_VAR, buf, len);
849 WL_ERR("error (%d)\n", err);
855 wl_dev_intvar_get(struct net_device *dev, s8 *name, s32 *retval)
858 s8 buf[BRCMF_C_IOCTL_SMLEN];
866 brcmu_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
869 err = wl_dev_ioctl(dev, BRCMF_C_GET_VAR, &var, len);
871 WL_ERR("error (%d)\n", err);
873 *retval = le32_to_cpu(var.val);
878 static s32 wl_set_rts(struct net_device *dev, u32 rts_threshold)
882 err = wl_dev_intvar_set(dev, "rtsthresh", rts_threshold);
884 WL_ERR("Error (%d)\n", err);
889 static s32 wl_set_frag(struct net_device *dev, u32 frag_threshold)
893 err = wl_dev_intvar_set(dev, "fragthresh", frag_threshold);
895 WL_ERR("Error (%d)\n", err);
900 static s32 wl_set_retry(struct net_device *dev, u32 retry, bool l)
903 u32 cmd = (l ? WLC_SET_LRL : WLC_SET_SRL);
905 retry = cpu_to_le32(retry);
906 err = wl_dev_ioctl(dev, cmd, &retry, sizeof(retry));
908 WL_ERR("cmd (%d) , error (%d)\n", cmd, err);
914 static s32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
916 struct wl_priv *wl = wiphy_to_wl(wiphy);
917 struct net_device *ndev = wl_to_ndev(wl);
923 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
924 (wl->conf->rts_threshold != wiphy->rts_threshold)) {
925 wl->conf->rts_threshold = wiphy->rts_threshold;
926 err = wl_set_rts(ndev, wl->conf->rts_threshold);
930 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
931 (wl->conf->frag_threshold != wiphy->frag_threshold)) {
932 wl->conf->frag_threshold = wiphy->frag_threshold;
933 err = wl_set_frag(ndev, wl->conf->frag_threshold);
937 if (changed & WIPHY_PARAM_RETRY_LONG
938 && (wl->conf->retry_long != wiphy->retry_long)) {
939 wl->conf->retry_long = wiphy->retry_long;
940 err = wl_set_retry(ndev, wl->conf->retry_long, true);
944 if (changed & WIPHY_PARAM_RETRY_SHORT
945 && (wl->conf->retry_short != wiphy->retry_short)) {
946 wl->conf->retry_short = wiphy->retry_short;
947 err = wl_set_retry(ndev, wl->conf->retry_short, false);
958 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
959 struct cfg80211_ibss_params *params)
961 struct wl_priv *wl = wiphy_to_wl(wiphy);
962 struct wl_join_params join_params;
963 size_t join_params_size = 0;
972 WL_CONN("SSID: %s\n", params->ssid);
974 WL_CONN("SSID: NULL, Not supported\n");
978 set_bit(WL_STATUS_CONNECTING, &wl->status);
981 WL_CONN("BSSID: %02X %02X %02X %02X %02X %02X\n",
982 params->bssid[0], params->bssid[1], params->bssid[2],
983 params->bssid[3], params->bssid[4], params->bssid[5]);
985 WL_CONN("No BSSID specified\n");
988 WL_CONN("channel: %d\n", params->channel->center_freq);
990 WL_CONN("no channel specified\n");
992 if (params->channel_fixed)
993 WL_CONN("fixed channel required\n");
995 WL_CONN("no fixed channel required\n");
997 if (params->ie && params->ie_len)
998 WL_CONN("ie len: %d\n", params->ie_len);
1000 WL_CONN("no ie specified\n");
1002 if (params->beacon_interval)
1003 WL_CONN("beacon interval: %d\n", params->beacon_interval);
1005 WL_CONN("no beacon interval specified\n");
1007 if (params->basic_rates)
1008 WL_CONN("basic rates: %08X\n", params->basic_rates);
1010 WL_CONN("no basic rates specified\n");
1012 if (params->privacy)
1013 WL_CONN("privacy required\n");
1015 WL_CONN("no privacy required\n");
1017 /* Configure Privacy for starter */
1018 if (params->privacy)
1019 wsec |= WEP_ENABLED;
1021 err = wl_dev_intvar_set(dev, "wsec", wsec);
1022 if (unlikely(err)) {
1023 WL_ERR("wsec failed (%d)\n", err);
1027 /* Configure Beacon Interval for starter */
1028 if (params->beacon_interval)
1029 bcnprd = cpu_to_le32(params->beacon_interval);
1031 bcnprd = cpu_to_le32(100);
1033 err = wl_dev_ioctl(dev, WLC_SET_BCNPRD, &bcnprd, sizeof(bcnprd));
1034 if (unlikely(err)) {
1035 WL_ERR("WLC_SET_BCNPRD failed (%d)\n", err);
1039 /* Configure required join parameter */
1040 memset(&join_params, 0, sizeof(wl_join_params_t));
1043 join_params.ssid.SSID_len =
1044 (params->ssid_len > 32) ? 32 : params->ssid_len;
1045 memcpy(join_params.ssid.SSID, params->ssid, join_params.ssid.SSID_len);
1046 join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1047 join_params_size = sizeof(join_params.ssid);
1048 wl_update_prof(wl, NULL, &join_params.ssid, WL_PROF_SSID);
1051 if (params->bssid) {
1052 memcpy(join_params.params.bssid, params->bssid, ETH_ALEN);
1054 sizeof(join_params.ssid) + WL_ASSOC_PARAMS_FIXED_SIZE;
1056 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1058 wl_update_prof(wl, NULL, &join_params.params.bssid, WL_PROF_BSSID);
1061 if (params->channel) {
1065 ieee80211_frequency_to_channel(
1066 params->channel->center_freq);
1067 if (params->channel_fixed) {
1068 /* adding chanspec */
1069 wl_ch_to_chanspec(wl->channel,
1070 &join_params, &join_params_size);
1073 /* set channel for starter */
1074 target_channel = cpu_to_le32(wl->channel);
1075 err = wl_dev_ioctl(dev, WLC_SET_CHANNEL,
1076 &target_channel, sizeof(target_channel));
1077 if (unlikely(err)) {
1078 WL_ERR("WLC_SET_CHANNEL failed (%d)\n", err);
1084 wl->ibss_starter = false;
1087 err = wl_dev_ioctl(dev, BRCMF_C_SET_SSID,
1088 &join_params, join_params_size);
1089 if (unlikely(err)) {
1090 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1096 clear_bit(WL_STATUS_CONNECTING, &wl->status);
1101 static s32 wl_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1103 struct wl_priv *wl = wiphy_to_wl(wiphy);
1106 WL_TRACE("Enter\n");
1117 wl_set_wpa_version(struct net_device *dev, struct cfg80211_connect_params *sme)
1119 struct wl_priv *wl = ndev_to_wl(dev);
1120 struct wl_security *sec;
1124 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1125 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1126 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1127 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1129 val = WPA_AUTH_DISABLED;
1130 WL_CONN("setting wpa_auth to 0x%0x\n", val);
1131 err = wl_dev_intvar_set(dev, "wpa_auth", val);
1132 if (unlikely(err)) {
1133 WL_ERR("set wpa_auth failed (%d)\n", err);
1136 sec = wl_read_prof(wl, WL_PROF_SEC);
1137 sec->wpa_versions = sme->crypto.wpa_versions;
1142 wl_set_auth_type(struct net_device *dev, struct cfg80211_connect_params *sme)
1144 struct wl_priv *wl = ndev_to_wl(dev);
1145 struct wl_security *sec;
1149 switch (sme->auth_type) {
1150 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1152 WL_CONN("open system\n");
1154 case NL80211_AUTHTYPE_SHARED_KEY:
1156 WL_CONN("shared key\n");
1158 case NL80211_AUTHTYPE_AUTOMATIC:
1160 WL_CONN("automatic\n");
1162 case NL80211_AUTHTYPE_NETWORK_EAP:
1163 WL_CONN("network eap\n");
1166 WL_ERR("invalid auth type (%d)\n", sme->auth_type);
1170 err = wl_dev_intvar_set(dev, "auth", val);
1171 if (unlikely(err)) {
1172 WL_ERR("set auth failed (%d)\n", err);
1175 sec = wl_read_prof(wl, WL_PROF_SEC);
1176 sec->auth_type = sme->auth_type;
1181 wl_set_set_cipher(struct net_device *dev, struct cfg80211_connect_params *sme)
1183 struct wl_priv *wl = ndev_to_wl(dev);
1184 struct wl_security *sec;
1189 if (sme->crypto.n_ciphers_pairwise) {
1190 switch (sme->crypto.ciphers_pairwise[0]) {
1191 case WLAN_CIPHER_SUITE_WEP40:
1192 case WLAN_CIPHER_SUITE_WEP104:
1195 case WLAN_CIPHER_SUITE_TKIP:
1196 pval = TKIP_ENABLED;
1198 case WLAN_CIPHER_SUITE_CCMP:
1201 case WLAN_CIPHER_SUITE_AES_CMAC:
1205 WL_ERR("invalid cipher pairwise (%d)\n",
1206 sme->crypto.ciphers_pairwise[0]);
1210 if (sme->crypto.cipher_group) {
1211 switch (sme->crypto.cipher_group) {
1212 case WLAN_CIPHER_SUITE_WEP40:
1213 case WLAN_CIPHER_SUITE_WEP104:
1216 case WLAN_CIPHER_SUITE_TKIP:
1217 gval = TKIP_ENABLED;
1219 case WLAN_CIPHER_SUITE_CCMP:
1222 case WLAN_CIPHER_SUITE_AES_CMAC:
1226 WL_ERR("invalid cipher group (%d)\n",
1227 sme->crypto.cipher_group);
1232 WL_CONN("pval (%d) gval (%d)\n", pval, gval);
1233 err = wl_dev_intvar_set(dev, "wsec", pval | gval);
1234 if (unlikely(err)) {
1235 WL_ERR("error (%d)\n", err);
1239 sec = wl_read_prof(wl, WL_PROF_SEC);
1240 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1241 sec->cipher_group = sme->crypto.cipher_group;
1247 wl_set_key_mgmt(struct net_device *dev, struct cfg80211_connect_params *sme)
1249 struct wl_priv *wl = ndev_to_wl(dev);
1250 struct wl_security *sec;
1254 if (sme->crypto.n_akm_suites) {
1255 err = wl_dev_intvar_get(dev, "wpa_auth", &val);
1256 if (unlikely(err)) {
1257 WL_ERR("could not get wpa_auth (%d)\n", err);
1260 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1261 switch (sme->crypto.akm_suites[0]) {
1262 case WLAN_AKM_SUITE_8021X:
1263 val = WPA_AUTH_UNSPECIFIED;
1265 case WLAN_AKM_SUITE_PSK:
1269 WL_ERR("invalid cipher group (%d)\n",
1270 sme->crypto.cipher_group);
1273 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1274 switch (sme->crypto.akm_suites[0]) {
1275 case WLAN_AKM_SUITE_8021X:
1276 val = WPA2_AUTH_UNSPECIFIED;
1278 case WLAN_AKM_SUITE_PSK:
1279 val = WPA2_AUTH_PSK;
1282 WL_ERR("invalid cipher group (%d)\n",
1283 sme->crypto.cipher_group);
1288 WL_CONN("setting wpa_auth to %d\n", val);
1289 err = wl_dev_intvar_set(dev, "wpa_auth", val);
1290 if (unlikely(err)) {
1291 WL_ERR("could not set wpa_auth (%d)\n", err);
1295 sec = wl_read_prof(wl, WL_PROF_SEC);
1296 sec->wpa_auth = sme->crypto.akm_suites[0];
1302 wl_set_set_sharedkey(struct net_device *dev,
1303 struct cfg80211_connect_params *sme)
1305 struct wl_priv *wl = ndev_to_wl(dev);
1306 struct wl_security *sec;
1307 struct wl_wsec_key key;
1311 WL_CONN("key len (%d)\n", sme->key_len);
1313 sec = wl_read_prof(wl, WL_PROF_SEC);
1314 WL_CONN("wpa_versions 0x%x cipher_pairwise 0x%x\n",
1315 sec->wpa_versions, sec->cipher_pairwise);
1317 (sec->wpa_versions & (NL80211_WPA_VERSION_1 |
1318 NL80211_WPA_VERSION_2))
1319 && (sec->cipher_pairwise & (WLAN_CIPHER_SUITE_WEP40 |
1320 WLAN_CIPHER_SUITE_WEP104))) {
1321 memset(&key, 0, sizeof(key));
1322 key.len = (u32) sme->key_len;
1323 key.index = (u32) sme->key_idx;
1324 if (unlikely(key.len > sizeof(key.data))) {
1325 WL_ERR("Too long key length (%u)\n", key.len);
1328 memcpy(key.data, sme->key, key.len);
1329 key.flags = WL_PRIMARY_KEY;
1330 switch (sec->cipher_pairwise) {
1331 case WLAN_CIPHER_SUITE_WEP40:
1332 key.algo = CRYPTO_ALGO_WEP1;
1334 case WLAN_CIPHER_SUITE_WEP104:
1335 key.algo = CRYPTO_ALGO_WEP128;
1338 WL_ERR("Invalid algorithm (%d)\n",
1339 sme->crypto.ciphers_pairwise[0]);
1342 /* Set the new key/index */
1343 WL_CONN("key length (%d) key index (%d) algo (%d)\n",
1344 key.len, key.index, key.algo);
1345 WL_CONN("key \"%s\"\n", key.data);
1346 swap_key_from_BE(&key);
1347 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY, &key,
1349 if (unlikely(err)) {
1350 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1353 if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
1354 WL_CONN("set auth_type to shared key\n");
1355 val = 1; /* shared key */
1356 err = wl_dev_intvar_set(dev, "auth", val);
1357 if (unlikely(err)) {
1358 WL_ERR("set auth failed (%d)\n", err);
1368 wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
1369 struct cfg80211_connect_params *sme)
1371 struct wl_priv *wl = wiphy_to_wl(wiphy);
1372 struct ieee80211_channel *chan = sme->channel;
1373 struct wl_join_params join_params;
1374 size_t join_params_size;
1378 WL_TRACE("Enter\n");
1381 if (unlikely(!sme->ssid)) {
1382 WL_ERR("Invalid ssid\n");
1386 set_bit(WL_STATUS_CONNECTING, &wl->status);
1390 ieee80211_frequency_to_channel(chan->center_freq);
1391 WL_CONN("channel (%d), center_req (%d)\n",
1392 wl->channel, chan->center_freq);
1396 WL_INFO("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1398 err = wl_set_wpa_version(dev, sme);
1400 WL_ERR("wl_set_wpa_version failed (%d)\n", err);
1404 err = wl_set_auth_type(dev, sme);
1406 WL_ERR("wl_set_auth_type failed (%d)\n", err);
1410 err = wl_set_set_cipher(dev, sme);
1412 WL_ERR("wl_set_set_cipher failed (%d)\n", err);
1416 err = wl_set_key_mgmt(dev, sme);
1418 WL_ERR("wl_set_key_mgmt failed (%d)\n", err);
1422 err = wl_set_set_sharedkey(dev, sme);
1424 WL_ERR("wl_set_set_sharedkey failed (%d)\n", err);
1428 wl_update_prof(wl, NULL, sme->bssid, WL_PROF_BSSID);
1430 ** Join with specific BSSID and cached SSID
1431 ** If SSID is zero join based on BSSID only
1433 memset(&join_params, 0, sizeof(join_params));
1434 join_params_size = sizeof(join_params.ssid);
1436 join_params.ssid.SSID_len = min(sizeof(join_params.ssid.SSID), sme->ssid_len);
1437 memcpy(&join_params.ssid.SSID, sme->ssid, join_params.ssid.SSID_len);
1438 join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1439 wl_update_prof(wl, NULL, &join_params.ssid, WL_PROF_SSID);
1442 memcpy(join_params.params.bssid, sme->bssid, ETH_ALEN);
1444 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1446 if (join_params.ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
1447 WL_CONN("ssid \"%s\", len (%d)\n",
1448 join_params.ssid.SSID, join_params.ssid.SSID_len);
1451 wl_ch_to_chanspec(wl->channel, &join_params, &join_params_size);
1452 err = wl_dev_ioctl(dev, BRCMF_C_SET_SSID,
1453 &join_params, join_params_size);
1455 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1459 clear_bit(WL_STATUS_CONNECTING, &wl->status);
1465 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1468 struct wl_priv *wl = wiphy_to_wl(wiphy);
1472 WL_TRACE("Enter. Reason code = %d\n", reason_code);
1475 clear_bit(WL_STATUS_CONNECTED, &wl->status);
1477 scbval.val = reason_code;
1478 memcpy(&scbval.ea, wl_read_prof(wl, WL_PROF_BSSID), ETH_ALEN);
1479 scbval.val = cpu_to_le32(scbval.val);
1480 err = wl_dev_ioctl(dev, BRCMF_C_DISASSOC, &scbval,
1483 WL_ERR("error (%d)\n", err);
1485 wl->link_up = false;
1492 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
1493 enum nl80211_tx_power_setting type, s32 dbm)
1496 struct wl_priv *wl = wiphy_to_wl(wiphy);
1497 struct net_device *ndev = wl_to_ndev(wl);
1502 WL_TRACE("Enter\n");
1506 case NL80211_TX_POWER_AUTOMATIC:
1508 case NL80211_TX_POWER_LIMITED:
1510 WL_ERR("TX_POWER_LIMITED - dbm is negative\n");
1515 case NL80211_TX_POWER_FIXED:
1517 WL_ERR("TX_POWER_FIXED - dbm is negative\n");
1523 /* Make sure radio is off or on as far as software is concerned */
1524 disable = WL_RADIO_SW_DISABLE << 16;
1525 disable = cpu_to_le32(disable);
1526 err = wl_dev_ioctl(ndev, BRCMF_C_SET_RADIO, &disable, sizeof(disable));
1528 WL_ERR("WLC_SET_RADIO error (%d)\n", err);
1533 txpwrmw = (u16) dbm;
1534 err = wl_dev_intvar_set(ndev, "qtxpower",
1535 (s32) (brcmu_mw_to_qdbm(txpwrmw)));
1537 WL_ERR("qtxpower error (%d)\n", err);
1538 wl->conf->tx_power = dbm;
1545 static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1547 struct wl_priv *wl = wiphy_to_wl(wiphy);
1548 struct net_device *ndev = wl_to_ndev(wl);
1553 WL_TRACE("Enter\n");
1556 err = wl_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1557 if (unlikely(err)) {
1558 WL_ERR("error (%d)\n", err);
1562 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1563 *dbm = (s32) brcmu_qdbm_to_mw(result);
1571 wl_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
1572 u8 key_idx, bool unicast, bool multicast)
1578 WL_TRACE("Enter\n");
1579 WL_CONN("key index (%d)\n", key_idx);
1582 err = wl_dev_ioctl(dev, BRCMF_C_GET_WSEC, &wsec, sizeof(wsec));
1583 if (unlikely(err)) {
1584 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1588 wsec = le32_to_cpu(wsec);
1589 if (wsec & WEP_ENABLED) {
1590 /* Just select a new current key */
1591 index = (u32) key_idx;
1592 index = cpu_to_le32(index);
1593 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY_PRIMARY, &index,
1596 WL_ERR("error (%d)\n", err);
1604 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
1605 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1607 struct wl_wsec_key key;
1610 memset(&key, 0, sizeof(key));
1611 key.index = (u32) key_idx;
1612 /* Instead of bcast for ea address for default wep keys,
1613 driver needs it to be Null */
1614 if (!is_multicast_ether_addr(mac_addr))
1615 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1616 key.len = (u32) params->key_len;
1617 /* check for key index change */
1620 swap_key_from_BE(&key);
1621 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1622 if (unlikely(err)) {
1623 WL_ERR("key delete error (%d)\n", err);
1627 if (key.len > sizeof(key.data)) {
1628 WL_ERR("Invalid key length (%d)\n", key.len);
1632 WL_CONN("Setting the key index %d\n", key.index);
1633 memcpy(key.data, params->key, key.len);
1635 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1637 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1638 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1639 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1642 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1643 if (params->seq && params->seq_len == 6) {
1646 ivptr = (u8 *) params->seq;
1647 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1648 (ivptr[3] << 8) | ivptr[2];
1649 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1650 key.iv_initialized = true;
1653 switch (params->cipher) {
1654 case WLAN_CIPHER_SUITE_WEP40:
1655 key.algo = CRYPTO_ALGO_WEP1;
1656 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1658 case WLAN_CIPHER_SUITE_WEP104:
1659 key.algo = CRYPTO_ALGO_WEP128;
1660 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1662 case WLAN_CIPHER_SUITE_TKIP:
1663 key.algo = CRYPTO_ALGO_TKIP;
1664 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1666 case WLAN_CIPHER_SUITE_AES_CMAC:
1667 key.algo = CRYPTO_ALGO_AES_CCM;
1668 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1670 case WLAN_CIPHER_SUITE_CCMP:
1671 key.algo = CRYPTO_ALGO_AES_CCM;
1672 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1675 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1678 swap_key_from_BE(&key);
1680 dhd_wait_pend8021x(dev);
1681 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1682 if (unlikely(err)) {
1683 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1691 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
1692 u8 key_idx, bool pairwise, const u8 *mac_addr,
1693 struct key_params *params)
1695 struct wl_wsec_key key;
1701 WL_TRACE("Enter\n");
1702 WL_CONN("key index (%d)\n", key_idx);
1707 return wl_add_keyext(wiphy, dev, key_idx, mac_addr, params);
1709 memset(&key, 0, sizeof(key));
1711 key.len = (u32) params->key_len;
1712 key.index = (u32) key_idx;
1714 if (unlikely(key.len > sizeof(key.data))) {
1715 WL_ERR("Too long key length (%u)\n", key.len);
1719 memcpy(key.data, params->key, key.len);
1721 key.flags = WL_PRIMARY_KEY;
1722 switch (params->cipher) {
1723 case WLAN_CIPHER_SUITE_WEP40:
1724 key.algo = CRYPTO_ALGO_WEP1;
1725 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1727 case WLAN_CIPHER_SUITE_WEP104:
1728 key.algo = CRYPTO_ALGO_WEP128;
1729 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1731 case WLAN_CIPHER_SUITE_TKIP:
1732 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1733 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1734 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1735 key.algo = CRYPTO_ALGO_TKIP;
1736 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1738 case WLAN_CIPHER_SUITE_AES_CMAC:
1739 key.algo = CRYPTO_ALGO_AES_CCM;
1740 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1742 case WLAN_CIPHER_SUITE_CCMP:
1743 key.algo = CRYPTO_ALGO_AES_CCM;
1744 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1747 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1752 /* Set the new key/index */
1753 swap_key_from_BE(&key);
1754 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1755 if (unlikely(err)) {
1756 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1761 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1762 if (unlikely(err)) {
1763 WL_ERR("get wsec error (%d)\n", err);
1766 wsec &= ~(WEP_ENABLED);
1768 err = wl_dev_intvar_set(dev, "wsec", wsec);
1769 if (unlikely(err)) {
1770 WL_ERR("set wsec error (%d)\n", err);
1774 val = 1; /* assume shared key. otherwise 0 */
1775 val = cpu_to_le32(val);
1776 err = wl_dev_ioctl(dev, BRCMF_C_SET_AUTH, &val, sizeof(val));
1778 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1785 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
1786 u8 key_idx, bool pairwise, const u8 *mac_addr)
1788 struct wl_wsec_key key;
1793 WL_TRACE("Enter\n");
1795 memset(&key, 0, sizeof(key));
1797 key.index = (u32) key_idx;
1798 key.flags = WL_PRIMARY_KEY;
1799 key.algo = CRYPTO_ALGO_OFF;
1801 WL_CONN("key index (%d)\n", key_idx);
1802 /* Set the new key/index */
1803 swap_key_from_BE(&key);
1804 err = wl_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1805 if (unlikely(err)) {
1806 if (err == -EINVAL) {
1807 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
1808 /* we ignore this key index in this case */
1809 WL_ERR("invalid key index (%d)\n", key_idx);
1811 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1813 /* Ignore this error, may happen during DISASSOC */
1819 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1820 if (unlikely(err)) {
1821 WL_ERR("get wsec error (%d)\n", err);
1822 /* Ignore this error, may happen during DISASSOC */
1826 wsec &= ~(WEP_ENABLED);
1828 err = wl_dev_intvar_set(dev, "wsec", wsec);
1829 if (unlikely(err)) {
1830 WL_ERR("set wsec error (%d)\n", err);
1831 /* Ignore this error, may happen during DISASSOC */
1836 val = 0; /* assume open key. otherwise 1 */
1837 val = cpu_to_le32(val);
1838 err = wl_dev_ioctl(dev, BRCMF_C_SET_AUTH, &val, sizeof(val));
1839 if (unlikely(err)) {
1840 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1841 /* Ignore this error, may happen during DISASSOC */
1850 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
1851 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
1852 void (*callback) (void *cookie, struct key_params * params))
1854 struct key_params params;
1855 struct wl_wsec_key key;
1856 struct wl_priv *wl = wiphy_to_wl(wiphy);
1857 struct wl_security *sec;
1861 WL_TRACE("Enter\n");
1862 WL_CONN("key index (%d)\n", key_idx);
1865 memset(&key, 0, sizeof(key));
1866 key.index = key_idx;
1867 swap_key_to_BE(&key);
1868 memset(¶ms, 0, sizeof(params));
1869 params.key_len = (u8) min_t(u8, WLAN_MAX_KEY_LEN, key.len);
1870 memcpy(params.key, key.data, params.key_len);
1872 err = wl_dev_ioctl(dev, BRCMF_C_GET_WSEC, &wsec, sizeof(wsec));
1873 if (unlikely(err)) {
1874 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1875 /* Ignore this error, may happen during DISASSOC */
1879 wsec = le32_to_cpu(wsec);
1882 sec = wl_read_prof(wl, WL_PROF_SEC);
1883 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1884 params.cipher = WLAN_CIPHER_SUITE_WEP40;
1885 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1886 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1887 params.cipher = WLAN_CIPHER_SUITE_WEP104;
1888 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1892 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1893 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1896 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1897 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1900 WL_ERR("Invalid algo (0x%x)\n", wsec);
1904 callback(cookie, ¶ms);
1912 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1913 struct net_device *dev, u8 key_idx)
1915 WL_INFO("Not supported\n");
1922 wl_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
1923 u8 *mac, struct station_info *sinfo)
1925 struct wl_priv *wl = wiphy_to_wl(wiphy);
1930 u8 *bssid = wl_read_prof(wl, WL_PROF_BSSID);
1932 WL_TRACE("Enter\n");
1936 (memcmp(mac, bssid, ETH_ALEN))) {
1937 WL_ERR("Wrong Mac address cfg_mac-%X:%X:%X:%X:%X:%X"
1938 "wl_bssid-%X:%X:%X:%X:%X:%X\n",
1939 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
1940 bssid[0], bssid[1], bssid[2], bssid[3],
1941 bssid[4], bssid[5]);
1946 /* Report the current tx rate */
1947 err = wl_dev_ioctl(dev, BRCMF_C_GET_RATE, &rate, sizeof(rate));
1949 WL_ERR("Could not get rate (%d)\n", err);
1951 rate = le32_to_cpu(rate);
1952 sinfo->filled |= STATION_INFO_TX_BITRATE;
1953 sinfo->txrate.legacy = rate * 5;
1954 WL_CONN("Rate %d Mbps\n", rate / 2);
1957 if (test_bit(WL_STATUS_CONNECTED, &wl->status)) {
1959 err = wl_dev_ioctl(dev, BRCMF_C_GET_RSSI, &scb_val,
1961 if (unlikely(err)) {
1962 WL_ERR("Could not get rssi (%d)\n", err);
1964 rssi = le32_to_cpu(scb_val.val);
1965 sinfo->filled |= STATION_INFO_SIGNAL;
1966 sinfo->signal = rssi;
1967 WL_CONN("RSSI %d dBm\n", rssi);
1976 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1977 bool enabled, s32 timeout)
1982 WL_TRACE("Enter\n");
1985 pm = enabled ? PM_FAST : PM_OFF;
1986 pm = cpu_to_le32(pm);
1987 WL_INFO("power save %s\n", (pm ? "enabled" : "disabled"));
1989 err = wl_dev_ioctl(dev, BRCMF_C_SET_PM, &pm, sizeof(pm));
1990 if (unlikely(err)) {
1992 WL_ERR("net_device is not ready yet\n");
1994 WL_ERR("error (%d)\n", err);
2000 static __used u32 wl_find_msb(u16 bit16)
2004 if (bit16 & 0xff00) {
2028 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
2030 const struct cfg80211_bitrate_mask *mask)
2032 struct wl_rateset rateset;
2040 WL_TRACE("Enter\n");
2043 /* addr param is always NULL. ignore it */
2044 /* Get current rateset */
2045 err = wl_dev_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
2047 if (unlikely(err)) {
2048 WL_ERR("could not get current rateset (%d)\n", err);
2052 rateset.count = le32_to_cpu(rateset.count);
2054 legacy = wl_find_msb(mask->control[IEEE80211_BAND_2GHZ].legacy);
2056 legacy = wl_find_msb(mask->control[IEEE80211_BAND_5GHZ].legacy);
2058 val = wl_g_rates[legacy - 1].bitrate * 100000;
2060 if (val < rateset.count)
2061 /* Select rate by rateset index */
2062 rate = rateset.rates[val] & 0x7f;
2064 /* Specified rate in bps */
2065 rate = val / 500000;
2067 WL_CONN("rate %d mbps\n", rate / 2);
2071 * Set rate override,
2072 * Since the is a/b/g-blind, both a/bg_rate are enforced.
2074 err_bg = wl_dev_intvar_set(dev, "bg_rate", rate);
2075 err_a = wl_dev_intvar_set(dev, "a_rate", rate);
2076 if (unlikely(err_bg && err_a)) {
2077 WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
2078 err = err_bg | err_a;
2086 static s32 wl_cfg80211_resume(struct wiphy *wiphy)
2088 struct wl_priv *wl = wiphy_to_wl(wiphy);
2089 struct net_device *ndev = wl_to_ndev(wl);
2092 * Check for WL_STATUS_READY before any function call which
2093 * could result is bus access. Don't block the resume for
2094 * any driver error conditions
2096 WL_TRACE("Enter\n");
2098 #if defined(CONFIG_PM_SLEEP)
2099 atomic_set(&dhd_mmc_suspend, false);
2100 #endif /* defined(CONFIG_PM_SLEEP) */
2102 if (test_bit(WL_STATUS_READY, &wl->status)) {
2103 /* Turn on Watchdog timer */
2104 wl_os_wd_timer(ndev, dhd_watchdog_ms);
2105 wl_invoke_iscan(wiphy_to_wl(wiphy));
2112 static s32 wl_cfg80211_suspend(struct wiphy *wiphy, struct cfg80211_wowlan *wow)
2114 struct wl_priv *wl = wiphy_to_wl(wiphy);
2115 struct net_device *ndev = wl_to_ndev(wl);
2117 WL_TRACE("Enter\n");
2120 * Check for WL_STATUS_READY before any function call which
2121 * could result is bus access. Don't block the suspend for
2122 * any driver error conditions
2126 * While going to suspend if associated with AP disassociate
2127 * from AP to save power while system is in suspended state
2129 if ((test_bit(WL_STATUS_CONNECTED, &wl->status) ||
2130 test_bit(WL_STATUS_CONNECTING, &wl->status)) &&
2131 test_bit(WL_STATUS_READY, &wl->status)) {
2132 WL_INFO("Disassociating from AP"
2133 " while entering suspend state\n");
2137 * Make sure WPA_Supplicant receives all the event
2138 * generated due to DISASSOC call to the fw to keep
2139 * the state fw and WPA_Supplicant state consistent
2146 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
2147 if (test_bit(WL_STATUS_READY, &wl->status))
2150 if (wl->scan_request) {
2151 /* Indidate scan abort to cfg80211 layer */
2152 WL_INFO("Terminating scan in progress\n");
2153 cfg80211_scan_done(wl->scan_request, true);
2154 wl->scan_request = NULL;
2156 clear_bit(WL_STATUS_SCANNING, &wl->status);
2157 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
2159 /* Inform SDIO stack not to switch off power to the chip */
2160 brcmf_sdioh_set_host_pm_flags(MMC_PM_KEEP_POWER);
2162 /* Turn off watchdog timer */
2163 if (test_bit(WL_STATUS_READY, &wl->status)) {
2164 WL_INFO("Terminate watchdog timer and enable MPC\n");
2165 wl_set_mpc(ndev, 1);
2166 wl_os_wd_timer(ndev, 0);
2169 #if defined(CONFIG_PM_SLEEP)
2170 atomic_set(&dhd_mmc_suspend, true);
2171 #endif /* defined(CONFIG_PM_SLEEP) */
2179 wl_update_pmklist(struct net_device *dev, struct wl_pmk_list *pmk_list,
2184 WL_CONN("No of elements %d\n", pmk_list->pmkids.npmkid);
2185 for (i = 0; i < pmk_list->pmkids.npmkid; i++) {
2186 WL_CONN("PMKID[%d]: %pM =\n", i,
2187 &pmk_list->pmkids.pmkid[i].BSSID);
2188 for (j = 0; j < WLAN_PMKID_LEN; j++)
2189 WL_CONN("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
2193 wl_dev_bufvar_set(dev, "pmkid_info", (char *)pmk_list,
2200 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
2201 struct cfg80211_pmksa *pmksa)
2203 struct wl_priv *wl = wiphy_to_wl(wiphy);
2207 WL_TRACE("Enter\n");
2210 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2211 if (!memcmp(pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2214 if (i < WL_NUM_PMKIDS_MAX) {
2215 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID, pmksa->bssid,
2217 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID, pmksa->pmkid,
2219 if (i == wl->pmk_list->pmkids.npmkid)
2220 wl->pmk_list->pmkids.npmkid++;
2224 WL_CONN("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
2225 &wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].BSSID);
2226 for (i = 0; i < WLAN_PMKID_LEN; i++)
2228 wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].
2231 err = wl_update_pmklist(dev, wl->pmk_list, err);
2238 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
2239 struct cfg80211_pmksa *pmksa)
2241 struct wl_priv *wl = wiphy_to_wl(wiphy);
2242 struct _pmkid_list pmkid;
2246 WL_TRACE("Enter\n");
2248 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2249 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2251 WL_CONN("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2252 &pmkid.pmkid[0].BSSID);
2253 for (i = 0; i < WLAN_PMKID_LEN; i++)
2254 WL_CONN("%02x\n", pmkid.pmkid[0].PMKID[i]);
2256 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2258 (pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2262 if ((wl->pmk_list->pmkids.npmkid > 0)
2263 && (i < wl->pmk_list->pmkids.npmkid)) {
2264 memset(&wl->pmk_list->pmkids.pmkid[i], 0, sizeof(pmkid_t));
2265 for (; i < (wl->pmk_list->pmkids.npmkid - 1); i++) {
2266 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID,
2267 &wl->pmk_list->pmkids.pmkid[i + 1].BSSID,
2269 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID,
2270 &wl->pmk_list->pmkids.pmkid[i + 1].PMKID,
2273 wl->pmk_list->pmkids.npmkid--;
2277 err = wl_update_pmklist(dev, wl->pmk_list, err);
2285 wl_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *dev)
2287 struct wl_priv *wl = wiphy_to_wl(wiphy);
2290 WL_TRACE("Enter\n");
2293 memset(wl->pmk_list, 0, sizeof(*wl->pmk_list));
2294 err = wl_update_pmklist(dev, wl->pmk_list, err);
2301 static struct cfg80211_ops wl_cfg80211_ops = {
2302 .change_virtual_intf = wl_cfg80211_change_iface,
2303 .scan = wl_cfg80211_scan,
2304 .set_wiphy_params = wl_cfg80211_set_wiphy_params,
2305 .join_ibss = wl_cfg80211_join_ibss,
2306 .leave_ibss = wl_cfg80211_leave_ibss,
2307 .get_station = wl_cfg80211_get_station,
2308 .set_tx_power = wl_cfg80211_set_tx_power,
2309 .get_tx_power = wl_cfg80211_get_tx_power,
2310 .add_key = wl_cfg80211_add_key,
2311 .del_key = wl_cfg80211_del_key,
2312 .get_key = wl_cfg80211_get_key,
2313 .set_default_key = wl_cfg80211_config_default_key,
2314 .set_default_mgmt_key = wl_cfg80211_config_default_mgmt_key,
2315 .set_power_mgmt = wl_cfg80211_set_power_mgmt,
2316 .set_bitrate_mask = wl_cfg80211_set_bitrate_mask,
2317 .connect = wl_cfg80211_connect,
2318 .disconnect = wl_cfg80211_disconnect,
2319 .suspend = wl_cfg80211_suspend,
2320 .resume = wl_cfg80211_resume,
2321 .set_pmksa = wl_cfg80211_set_pmksa,
2322 .del_pmksa = wl_cfg80211_del_pmksa,
2323 .flush_pmksa = wl_cfg80211_flush_pmksa
2326 static s32 wl_mode_to_nl80211_iftype(s32 mode)
2332 return NL80211_IFTYPE_STATION;
2334 return NL80211_IFTYPE_ADHOC;
2336 return NL80211_IFTYPE_UNSPECIFIED;
2342 static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
2345 struct wireless_dev *wdev;
2348 wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2349 if (unlikely(!wdev)) {
2350 WL_ERR("Could not allocate wireless device\n");
2351 return ERR_PTR(-ENOMEM);
2354 wiphy_new(&wl_cfg80211_ops, sizeof(struct wl_priv) + sizeof_iface);
2355 if (unlikely(!wdev->wiphy)) {
2356 WL_ERR("Couldn not allocate wiphy device\n");
2360 set_wiphy_dev(wdev->wiphy, dev);
2361 wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2362 wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2363 wdev->wiphy->interface_modes =
2364 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2365 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2366 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a; /* Set
2367 * it as 11a by default.
2368 * This will be updated with
2371 * if phy has 11n capability
2373 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2374 wdev->wiphy->cipher_suites = __wl_cipher_suites;
2375 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2376 #ifndef WL_POWERSAVE_DISABLED
2377 wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; /* enable power
2382 wdev->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
2383 #endif /* !WL_POWERSAVE_DISABLED */
2384 err = wiphy_register(wdev->wiphy);
2385 if (unlikely(err < 0)) {
2386 WL_ERR("Couldn not register wiphy device (%d)\n", err);
2387 goto wiphy_register_out;
2392 wiphy_free(wdev->wiphy);
2397 return ERR_PTR(err);
2400 static void wl_free_wdev(struct wl_priv *wl)
2402 struct wireless_dev *wdev = wl_to_wdev(wl);
2404 if (unlikely(!wdev)) {
2405 WL_ERR("wdev is invalid\n");
2408 wiphy_unregister(wdev->wiphy);
2409 wiphy_free(wdev->wiphy);
2411 wl_to_wdev(wl) = NULL;
2414 static s32 wl_inform_bss(struct wl_priv *wl)
2416 struct wl_scan_results *bss_list;
2417 struct wl_bss_info *bi = NULL; /* must be initialized */
2421 bss_list = wl->bss_list;
2422 if (unlikely(bss_list->version != WL_BSS_INFO_VERSION)) {
2423 WL_ERR("Version %d != WL_BSS_INFO_VERSION\n",
2427 WL_SCAN("scanned AP count (%d)\n", bss_list->count);
2428 bi = next_bss(bss_list, bi);
2429 for_each_bss(bss_list, bi, i) {
2430 err = wl_inform_single_bss(wl, bi);
2438 static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
2440 struct wiphy *wiphy = wl_to_wiphy(wl);
2441 struct ieee80211_channel *notify_channel;
2442 struct cfg80211_bss *bss;
2443 struct ieee80211_supported_band *band;
2447 u64 notify_timestamp;
2448 u16 notify_capability;
2449 u16 notify_interval;
2451 size_t notify_ielen;
2454 if (unlikely(le32_to_cpu(bi->length) > WL_BSS_INFO_MAX)) {
2455 WL_ERR("Bss info is larger than buffer. Discarding\n");
2459 channel = bi->ctl_ch ? bi->ctl_ch :
2460 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2462 if (channel <= CH_MAX_2G_CHANNEL)
2463 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2465 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2467 freq = ieee80211_channel_to_frequency(channel, band->band);
2468 notify_channel = ieee80211_get_channel(wiphy, freq);
2470 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2471 notify_capability = le16_to_cpu(bi->capability);
2472 notify_interval = le16_to_cpu(bi->beacon_period);
2473 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2474 notify_ielen = le16_to_cpu(bi->ie_length);
2475 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2477 WL_CONN("bssid: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2478 bi->BSSID[0], bi->BSSID[1], bi->BSSID[2],
2479 bi->BSSID[3], bi->BSSID[4], bi->BSSID[5]);
2480 WL_CONN("Channel: %d(%d)\n", channel, freq);
2481 WL_CONN("Capability: %X\n", notify_capability);
2482 WL_CONN("Beacon interval: %d\n", notify_interval);
2483 WL_CONN("Signal: %d\n", notify_signal);
2484 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2486 bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
2487 notify_timestamp, notify_capability, notify_interval, notify_ie,
2488 notify_ielen, notify_signal, GFP_KERNEL);
2490 if (unlikely(!bss)) {
2491 WL_ERR("cfg80211_inform_bss_frame error\n");
2499 wl_inform_ibss(struct wl_priv *wl, struct net_device *dev, const u8 *bssid)
2501 struct wiphy *wiphy = wl_to_wiphy(wl);
2502 struct ieee80211_channel *notify_channel;
2503 struct wl_bss_info *bi = NULL;
2504 struct ieee80211_supported_band *band;
2509 u64 notify_timestamp;
2510 u16 notify_capability;
2511 u16 notify_interval;
2513 size_t notify_ielen;
2516 WL_TRACE("Enter\n");
2518 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2520 WL_ERR("kzalloc() failed\n");
2525 *(u32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2527 err = wl_dev_ioctl(dev, BRCMF_C_GET_BSS_INFO, buf, WL_BSS_INFO_MAX);
2528 if (unlikely(err)) {
2529 WL_ERR("WLC_GET_BSS_INFO failed: %d\n", err);
2533 bi = (wl_bss_info_t *)(buf + 4);
2535 channel = bi->ctl_ch ? bi->ctl_ch :
2536 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2538 if (channel <= CH_MAX_2G_CHANNEL)
2539 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2541 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2543 freq = ieee80211_channel_to_frequency(channel, band->band);
2544 notify_channel = ieee80211_get_channel(wiphy, freq);
2546 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2547 notify_capability = le16_to_cpu(bi->capability);
2548 notify_interval = le16_to_cpu(bi->beacon_period);
2549 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2550 notify_ielen = le16_to_cpu(bi->ie_length);
2551 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2553 WL_CONN("channel: %d(%d)\n", channel, freq);
2554 WL_CONN("capability: %X\n", notify_capability);
2555 WL_CONN("beacon interval: %d\n", notify_interval);
2556 WL_CONN("signal: %d\n", notify_signal);
2557 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2559 cfg80211_inform_bss(wiphy, notify_channel, bssid,
2560 notify_timestamp, notify_capability, notify_interval,
2561 notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
2572 static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e)
2574 u32 event = be32_to_cpu(e->event_type);
2575 u32 status = be32_to_cpu(e->status);
2577 if (event == WLC_E_SET_SSID && status == WLC_E_STATUS_SUCCESS) {
2578 WL_CONN("Processing set ssid\n");
2586 static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e)
2588 u32 event = be32_to_cpu(e->event_type);
2589 u16 flags = be16_to_cpu(e->flags);
2591 if (event == WLC_E_LINK && (!(flags & WLC_EVENT_MSG_LINK))) {
2592 WL_CONN("Processing link down\n");
2598 static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e)
2600 u32 event = be32_to_cpu(e->event_type);
2601 u32 status = be32_to_cpu(e->status);
2603 if (event == WLC_E_LINK && status == WLC_E_STATUS_NO_NETWORKS) {
2604 WL_CONN("Processing Link %s & no network found\n",
2605 be16_to_cpu(e->flags) & WLC_EVENT_MSG_LINK ?
2610 if (event == WLC_E_SET_SSID && status != WLC_E_STATUS_SUCCESS) {
2611 WL_CONN("Processing connecting & no network found\n");
2619 wl_notify_connect_status(struct wl_priv *wl, struct net_device *ndev,
2620 const wl_event_msg_t *e, void *data)
2624 if (wl_is_linkup(wl, e)) {
2625 WL_CONN("Linkup\n");
2626 if (wl_is_ibssmode(wl)) {
2627 wl_update_prof(wl, NULL, (void *)e->addr,
2629 wl_inform_ibss(wl, ndev, e->addr);
2630 cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
2631 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2632 set_bit(WL_STATUS_CONNECTED, &wl->status);
2634 wl_bss_connect_done(wl, ndev, e, data, true);
2635 } else if (wl_is_linkdown(wl, e)) {
2636 WL_CONN("Linkdown\n");
2637 if (wl_is_ibssmode(wl)) {
2638 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2639 if (test_and_clear_bit(WL_STATUS_CONNECTED,
2643 wl_bss_connect_done(wl, ndev, e, data, false);
2644 if (test_and_clear_bit(WL_STATUS_CONNECTED,
2646 cfg80211_disconnected(ndev, 0, NULL, 0,
2651 wl_init_prof(wl->profile);
2652 } else if (wl_is_nonetwork(wl, e)) {
2653 if (wl_is_ibssmode(wl))
2654 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2656 wl_bss_connect_done(wl, ndev, e, data, false);
2663 wl_notify_roaming_status(struct wl_priv *wl, struct net_device *ndev,
2664 const wl_event_msg_t *e, void *data)
2667 u32 event = be32_to_cpu(e->event_type);
2668 u32 status = be32_to_cpu(e->status);
2670 if (event == WLC_E_ROAM && status == WLC_E_STATUS_SUCCESS) {
2671 if (test_bit(WL_STATUS_CONNECTED, &wl->status))
2672 wl_bss_roaming_done(wl, ndev, e, data);
2674 wl_bss_connect_done(wl, ndev, e, data, true);
2681 wl_dev_bufvar_set(struct net_device *dev, s8 *name, s8 *buf, s32 len)
2683 struct wl_priv *wl = ndev_to_wl(dev);
2686 buflen = brcmu_mkiovar(name, buf, len, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2689 return wl_dev_ioctl(dev, BRCMF_C_SET_VAR, wl->ioctl_buf, buflen);
2693 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
2696 struct wl_priv *wl = ndev_to_wl(dev);
2700 len = brcmu_mkiovar(name, NULL, 0, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2702 err = wl_dev_ioctl(dev, BRCMF_C_GET_VAR, (void *)wl->ioctl_buf,
2704 if (unlikely(err)) {
2705 WL_ERR("error (%d)\n", err);
2708 memcpy(buf, wl->ioctl_buf, buf_len);
2713 static s32 wl_get_assoc_ies(struct wl_priv *wl)
2715 struct net_device *ndev = wl_to_ndev(wl);
2716 struct wl_assoc_ielen *assoc_info;
2717 struct wl_connect_info *conn_info = wl_to_conn(wl);
2722 wl_clear_assoc_ies(wl);
2724 err = wl_dev_bufvar_get(ndev, "assoc_info", wl->extra_buf,
2726 if (unlikely(err)) {
2727 WL_ERR("could not get assoc info (%d)\n", err);
2730 assoc_info = (struct wl_assoc_ielen *)wl->extra_buf;
2731 req_len = assoc_info->req_len;
2732 resp_len = assoc_info->resp_len;
2734 err = wl_dev_bufvar_get(ndev, "assoc_req_ies", wl->extra_buf,
2736 if (unlikely(err)) {
2737 WL_ERR("could not get assoc req (%d)\n", err);
2740 conn_info->req_ie_len = req_len;
2742 kmemdup(wl->extra_buf, conn_info->req_ie_len, GFP_KERNEL);
2744 conn_info->req_ie_len = 0;
2745 conn_info->req_ie = NULL;
2748 err = wl_dev_bufvar_get(ndev, "assoc_resp_ies", wl->extra_buf,
2750 if (unlikely(err)) {
2751 WL_ERR("could not get assoc resp (%d)\n", err);
2754 conn_info->resp_ie_len = resp_len;
2755 conn_info->resp_ie =
2756 kmemdup(wl->extra_buf, conn_info->resp_ie_len, GFP_KERNEL);
2758 conn_info->resp_ie_len = 0;
2759 conn_info->resp_ie = NULL;
2761 WL_CONN("req len (%d) resp len (%d)\n",
2762 conn_info->req_ie_len, conn_info->resp_ie_len);
2767 static void wl_clear_assoc_ies(struct wl_priv *wl)
2769 struct wl_connect_info *conn_info = wl_to_conn(wl);
2771 kfree(conn_info->req_ie);
2772 conn_info->req_ie = NULL;
2773 conn_info->req_ie_len = 0;
2774 kfree(conn_info->resp_ie);
2775 conn_info->resp_ie = NULL;
2776 conn_info->resp_ie_len = 0;
2780 static void wl_ch_to_chanspec(int ch, struct wl_join_params *join_params,
2781 size_t *join_params_size)
2783 chanspec_t chanspec = 0;
2786 join_params->params.chanspec_num = 1;
2787 join_params->params.chanspec_list[0] = ch;
2789 if (join_params->params.chanspec_list[0] <= CH_MAX_2G_CHANNEL)
2790 chanspec |= WL_CHANSPEC_BAND_2G;
2792 chanspec |= WL_CHANSPEC_BAND_5G;
2794 chanspec |= WL_CHANSPEC_BW_20;
2795 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
2797 *join_params_size += WL_ASSOC_PARAMS_FIXED_SIZE +
2798 join_params->params.chanspec_num * sizeof(chanspec_t);
2800 join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
2801 join_params->params.chanspec_list[0] |= chanspec;
2802 join_params->params.chanspec_list[0] =
2803 cpu_to_le16(join_params->params.chanspec_list[0]);
2805 join_params->params.chanspec_num =
2806 cpu_to_le32(join_params->params.chanspec_num);
2808 WL_CONN("join_params->params.chanspec_list[0]= %#X,"
2809 "channel %d, chanspec %#X\n",
2810 join_params->params.chanspec_list[0], ch, chanspec);
2814 static s32 wl_update_bss_info(struct wl_priv *wl)
2816 struct wl_bss_info *bi;
2817 struct wlc_ssid *ssid;
2818 struct brcmu_tlv *tim;
2819 u16 beacon_interval;
2825 WL_TRACE("Enter\n");
2826 if (wl_is_ibssmode(wl))
2829 ssid = (struct wlc_ssid *)wl_read_prof(wl, WL_PROF_SSID);
2831 *(u32 *)wl->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2832 err = wl_dev_ioctl(wl_to_ndev(wl), BRCMF_C_GET_BSS_INFO,
2833 wl->extra_buf, WL_EXTRA_BUF_MAX);
2834 if (unlikely(err)) {
2835 WL_ERR("Could not get bss info %d\n", err);
2836 goto update_bss_info_out;
2839 bi = (struct wl_bss_info *)(wl->extra_buf + 4);
2840 err = wl_inform_single_bss(wl, bi);
2842 goto update_bss_info_out;
2844 ie = ((u8 *)bi) + bi->ie_offset;
2845 ie_len = bi->ie_length;
2846 beacon_interval = cpu_to_le16(bi->beacon_period);
2848 tim = brcmu_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2850 dtim_period = tim->data[1];
2853 * active scan was done so we could not get dtim
2854 * information out of probe response.
2855 * so we speficially query dtim information to dongle.
2858 err = wl_dev_intvar_get(wl_to_ndev(wl), "dtim_assoc", &var);
2859 if (unlikely(err)) {
2860 WL_ERR("wl dtim_assoc failed (%d)\n", err);
2861 goto update_bss_info_out;
2863 dtim_period = (u8)var;
2866 wl_update_prof(wl, NULL, &beacon_interval, WL_PROF_BEACONINT);
2867 wl_update_prof(wl, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
2869 update_bss_info_out:
2875 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
2876 const wl_event_msg_t *e, void *data)
2878 struct wl_connect_info *conn_info = wl_to_conn(wl);
2881 WL_TRACE("Enter\n");
2883 wl_get_assoc_ies(wl);
2884 wl_update_prof(wl, NULL, &e->addr, WL_PROF_BSSID);
2885 wl_update_bss_info(wl);
2887 cfg80211_roamed(ndev, NULL,
2888 (u8 *)wl_read_prof(wl, WL_PROF_BSSID),
2889 conn_info->req_ie, conn_info->req_ie_len,
2890 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
2891 WL_CONN("Report roaming result\n");
2893 set_bit(WL_STATUS_CONNECTED, &wl->status);
2899 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
2900 const wl_event_msg_t *e, void *data, bool completed)
2902 struct wl_connect_info *conn_info = wl_to_conn(wl);
2905 WL_TRACE("Enter\n");
2907 if (test_and_clear_bit(WL_STATUS_CONNECTING, &wl->status)) {
2909 wl_get_assoc_ies(wl);
2910 wl_update_prof(wl, NULL, &e->addr, WL_PROF_BSSID);
2911 wl_update_bss_info(wl);
2913 cfg80211_connect_result(ndev,
2914 (u8 *)wl_read_prof(wl, WL_PROF_BSSID),
2916 conn_info->req_ie_len,
2918 conn_info->resp_ie_len,
2919 completed ? WLAN_STATUS_SUCCESS : WLAN_STATUS_AUTH_TIMEOUT,
2922 set_bit(WL_STATUS_CONNECTED, &wl->status);
2923 WL_CONN("Report connect result - connection %s\n",
2924 completed ? "succeeded" : "failed");
2931 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
2932 const wl_event_msg_t *e, void *data)
2934 u16 flags = be16_to_cpu(e->flags);
2935 enum nl80211_key_type key_type;
2938 if (flags & WLC_EVENT_MSG_GROUP)
2939 key_type = NL80211_KEYTYPE_GROUP;
2941 key_type = NL80211_KEYTYPE_PAIRWISE;
2943 cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
2951 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
2952 const wl_event_msg_t *e, void *data)
2954 struct channel_info channel_inform;
2955 struct wl_scan_results *bss_list;
2956 u32 len = WL_SCAN_BUF_MAX;
2958 bool scan_abort = false;
2960 WL_TRACE("Enter\n");
2962 if (wl->iscan_on && wl->iscan_kickstart) {
2964 return wl_wakeup_iscan(wl_to_iscan(wl));
2967 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
2968 WL_ERR("Scan complete while device not scanning\n");
2974 err = wl_dev_ioctl(ndev, BRCMF_C_GET_CHANNEL, &channel_inform,
2975 sizeof(channel_inform));
2976 if (unlikely(err)) {
2977 WL_ERR("scan busy (%d)\n", err);
2981 channel_inform.scan_channel = le32_to_cpu(channel_inform.scan_channel);
2982 if (unlikely(channel_inform.scan_channel)) {
2984 WL_CONN("channel_inform.scan_channel (%d)\n",
2985 channel_inform.scan_channel);
2987 wl->bss_list = wl->scan_results;
2988 bss_list = wl->bss_list;
2989 memset(bss_list, 0, len);
2990 bss_list->buflen = cpu_to_le32(len);
2992 err = wl_dev_ioctl(ndev, BRCMF_C_SCAN_RESULTS, bss_list, len);
2993 if (unlikely(err)) {
2994 WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
2999 bss_list->buflen = le32_to_cpu(bss_list->buflen);
3000 bss_list->version = le32_to_cpu(bss_list->version);
3001 bss_list->count = le32_to_cpu(bss_list->count);
3003 err = wl_inform_bss(wl);
3010 if (wl->scan_request) {
3011 WL_SCAN("calling cfg80211_scan_done\n");
3012 cfg80211_scan_done(wl->scan_request, scan_abort);
3013 wl_set_mpc(ndev, 1);
3014 wl->scan_request = NULL;
3022 static void wl_init_conf(struct wl_conf *conf)
3024 conf->mode = (u32)-1;
3025 conf->frag_threshold = (u32)-1;
3026 conf->rts_threshold = (u32)-1;
3027 conf->retry_short = (u32)-1;
3028 conf->retry_long = (u32)-1;
3029 conf->tx_power = -1;
3032 static void wl_init_prof(struct wl_profile *prof)
3034 memset(prof, 0, sizeof(*prof));
3037 static void wl_init_eloop_handler(struct wl_event_loop *el)
3039 memset(el, 0, sizeof(*el));
3040 el->handler[WLC_E_SCAN_COMPLETE] = wl_notify_scan_status;
3041 el->handler[WLC_E_LINK] = wl_notify_connect_status;
3042 el->handler[WLC_E_ROAM] = wl_notify_roaming_status;
3043 el->handler[WLC_E_MIC_ERROR] = wl_notify_mic_status;
3044 el->handler[WLC_E_SET_SSID] = wl_notify_connect_status;
3047 static s32 wl_init_priv_mem(struct wl_priv *wl)
3049 wl->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
3050 if (unlikely(!wl->scan_results)) {
3051 WL_ERR("Scan results alloc failed\n");
3052 goto init_priv_mem_out;
3054 wl->conf = kzalloc(sizeof(*wl->conf), GFP_KERNEL);
3055 if (unlikely(!wl->conf)) {
3056 WL_ERR("wl_conf alloc failed\n");
3057 goto init_priv_mem_out;
3059 wl->profile = kzalloc(sizeof(*wl->profile), GFP_KERNEL);
3060 if (unlikely(!wl->profile)) {
3061 WL_ERR("wl_profile alloc failed\n");
3062 goto init_priv_mem_out;
3064 wl->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
3065 if (unlikely(!wl->bss_info)) {
3066 WL_ERR("Bss information alloc failed\n");
3067 goto init_priv_mem_out;
3069 wl->scan_req_int = kzalloc(sizeof(*wl->scan_req_int), GFP_KERNEL);
3070 if (unlikely(!wl->scan_req_int)) {
3071 WL_ERR("Scan req alloc failed\n");
3072 goto init_priv_mem_out;
3074 wl->ioctl_buf = kzalloc(WL_IOCTL_LEN_MAX, GFP_KERNEL);
3075 if (unlikely(!wl->ioctl_buf)) {
3076 WL_ERR("Ioctl buf alloc failed\n");
3077 goto init_priv_mem_out;
3079 wl->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3080 if (unlikely(!wl->extra_buf)) {
3081 WL_ERR("Extra buf alloc failed\n");
3082 goto init_priv_mem_out;
3084 wl->iscan = kzalloc(sizeof(*wl->iscan), GFP_KERNEL);
3085 if (unlikely(!wl->iscan)) {
3086 WL_ERR("Iscan buf alloc failed\n");
3087 goto init_priv_mem_out;
3089 wl->fw = kzalloc(sizeof(*wl->fw), GFP_KERNEL);
3090 if (unlikely(!wl->fw)) {
3091 WL_ERR("fw object alloc failed\n");
3092 goto init_priv_mem_out;
3094 wl->pmk_list = kzalloc(sizeof(*wl->pmk_list), GFP_KERNEL);
3095 if (unlikely(!wl->pmk_list)) {
3096 WL_ERR("pmk list alloc failed\n");
3097 goto init_priv_mem_out;
3103 wl_deinit_priv_mem(wl);
3108 static void wl_deinit_priv_mem(struct wl_priv *wl)
3110 kfree(wl->scan_results);
3111 wl->scan_results = NULL;
3112 kfree(wl->bss_info);
3113 wl->bss_info = NULL;
3118 kfree(wl->scan_req_int);
3119 wl->scan_req_int = NULL;
3120 kfree(wl->ioctl_buf);
3121 wl->ioctl_buf = NULL;
3122 kfree(wl->extra_buf);
3123 wl->extra_buf = NULL;
3128 kfree(wl->pmk_list);
3129 wl->pmk_list = NULL;
3132 static s32 wl_create_event_handler(struct wl_priv *wl)
3134 sema_init(&wl->event_sync, 0);
3135 wl->event_tsk = kthread_run(wl_event_handler, wl, "wl_event_handler");
3136 if (IS_ERR(wl->event_tsk)) {
3137 wl->event_tsk = NULL;
3138 WL_ERR("failed to create event thread\n");
3144 static void wl_destroy_event_handler(struct wl_priv *wl)
3146 if (wl->event_tsk) {
3147 send_sig(SIGTERM, wl->event_tsk, 1);
3148 kthread_stop(wl->event_tsk);
3149 wl->event_tsk = NULL;
3153 static void wl_term_iscan(struct wl_priv *wl)
3155 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3157 if (wl->iscan_on && iscan->tsk) {
3158 iscan->state = WL_ISCAN_STATE_IDLE;
3159 send_sig(SIGTERM, iscan->tsk, 1);
3160 kthread_stop(iscan->tsk);
3165 static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted)
3167 struct wl_priv *wl = iscan_to_wl(iscan);
3168 struct net_device *ndev = wl_to_ndev(wl);
3170 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
3171 WL_ERR("Scan complete while device not scanning\n");
3174 if (likely(wl->scan_request)) {
3175 WL_SCAN("ISCAN Completed scan: %s\n",
3176 aborted ? "Aborted" : "Done");
3177 cfg80211_scan_done(wl->scan_request, aborted);
3178 wl_set_mpc(ndev, 1);
3179 wl->scan_request = NULL;
3181 wl->iscan_kickstart = false;
3184 static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan)
3186 if (likely(iscan->state != WL_ISCAN_STATE_IDLE)) {
3187 WL_SCAN("wake up iscan\n");
3196 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
3197 struct wl_scan_results **bss_list)
3199 struct wl_iscan_results list;
3200 struct wl_scan_results *results;
3201 struct wl_iscan_results *list_buf;
3204 memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
3205 list_buf = (struct wl_iscan_results *)iscan->scan_buf;
3206 results = &list_buf->results;
3207 results->buflen = WL_ISCAN_RESULTS_FIXED_SIZE;
3208 results->version = 0;
3211 memset(&list, 0, sizeof(list));
3212 list.results.buflen = cpu_to_le32(WL_ISCAN_BUF_MAX);
3213 err = wl_dev_iovar_getbuf(iscan->dev, "iscanresults", &list,
3214 WL_ISCAN_RESULTS_FIXED_SIZE, iscan->scan_buf,
3216 if (unlikely(err)) {
3217 WL_ERR("error (%d)\n", err);
3220 results->buflen = le32_to_cpu(results->buflen);
3221 results->version = le32_to_cpu(results->version);
3222 results->count = le32_to_cpu(results->count);
3223 WL_SCAN("results->count = %d\n", results->count);
3224 WL_SCAN("results->buflen = %d\n", results->buflen);
3225 *status = le32_to_cpu(list_buf->status);
3226 *bss_list = results;
3231 static s32 wl_iscan_done(struct wl_priv *wl)
3233 struct wl_iscan_ctrl *iscan = wl->iscan;
3236 iscan->state = WL_ISCAN_STATE_IDLE;
3239 wl_notify_iscan_complete(iscan, false);
3245 static s32 wl_iscan_pending(struct wl_priv *wl)
3247 struct wl_iscan_ctrl *iscan = wl->iscan;
3250 /* Reschedule the timer */
3251 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3252 iscan->timer_on = 1;
3257 static s32 wl_iscan_inprogress(struct wl_priv *wl)
3259 struct wl_iscan_ctrl *iscan = wl->iscan;
3264 wl_run_iscan(iscan, NULL, WL_SCAN_ACTION_CONTINUE);
3266 /* Reschedule the timer */
3267 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3268 iscan->timer_on = 1;
3273 static s32 wl_iscan_aborted(struct wl_priv *wl)
3275 struct wl_iscan_ctrl *iscan = wl->iscan;
3278 iscan->state = WL_ISCAN_STATE_IDLE;
3280 wl_notify_iscan_complete(iscan, true);
3286 static s32 wl_iscan_thread(void *data)
3288 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3289 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
3290 struct wl_priv *wl = iscan_to_wl(iscan);
3291 struct wl_iscan_eloop *el = &iscan->el;
3295 sched_setscheduler(current, SCHED_FIFO, ¶m);
3296 allow_signal(SIGTERM);
3297 status = WL_SCAN_RESULTS_PARTIAL;
3298 while (likely(!down_interruptible(&iscan->sync))) {
3299 if (kthread_should_stop())
3301 if (iscan->timer_on) {
3302 del_timer_sync(&iscan->timer);
3303 iscan->timer_on = 0;
3306 err = wl_get_iscan_results(iscan, &status, &wl->bss_list);
3307 if (unlikely(err)) {
3308 status = WL_SCAN_RESULTS_ABORTED;
3309 WL_ERR("Abort iscan\n");
3312 el->handler[status] (wl);
3314 if (iscan->timer_on) {
3315 del_timer_sync(&iscan->timer);
3316 iscan->timer_on = 0;
3318 WL_SCAN("ISCAN thread terminated\n");
3323 static void wl_iscan_timer(unsigned long data)
3325 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
3328 iscan->timer_on = 0;
3329 WL_SCAN("timer expired\n");
3330 wl_wakeup_iscan(iscan);
3334 static s32 wl_invoke_iscan(struct wl_priv *wl)
3336 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3339 if (wl->iscan_on && !iscan->tsk) {
3340 iscan->state = WL_ISCAN_STATE_IDLE;
3341 sema_init(&iscan->sync, 0);
3342 iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
3343 if (IS_ERR(iscan->tsk)) {
3344 WL_ERR("Could not create iscan thread\n");
3353 static void wl_init_iscan_eloop(struct wl_iscan_eloop *el)
3355 memset(el, 0, sizeof(*el));
3356 el->handler[WL_SCAN_RESULTS_SUCCESS] = wl_iscan_done;
3357 el->handler[WL_SCAN_RESULTS_PARTIAL] = wl_iscan_inprogress;
3358 el->handler[WL_SCAN_RESULTS_PENDING] = wl_iscan_pending;
3359 el->handler[WL_SCAN_RESULTS_ABORTED] = wl_iscan_aborted;
3360 el->handler[WL_SCAN_RESULTS_NO_MEM] = wl_iscan_aborted;
3363 static s32 wl_init_iscan(struct wl_priv *wl)
3365 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3369 iscan->dev = wl_to_ndev(wl);
3370 iscan->state = WL_ISCAN_STATE_IDLE;
3371 wl_init_iscan_eloop(&iscan->el);
3372 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
3373 init_timer(&iscan->timer);
3374 iscan->timer.data = (unsigned long) iscan;
3375 iscan->timer.function = wl_iscan_timer;
3376 sema_init(&iscan->sync, 0);
3377 iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
3378 if (IS_ERR(iscan->tsk)) {
3379 WL_ERR("Could not create iscan thread\n");
3389 static void wl_init_fw(struct wl_fw_ctrl *fw)
3391 fw->status = 0; /* init fw loading status.
3392 0 means nothing was loaded yet */
3395 static s32 wl_init_priv(struct wl_priv *wl)
3397 struct wiphy *wiphy = wl_to_wiphy(wl);
3400 wl->scan_request = NULL;
3401 wl->pwr_save = !!(wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT);
3402 wl->iscan_on = true; /* iscan on & off switch.
3403 we enable iscan per default */
3404 wl->roam_on = false; /* roam on & off switch.
3405 we enable roam per default */
3407 wl->iscan_kickstart = false;
3408 wl->active_scan = true; /* we do active scan for
3409 specific scan per default */
3410 wl->dongle_up = false; /* dongle is not up yet */
3412 err = wl_init_priv_mem(wl);
3415 if (unlikely(wl_create_event_handler(wl)))
3417 wl_init_eloop_handler(&wl->el);
3418 mutex_init(&wl->usr_sync);
3419 err = wl_init_iscan(wl);
3423 wl_init_conf(wl->conf);
3424 wl_init_prof(wl->profile);
3430 static void wl_deinit_priv(struct wl_priv *wl)
3432 wl_destroy_event_handler(wl);
3433 wl->dongle_up = false; /* dongle down */
3437 wl_deinit_priv_mem(wl);
3440 s32 wl_cfg80211_attach(struct net_device *ndev, void *data)
3442 struct wireless_dev *wdev;
3444 struct wl_iface *ci;
3447 if (unlikely(!ndev)) {
3448 WL_ERR("ndev is invalid\n");
3451 wl_cfg80211_dev = kzalloc(sizeof(struct wl_dev), GFP_KERNEL);
3452 if (unlikely(!wl_cfg80211_dev)) {
3453 WL_ERR("wl_cfg80211_dev is invalid\n");
3456 WL_INFO("func %p\n", wl_cfg80211_get_sdio_func());
3457 wdev = wl_alloc_wdev(sizeof(struct wl_iface), &wl_cfg80211_get_sdio_func()->dev);
3461 wdev->iftype = wl_mode_to_nl80211_iftype(WL_MODE_BSS);
3462 wl = wdev_to_wl(wdev);
3465 ci = (struct wl_iface *)wl_to_ci(wl);
3467 ndev->ieee80211_ptr = wdev;
3468 SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
3469 wdev->netdev = ndev;
3470 err = wl_init_priv(wl);
3471 if (unlikely(err)) {
3472 WL_ERR("Failed to init iwm_priv (%d)\n", err);
3473 goto cfg80211_attach_out;
3475 wl_set_drvdata(wl_cfg80211_dev, ci);
3479 cfg80211_attach_out:
3484 void wl_cfg80211_detach(void)
3492 wl_set_drvdata(wl_cfg80211_dev, NULL);
3493 kfree(wl_cfg80211_dev);
3494 wl_cfg80211_dev = NULL;
3495 wl_clear_sdio_func();
3498 static void wl_wakeup_event(struct wl_priv *wl)
3500 up(&wl->event_sync);
3503 static s32 wl_event_handler(void *data)
3505 struct wl_priv *wl = (struct wl_priv *)data;
3506 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3507 struct wl_event_q *e;
3509 sched_setscheduler(current, SCHED_FIFO, ¶m);
3510 allow_signal(SIGTERM);
3511 while (likely(!down_interruptible(&wl->event_sync))) {
3512 if (kthread_should_stop())
3514 e = wl_deq_event(wl);
3516 WL_ERR("event queue empty...\n");
3519 WL_INFO("event type (%d)\n", e->etype);
3520 if (wl->el.handler[e->etype]) {
3521 wl->el.handler[e->etype] (wl, wl_to_ndev(wl), &e->emsg,
3524 WL_INFO("Unknown Event (%d): ignoring\n", e->etype);
3528 WL_INFO("was terminated\n");
3533 wl_cfg80211_event(struct net_device *ndev, const wl_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 wl_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(wl_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, WLC_E_SET_SSID);
3886 setbit(eventmask, WLC_E_ROAM);
3887 setbit(eventmask, WLC_E_PRUNE);
3888 setbit(eventmask, WLC_E_AUTH);
3889 setbit(eventmask, WLC_E_REASSOC);
3890 setbit(eventmask, WLC_E_REASSOC_IND);
3891 setbit(eventmask, WLC_E_DEAUTH_IND);
3892 setbit(eventmask, WLC_E_DISASSOC_IND);
3893 setbit(eventmask, WLC_E_DISASSOC);
3894 setbit(eventmask, WLC_E_JOIN);
3895 setbit(eventmask, WLC_E_ASSOC_IND);
3896 setbit(eventmask, WLC_E_PSK_SUP);
3897 setbit(eventmask, WLC_E_LINK);
3898 setbit(eventmask, WLC_E_NDIS_LINK);
3899 setbit(eventmask, WLC_E_MIC_ERROR);
3900 setbit(eventmask, WLC_E_PMKID_CACHE);
3901 setbit(eventmask, WLC_E_TXFAIL);
3902 setbit(eventmask, WLC_E_JOIN_START);
3903 setbit(eventmask, WLC_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 wl_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;