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, WLC_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, WLC_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, WLC_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 >= WLC_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, WLC_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), WLC_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, WLC_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, WLC_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[WLC_IOCTL_SMLEN];
842 val = cpu_to_le32(val);
843 len = brcmu_mkiovar(name, (char *)(&val), sizeof(val), buf,
847 err = wl_dev_ioctl(dev, WLC_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[WLC_IOCTL_SMLEN];
866 brcmu_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
869 err = wl_dev_ioctl(dev, WLC_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, WLC_SET_SSID, &join_params, join_params_size);
1088 if (unlikely(err)) {
1089 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1095 clear_bit(WL_STATUS_CONNECTING, &wl->status);
1100 static s32 wl_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1102 struct wl_priv *wl = wiphy_to_wl(wiphy);
1105 WL_TRACE("Enter\n");
1116 wl_set_wpa_version(struct net_device *dev, struct cfg80211_connect_params *sme)
1118 struct wl_priv *wl = ndev_to_wl(dev);
1119 struct wl_security *sec;
1123 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1124 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1125 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1126 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1128 val = WPA_AUTH_DISABLED;
1129 WL_CONN("setting wpa_auth to 0x%0x\n", val);
1130 err = wl_dev_intvar_set(dev, "wpa_auth", val);
1131 if (unlikely(err)) {
1132 WL_ERR("set wpa_auth failed (%d)\n", err);
1135 sec = wl_read_prof(wl, WL_PROF_SEC);
1136 sec->wpa_versions = sme->crypto.wpa_versions;
1141 wl_set_auth_type(struct net_device *dev, struct cfg80211_connect_params *sme)
1143 struct wl_priv *wl = ndev_to_wl(dev);
1144 struct wl_security *sec;
1148 switch (sme->auth_type) {
1149 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1151 WL_CONN("open system\n");
1153 case NL80211_AUTHTYPE_SHARED_KEY:
1155 WL_CONN("shared key\n");
1157 case NL80211_AUTHTYPE_AUTOMATIC:
1159 WL_CONN("automatic\n");
1161 case NL80211_AUTHTYPE_NETWORK_EAP:
1162 WL_CONN("network eap\n");
1165 WL_ERR("invalid auth type (%d)\n", sme->auth_type);
1169 err = wl_dev_intvar_set(dev, "auth", val);
1170 if (unlikely(err)) {
1171 WL_ERR("set auth failed (%d)\n", err);
1174 sec = wl_read_prof(wl, WL_PROF_SEC);
1175 sec->auth_type = sme->auth_type;
1180 wl_set_set_cipher(struct net_device *dev, struct cfg80211_connect_params *sme)
1182 struct wl_priv *wl = ndev_to_wl(dev);
1183 struct wl_security *sec;
1188 if (sme->crypto.n_ciphers_pairwise) {
1189 switch (sme->crypto.ciphers_pairwise[0]) {
1190 case WLAN_CIPHER_SUITE_WEP40:
1191 case WLAN_CIPHER_SUITE_WEP104:
1194 case WLAN_CIPHER_SUITE_TKIP:
1195 pval = TKIP_ENABLED;
1197 case WLAN_CIPHER_SUITE_CCMP:
1200 case WLAN_CIPHER_SUITE_AES_CMAC:
1204 WL_ERR("invalid cipher pairwise (%d)\n",
1205 sme->crypto.ciphers_pairwise[0]);
1209 if (sme->crypto.cipher_group) {
1210 switch (sme->crypto.cipher_group) {
1211 case WLAN_CIPHER_SUITE_WEP40:
1212 case WLAN_CIPHER_SUITE_WEP104:
1215 case WLAN_CIPHER_SUITE_TKIP:
1216 gval = TKIP_ENABLED;
1218 case WLAN_CIPHER_SUITE_CCMP:
1221 case WLAN_CIPHER_SUITE_AES_CMAC:
1225 WL_ERR("invalid cipher group (%d)\n",
1226 sme->crypto.cipher_group);
1231 WL_CONN("pval (%d) gval (%d)\n", pval, gval);
1232 err = wl_dev_intvar_set(dev, "wsec", pval | gval);
1233 if (unlikely(err)) {
1234 WL_ERR("error (%d)\n", err);
1238 sec = wl_read_prof(wl, WL_PROF_SEC);
1239 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1240 sec->cipher_group = sme->crypto.cipher_group;
1246 wl_set_key_mgmt(struct net_device *dev, struct cfg80211_connect_params *sme)
1248 struct wl_priv *wl = ndev_to_wl(dev);
1249 struct wl_security *sec;
1253 if (sme->crypto.n_akm_suites) {
1254 err = wl_dev_intvar_get(dev, "wpa_auth", &val);
1255 if (unlikely(err)) {
1256 WL_ERR("could not get wpa_auth (%d)\n", err);
1259 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1260 switch (sme->crypto.akm_suites[0]) {
1261 case WLAN_AKM_SUITE_8021X:
1262 val = WPA_AUTH_UNSPECIFIED;
1264 case WLAN_AKM_SUITE_PSK:
1268 WL_ERR("invalid cipher group (%d)\n",
1269 sme->crypto.cipher_group);
1272 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1273 switch (sme->crypto.akm_suites[0]) {
1274 case WLAN_AKM_SUITE_8021X:
1275 val = WPA2_AUTH_UNSPECIFIED;
1277 case WLAN_AKM_SUITE_PSK:
1278 val = WPA2_AUTH_PSK;
1281 WL_ERR("invalid cipher group (%d)\n",
1282 sme->crypto.cipher_group);
1287 WL_CONN("setting wpa_auth to %d\n", val);
1288 err = wl_dev_intvar_set(dev, "wpa_auth", val);
1289 if (unlikely(err)) {
1290 WL_ERR("could not set wpa_auth (%d)\n", err);
1294 sec = wl_read_prof(wl, WL_PROF_SEC);
1295 sec->wpa_auth = sme->crypto.akm_suites[0];
1301 wl_set_set_sharedkey(struct net_device *dev,
1302 struct cfg80211_connect_params *sme)
1304 struct wl_priv *wl = ndev_to_wl(dev);
1305 struct wl_security *sec;
1306 struct wl_wsec_key key;
1310 WL_CONN("key len (%d)\n", sme->key_len);
1312 sec = wl_read_prof(wl, WL_PROF_SEC);
1313 WL_CONN("wpa_versions 0x%x cipher_pairwise 0x%x\n",
1314 sec->wpa_versions, sec->cipher_pairwise);
1316 (sec->wpa_versions & (NL80211_WPA_VERSION_1 |
1317 NL80211_WPA_VERSION_2))
1318 && (sec->cipher_pairwise & (WLAN_CIPHER_SUITE_WEP40 |
1319 WLAN_CIPHER_SUITE_WEP104))) {
1320 memset(&key, 0, sizeof(key));
1321 key.len = (u32) sme->key_len;
1322 key.index = (u32) sme->key_idx;
1323 if (unlikely(key.len > sizeof(key.data))) {
1324 WL_ERR("Too long key length (%u)\n", key.len);
1327 memcpy(key.data, sme->key, key.len);
1328 key.flags = WL_PRIMARY_KEY;
1329 switch (sec->cipher_pairwise) {
1330 case WLAN_CIPHER_SUITE_WEP40:
1331 key.algo = CRYPTO_ALGO_WEP1;
1333 case WLAN_CIPHER_SUITE_WEP104:
1334 key.algo = CRYPTO_ALGO_WEP128;
1337 WL_ERR("Invalid algorithm (%d)\n",
1338 sme->crypto.ciphers_pairwise[0]);
1341 /* Set the new key/index */
1342 WL_CONN("key length (%d) key index (%d) algo (%d)\n",
1343 key.len, key.index, key.algo);
1344 WL_CONN("key \"%s\"\n", key.data);
1345 swap_key_from_BE(&key);
1346 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key,
1348 if (unlikely(err)) {
1349 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1352 if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
1353 WL_CONN("set auth_type to shared key\n");
1354 val = 1; /* shared key */
1355 err = wl_dev_intvar_set(dev, "auth", val);
1356 if (unlikely(err)) {
1357 WL_ERR("set auth failed (%d)\n", err);
1367 wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
1368 struct cfg80211_connect_params *sme)
1370 struct wl_priv *wl = wiphy_to_wl(wiphy);
1371 struct ieee80211_channel *chan = sme->channel;
1372 struct wl_join_params join_params;
1373 size_t join_params_size;
1377 WL_TRACE("Enter\n");
1380 if (unlikely(!sme->ssid)) {
1381 WL_ERR("Invalid ssid\n");
1385 set_bit(WL_STATUS_CONNECTING, &wl->status);
1389 ieee80211_frequency_to_channel(chan->center_freq);
1390 WL_CONN("channel (%d), center_req (%d)\n",
1391 wl->channel, chan->center_freq);
1395 WL_INFO("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1397 err = wl_set_wpa_version(dev, sme);
1399 WL_ERR("wl_set_wpa_version failed (%d)\n", err);
1403 err = wl_set_auth_type(dev, sme);
1405 WL_ERR("wl_set_auth_type failed (%d)\n", err);
1409 err = wl_set_set_cipher(dev, sme);
1411 WL_ERR("wl_set_set_cipher failed (%d)\n", err);
1415 err = wl_set_key_mgmt(dev, sme);
1417 WL_ERR("wl_set_key_mgmt failed (%d)\n", err);
1421 err = wl_set_set_sharedkey(dev, sme);
1423 WL_ERR("wl_set_set_sharedkey failed (%d)\n", err);
1427 wl_update_prof(wl, NULL, sme->bssid, WL_PROF_BSSID);
1429 ** Join with specific BSSID and cached SSID
1430 ** If SSID is zero join based on BSSID only
1432 memset(&join_params, 0, sizeof(join_params));
1433 join_params_size = sizeof(join_params.ssid);
1435 join_params.ssid.SSID_len = min(sizeof(join_params.ssid.SSID), sme->ssid_len);
1436 memcpy(&join_params.ssid.SSID, sme->ssid, join_params.ssid.SSID_len);
1437 join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1438 wl_update_prof(wl, NULL, &join_params.ssid, WL_PROF_SSID);
1441 memcpy(join_params.params.bssid, sme->bssid, ETH_ALEN);
1443 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1445 if (join_params.ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
1446 WL_CONN("ssid \"%s\", len (%d)\n",
1447 join_params.ssid.SSID, join_params.ssid.SSID_len);
1450 wl_ch_to_chanspec(wl->channel, &join_params, &join_params_size);
1451 err = wl_dev_ioctl(dev, WLC_SET_SSID, &join_params, join_params_size);
1453 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1457 clear_bit(WL_STATUS_CONNECTING, &wl->status);
1463 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1466 struct wl_priv *wl = wiphy_to_wl(wiphy);
1470 WL_TRACE("Enter. Reason code = %d\n", reason_code);
1473 clear_bit(WL_STATUS_CONNECTED, &wl->status);
1475 scbval.val = reason_code;
1476 memcpy(&scbval.ea, wl_read_prof(wl, WL_PROF_BSSID), ETH_ALEN);
1477 scbval.val = cpu_to_le32(scbval.val);
1478 err = wl_dev_ioctl(dev, WLC_DISASSOC, &scbval,
1481 WL_ERR("error (%d)\n", err);
1483 wl->link_up = false;
1490 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
1491 enum nl80211_tx_power_setting type, s32 dbm)
1494 struct wl_priv *wl = wiphy_to_wl(wiphy);
1495 struct net_device *ndev = wl_to_ndev(wl);
1500 WL_TRACE("Enter\n");
1504 case NL80211_TX_POWER_AUTOMATIC:
1506 case NL80211_TX_POWER_LIMITED:
1508 WL_ERR("TX_POWER_LIMITED - dbm is negative\n");
1513 case NL80211_TX_POWER_FIXED:
1515 WL_ERR("TX_POWER_FIXED - dbm is negative\n");
1521 /* Make sure radio is off or on as far as software is concerned */
1522 disable = WL_RADIO_SW_DISABLE << 16;
1523 disable = cpu_to_le32(disable);
1524 err = wl_dev_ioctl(ndev, WLC_SET_RADIO, &disable, sizeof(disable));
1526 WL_ERR("WLC_SET_RADIO error (%d)\n", err);
1531 txpwrmw = (u16) dbm;
1532 err = wl_dev_intvar_set(ndev, "qtxpower",
1533 (s32) (brcmu_mw_to_qdbm(txpwrmw)));
1535 WL_ERR("qtxpower error (%d)\n", err);
1536 wl->conf->tx_power = dbm;
1543 static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1545 struct wl_priv *wl = wiphy_to_wl(wiphy);
1546 struct net_device *ndev = wl_to_ndev(wl);
1551 WL_TRACE("Enter\n");
1554 err = wl_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1555 if (unlikely(err)) {
1556 WL_ERR("error (%d)\n", err);
1560 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1561 *dbm = (s32) brcmu_qdbm_to_mw(result);
1569 wl_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
1570 u8 key_idx, bool unicast, bool multicast)
1576 WL_TRACE("Enter\n");
1577 WL_CONN("key index (%d)\n", key_idx);
1580 err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
1581 if (unlikely(err)) {
1582 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1586 wsec = le32_to_cpu(wsec);
1587 if (wsec & WEP_ENABLED) {
1588 /* Just select a new current key */
1589 index = (u32) key_idx;
1590 index = cpu_to_le32(index);
1591 err = wl_dev_ioctl(dev, WLC_SET_KEY_PRIMARY, &index,
1594 WL_ERR("error (%d)\n", err);
1602 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
1603 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1605 struct wl_wsec_key key;
1608 memset(&key, 0, sizeof(key));
1609 key.index = (u32) key_idx;
1610 /* Instead of bcast for ea address for default wep keys,
1611 driver needs it to be Null */
1612 if (!is_multicast_ether_addr(mac_addr))
1613 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1614 key.len = (u32) params->key_len;
1615 /* check for key index change */
1618 swap_key_from_BE(&key);
1619 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1620 if (unlikely(err)) {
1621 WL_ERR("key delete error (%d)\n", err);
1625 if (key.len > sizeof(key.data)) {
1626 WL_ERR("Invalid key length (%d)\n", key.len);
1630 WL_CONN("Setting the key index %d\n", key.index);
1631 memcpy(key.data, params->key, key.len);
1633 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1635 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1636 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1637 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1640 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1641 if (params->seq && params->seq_len == 6) {
1644 ivptr = (u8 *) params->seq;
1645 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1646 (ivptr[3] << 8) | ivptr[2];
1647 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1648 key.iv_initialized = true;
1651 switch (params->cipher) {
1652 case WLAN_CIPHER_SUITE_WEP40:
1653 key.algo = CRYPTO_ALGO_WEP1;
1654 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1656 case WLAN_CIPHER_SUITE_WEP104:
1657 key.algo = CRYPTO_ALGO_WEP128;
1658 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1660 case WLAN_CIPHER_SUITE_TKIP:
1661 key.algo = CRYPTO_ALGO_TKIP;
1662 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1664 case WLAN_CIPHER_SUITE_AES_CMAC:
1665 key.algo = CRYPTO_ALGO_AES_CCM;
1666 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1668 case WLAN_CIPHER_SUITE_CCMP:
1669 key.algo = CRYPTO_ALGO_AES_CCM;
1670 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1673 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1676 swap_key_from_BE(&key);
1678 dhd_wait_pend8021x(dev);
1679 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1680 if (unlikely(err)) {
1681 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1689 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
1690 u8 key_idx, bool pairwise, const u8 *mac_addr,
1691 struct key_params *params)
1693 struct wl_wsec_key key;
1699 WL_TRACE("Enter\n");
1700 WL_CONN("key index (%d)\n", key_idx);
1705 return wl_add_keyext(wiphy, dev, key_idx, mac_addr, params);
1707 memset(&key, 0, sizeof(key));
1709 key.len = (u32) params->key_len;
1710 key.index = (u32) key_idx;
1712 if (unlikely(key.len > sizeof(key.data))) {
1713 WL_ERR("Too long key length (%u)\n", key.len);
1717 memcpy(key.data, params->key, key.len);
1719 key.flags = WL_PRIMARY_KEY;
1720 switch (params->cipher) {
1721 case WLAN_CIPHER_SUITE_WEP40:
1722 key.algo = CRYPTO_ALGO_WEP1;
1723 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1725 case WLAN_CIPHER_SUITE_WEP104:
1726 key.algo = CRYPTO_ALGO_WEP128;
1727 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1729 case WLAN_CIPHER_SUITE_TKIP:
1730 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1731 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1732 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1733 key.algo = CRYPTO_ALGO_TKIP;
1734 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1736 case WLAN_CIPHER_SUITE_AES_CMAC:
1737 key.algo = CRYPTO_ALGO_AES_CCM;
1738 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1740 case WLAN_CIPHER_SUITE_CCMP:
1741 key.algo = CRYPTO_ALGO_AES_CCM;
1742 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1745 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1750 /* Set the new key/index */
1751 swap_key_from_BE(&key);
1752 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1753 if (unlikely(err)) {
1754 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1759 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1760 if (unlikely(err)) {
1761 WL_ERR("get wsec error (%d)\n", err);
1764 wsec &= ~(WEP_ENABLED);
1766 err = wl_dev_intvar_set(dev, "wsec", wsec);
1767 if (unlikely(err)) {
1768 WL_ERR("set wsec error (%d)\n", err);
1772 val = 1; /* assume shared key. otherwise 0 */
1773 val = cpu_to_le32(val);
1774 err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
1776 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1783 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
1784 u8 key_idx, bool pairwise, const u8 *mac_addr)
1786 struct wl_wsec_key key;
1791 WL_TRACE("Enter\n");
1793 memset(&key, 0, sizeof(key));
1795 key.index = (u32) key_idx;
1796 key.flags = WL_PRIMARY_KEY;
1797 key.algo = CRYPTO_ALGO_OFF;
1799 WL_CONN("key index (%d)\n", key_idx);
1800 /* Set the new key/index */
1801 swap_key_from_BE(&key);
1802 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1803 if (unlikely(err)) {
1804 if (err == -EINVAL) {
1805 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
1806 /* we ignore this key index in this case */
1807 WL_ERR("invalid key index (%d)\n", key_idx);
1809 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1811 /* Ignore this error, may happen during DISASSOC */
1817 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1818 if (unlikely(err)) {
1819 WL_ERR("get wsec error (%d)\n", err);
1820 /* Ignore this error, may happen during DISASSOC */
1824 wsec &= ~(WEP_ENABLED);
1826 err = wl_dev_intvar_set(dev, "wsec", wsec);
1827 if (unlikely(err)) {
1828 WL_ERR("set wsec error (%d)\n", err);
1829 /* Ignore this error, may happen during DISASSOC */
1834 val = 0; /* assume open key. otherwise 1 */
1835 val = cpu_to_le32(val);
1836 err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
1837 if (unlikely(err)) {
1838 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1839 /* Ignore this error, may happen during DISASSOC */
1848 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
1849 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
1850 void (*callback) (void *cookie, struct key_params * params))
1852 struct key_params params;
1853 struct wl_wsec_key key;
1854 struct wl_priv *wl = wiphy_to_wl(wiphy);
1855 struct wl_security *sec;
1859 WL_TRACE("Enter\n");
1860 WL_CONN("key index (%d)\n", key_idx);
1863 memset(&key, 0, sizeof(key));
1864 key.index = key_idx;
1865 swap_key_to_BE(&key);
1866 memset(¶ms, 0, sizeof(params));
1867 params.key_len = (u8) min_t(u8, WLAN_MAX_KEY_LEN, key.len);
1868 memcpy(params.key, key.data, params.key_len);
1870 err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
1871 if (unlikely(err)) {
1872 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1873 /* Ignore this error, may happen during DISASSOC */
1877 wsec = le32_to_cpu(wsec);
1880 sec = wl_read_prof(wl, WL_PROF_SEC);
1881 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1882 params.cipher = WLAN_CIPHER_SUITE_WEP40;
1883 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1884 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1885 params.cipher = WLAN_CIPHER_SUITE_WEP104;
1886 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1890 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1891 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1894 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1895 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1898 WL_ERR("Invalid algo (0x%x)\n", wsec);
1902 callback(cookie, ¶ms);
1910 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1911 struct net_device *dev, u8 key_idx)
1913 WL_INFO("Not supported\n");
1920 wl_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
1921 u8 *mac, struct station_info *sinfo)
1923 struct wl_priv *wl = wiphy_to_wl(wiphy);
1928 u8 *bssid = wl_read_prof(wl, WL_PROF_BSSID);
1930 WL_TRACE("Enter\n");
1934 (memcmp(mac, bssid, ETH_ALEN))) {
1935 WL_ERR("Wrong Mac address cfg_mac-%X:%X:%X:%X:%X:%X"
1936 "wl_bssid-%X:%X:%X:%X:%X:%X\n",
1937 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
1938 bssid[0], bssid[1], bssid[2], bssid[3],
1939 bssid[4], bssid[5]);
1944 /* Report the current tx rate */
1945 err = wl_dev_ioctl(dev, WLC_GET_RATE, &rate, sizeof(rate));
1947 WL_ERR("Could not get rate (%d)\n", err);
1949 rate = le32_to_cpu(rate);
1950 sinfo->filled |= STATION_INFO_TX_BITRATE;
1951 sinfo->txrate.legacy = rate * 5;
1952 WL_CONN("Rate %d Mbps\n", rate / 2);
1955 if (test_bit(WL_STATUS_CONNECTED, &wl->status)) {
1957 err = wl_dev_ioctl(dev, WLC_GET_RSSI, &scb_val,
1959 if (unlikely(err)) {
1960 WL_ERR("Could not get rssi (%d)\n", err);
1962 rssi = le32_to_cpu(scb_val.val);
1963 sinfo->filled |= STATION_INFO_SIGNAL;
1964 sinfo->signal = rssi;
1965 WL_CONN("RSSI %d dBm\n", rssi);
1974 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1975 bool enabled, s32 timeout)
1980 WL_TRACE("Enter\n");
1983 pm = enabled ? PM_FAST : PM_OFF;
1984 pm = cpu_to_le32(pm);
1985 WL_INFO("power save %s\n", (pm ? "enabled" : "disabled"));
1987 err = wl_dev_ioctl(dev, WLC_SET_PM, &pm, sizeof(pm));
1988 if (unlikely(err)) {
1990 WL_ERR("net_device is not ready yet\n");
1992 WL_ERR("error (%d)\n", err);
1998 static __used u32 wl_find_msb(u16 bit16)
2002 if (bit16 & 0xff00) {
2026 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
2028 const struct cfg80211_bitrate_mask *mask)
2030 struct wl_rateset rateset;
2038 WL_TRACE("Enter\n");
2041 /* addr param is always NULL. ignore it */
2042 /* Get current rateset */
2043 err = wl_dev_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
2045 if (unlikely(err)) {
2046 WL_ERR("could not get current rateset (%d)\n", err);
2050 rateset.count = le32_to_cpu(rateset.count);
2052 legacy = wl_find_msb(mask->control[IEEE80211_BAND_2GHZ].legacy);
2054 legacy = wl_find_msb(mask->control[IEEE80211_BAND_5GHZ].legacy);
2056 val = wl_g_rates[legacy - 1].bitrate * 100000;
2058 if (val < rateset.count)
2059 /* Select rate by rateset index */
2060 rate = rateset.rates[val] & 0x7f;
2062 /* Specified rate in bps */
2063 rate = val / 500000;
2065 WL_CONN("rate %d mbps\n", rate / 2);
2069 * Set rate override,
2070 * Since the is a/b/g-blind, both a/bg_rate are enforced.
2072 err_bg = wl_dev_intvar_set(dev, "bg_rate", rate);
2073 err_a = wl_dev_intvar_set(dev, "a_rate", rate);
2074 if (unlikely(err_bg && err_a)) {
2075 WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
2076 err = err_bg | err_a;
2084 static s32 wl_cfg80211_resume(struct wiphy *wiphy)
2086 struct wl_priv *wl = wiphy_to_wl(wiphy);
2087 struct net_device *ndev = wl_to_ndev(wl);
2090 * Check for WL_STATUS_READY before any function call which
2091 * could result is bus access. Don't block the resume for
2092 * any driver error conditions
2094 WL_TRACE("Enter\n");
2096 #if defined(CONFIG_PM_SLEEP)
2097 atomic_set(&dhd_mmc_suspend, false);
2098 #endif /* defined(CONFIG_PM_SLEEP) */
2100 if (test_bit(WL_STATUS_READY, &wl->status)) {
2101 /* Turn on Watchdog timer */
2102 wl_os_wd_timer(ndev, dhd_watchdog_ms);
2103 wl_invoke_iscan(wiphy_to_wl(wiphy));
2110 static s32 wl_cfg80211_suspend(struct wiphy *wiphy, struct cfg80211_wowlan *wow)
2112 struct wl_priv *wl = wiphy_to_wl(wiphy);
2113 struct net_device *ndev = wl_to_ndev(wl);
2115 WL_TRACE("Enter\n");
2118 * Check for WL_STATUS_READY before any function call which
2119 * could result is bus access. Don't block the suspend for
2120 * any driver error conditions
2124 * While going to suspend if associated with AP disassociate
2125 * from AP to save power while system is in suspended state
2127 if ((test_bit(WL_STATUS_CONNECTED, &wl->status) ||
2128 test_bit(WL_STATUS_CONNECTING, &wl->status)) &&
2129 test_bit(WL_STATUS_READY, &wl->status)) {
2130 WL_INFO("Disassociating from AP"
2131 " while entering suspend state\n");
2135 * Make sure WPA_Supplicant receives all the event
2136 * generated due to DISASSOC call to the fw to keep
2137 * the state fw and WPA_Supplicant state consistent
2144 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
2145 if (test_bit(WL_STATUS_READY, &wl->status))
2148 if (wl->scan_request) {
2149 /* Indidate scan abort to cfg80211 layer */
2150 WL_INFO("Terminating scan in progress\n");
2151 cfg80211_scan_done(wl->scan_request, true);
2152 wl->scan_request = NULL;
2154 clear_bit(WL_STATUS_SCANNING, &wl->status);
2155 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
2157 /* Inform SDIO stack not to switch off power to the chip */
2158 brcmf_sdioh_set_host_pm_flags(MMC_PM_KEEP_POWER);
2160 /* Turn off watchdog timer */
2161 if (test_bit(WL_STATUS_READY, &wl->status)) {
2162 WL_INFO("Terminate watchdog timer and enable MPC\n");
2163 wl_set_mpc(ndev, 1);
2164 wl_os_wd_timer(ndev, 0);
2167 #if defined(CONFIG_PM_SLEEP)
2168 atomic_set(&dhd_mmc_suspend, true);
2169 #endif /* defined(CONFIG_PM_SLEEP) */
2177 wl_update_pmklist(struct net_device *dev, struct wl_pmk_list *pmk_list,
2182 WL_CONN("No of elements %d\n", pmk_list->pmkids.npmkid);
2183 for (i = 0; i < pmk_list->pmkids.npmkid; i++) {
2184 WL_CONN("PMKID[%d]: %pM =\n", i,
2185 &pmk_list->pmkids.pmkid[i].BSSID);
2186 for (j = 0; j < WLAN_PMKID_LEN; j++)
2187 WL_CONN("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
2191 wl_dev_bufvar_set(dev, "pmkid_info", (char *)pmk_list,
2198 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
2199 struct cfg80211_pmksa *pmksa)
2201 struct wl_priv *wl = wiphy_to_wl(wiphy);
2205 WL_TRACE("Enter\n");
2208 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2209 if (!memcmp(pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2212 if (i < WL_NUM_PMKIDS_MAX) {
2213 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID, pmksa->bssid,
2215 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID, pmksa->pmkid,
2217 if (i == wl->pmk_list->pmkids.npmkid)
2218 wl->pmk_list->pmkids.npmkid++;
2222 WL_CONN("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
2223 &wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].BSSID);
2224 for (i = 0; i < WLAN_PMKID_LEN; i++)
2226 wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].
2229 err = wl_update_pmklist(dev, wl->pmk_list, err);
2236 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
2237 struct cfg80211_pmksa *pmksa)
2239 struct wl_priv *wl = wiphy_to_wl(wiphy);
2240 struct _pmkid_list pmkid;
2244 WL_TRACE("Enter\n");
2246 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2247 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2249 WL_CONN("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2250 &pmkid.pmkid[0].BSSID);
2251 for (i = 0; i < WLAN_PMKID_LEN; i++)
2252 WL_CONN("%02x\n", pmkid.pmkid[0].PMKID[i]);
2254 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2256 (pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2260 if ((wl->pmk_list->pmkids.npmkid > 0)
2261 && (i < wl->pmk_list->pmkids.npmkid)) {
2262 memset(&wl->pmk_list->pmkids.pmkid[i], 0, sizeof(pmkid_t));
2263 for (; i < (wl->pmk_list->pmkids.npmkid - 1); i++) {
2264 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID,
2265 &wl->pmk_list->pmkids.pmkid[i + 1].BSSID,
2267 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID,
2268 &wl->pmk_list->pmkids.pmkid[i + 1].PMKID,
2271 wl->pmk_list->pmkids.npmkid--;
2275 err = wl_update_pmklist(dev, wl->pmk_list, err);
2283 wl_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *dev)
2285 struct wl_priv *wl = wiphy_to_wl(wiphy);
2288 WL_TRACE("Enter\n");
2291 memset(wl->pmk_list, 0, sizeof(*wl->pmk_list));
2292 err = wl_update_pmklist(dev, wl->pmk_list, err);
2299 static struct cfg80211_ops wl_cfg80211_ops = {
2300 .change_virtual_intf = wl_cfg80211_change_iface,
2301 .scan = wl_cfg80211_scan,
2302 .set_wiphy_params = wl_cfg80211_set_wiphy_params,
2303 .join_ibss = wl_cfg80211_join_ibss,
2304 .leave_ibss = wl_cfg80211_leave_ibss,
2305 .get_station = wl_cfg80211_get_station,
2306 .set_tx_power = wl_cfg80211_set_tx_power,
2307 .get_tx_power = wl_cfg80211_get_tx_power,
2308 .add_key = wl_cfg80211_add_key,
2309 .del_key = wl_cfg80211_del_key,
2310 .get_key = wl_cfg80211_get_key,
2311 .set_default_key = wl_cfg80211_config_default_key,
2312 .set_default_mgmt_key = wl_cfg80211_config_default_mgmt_key,
2313 .set_power_mgmt = wl_cfg80211_set_power_mgmt,
2314 .set_bitrate_mask = wl_cfg80211_set_bitrate_mask,
2315 .connect = wl_cfg80211_connect,
2316 .disconnect = wl_cfg80211_disconnect,
2317 .suspend = wl_cfg80211_suspend,
2318 .resume = wl_cfg80211_resume,
2319 .set_pmksa = wl_cfg80211_set_pmksa,
2320 .del_pmksa = wl_cfg80211_del_pmksa,
2321 .flush_pmksa = wl_cfg80211_flush_pmksa
2324 static s32 wl_mode_to_nl80211_iftype(s32 mode)
2330 return NL80211_IFTYPE_STATION;
2332 return NL80211_IFTYPE_ADHOC;
2334 return NL80211_IFTYPE_UNSPECIFIED;
2340 static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
2343 struct wireless_dev *wdev;
2346 wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2347 if (unlikely(!wdev)) {
2348 WL_ERR("Could not allocate wireless device\n");
2349 return ERR_PTR(-ENOMEM);
2352 wiphy_new(&wl_cfg80211_ops, sizeof(struct wl_priv) + sizeof_iface);
2353 if (unlikely(!wdev->wiphy)) {
2354 WL_ERR("Couldn not allocate wiphy device\n");
2358 set_wiphy_dev(wdev->wiphy, dev);
2359 wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2360 wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2361 wdev->wiphy->interface_modes =
2362 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2363 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2364 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a; /* Set
2365 * it as 11a by default.
2366 * This will be updated with
2369 * if phy has 11n capability
2371 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2372 wdev->wiphy->cipher_suites = __wl_cipher_suites;
2373 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2374 #ifndef WL_POWERSAVE_DISABLED
2375 wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; /* enable power
2380 wdev->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
2381 #endif /* !WL_POWERSAVE_DISABLED */
2382 err = wiphy_register(wdev->wiphy);
2383 if (unlikely(err < 0)) {
2384 WL_ERR("Couldn not register wiphy device (%d)\n", err);
2385 goto wiphy_register_out;
2390 wiphy_free(wdev->wiphy);
2395 return ERR_PTR(err);
2398 static void wl_free_wdev(struct wl_priv *wl)
2400 struct wireless_dev *wdev = wl_to_wdev(wl);
2402 if (unlikely(!wdev)) {
2403 WL_ERR("wdev is invalid\n");
2406 wiphy_unregister(wdev->wiphy);
2407 wiphy_free(wdev->wiphy);
2409 wl_to_wdev(wl) = NULL;
2412 static s32 wl_inform_bss(struct wl_priv *wl)
2414 struct wl_scan_results *bss_list;
2415 struct wl_bss_info *bi = NULL; /* must be initialized */
2419 bss_list = wl->bss_list;
2420 if (unlikely(bss_list->version != WL_BSS_INFO_VERSION)) {
2421 WL_ERR("Version %d != WL_BSS_INFO_VERSION\n",
2425 WL_SCAN("scanned AP count (%d)\n", bss_list->count);
2426 bi = next_bss(bss_list, bi);
2427 for_each_bss(bss_list, bi, i) {
2428 err = wl_inform_single_bss(wl, bi);
2436 static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
2438 struct wiphy *wiphy = wl_to_wiphy(wl);
2439 struct ieee80211_channel *notify_channel;
2440 struct cfg80211_bss *bss;
2441 struct ieee80211_supported_band *band;
2445 u64 notify_timestamp;
2446 u16 notify_capability;
2447 u16 notify_interval;
2449 size_t notify_ielen;
2452 if (unlikely(le32_to_cpu(bi->length) > WL_BSS_INFO_MAX)) {
2453 WL_ERR("Bss info is larger than buffer. Discarding\n");
2457 channel = bi->ctl_ch ? bi->ctl_ch :
2458 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2460 if (channel <= CH_MAX_2G_CHANNEL)
2461 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2463 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2465 freq = ieee80211_channel_to_frequency(channel, band->band);
2466 notify_channel = ieee80211_get_channel(wiphy, freq);
2468 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2469 notify_capability = le16_to_cpu(bi->capability);
2470 notify_interval = le16_to_cpu(bi->beacon_period);
2471 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2472 notify_ielen = le16_to_cpu(bi->ie_length);
2473 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2475 WL_CONN("bssid: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2476 bi->BSSID[0], bi->BSSID[1], bi->BSSID[2],
2477 bi->BSSID[3], bi->BSSID[4], bi->BSSID[5]);
2478 WL_CONN("Channel: %d(%d)\n", channel, freq);
2479 WL_CONN("Capability: %X\n", notify_capability);
2480 WL_CONN("Beacon interval: %d\n", notify_interval);
2481 WL_CONN("Signal: %d\n", notify_signal);
2482 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2484 bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
2485 notify_timestamp, notify_capability, notify_interval, notify_ie,
2486 notify_ielen, notify_signal, GFP_KERNEL);
2488 if (unlikely(!bss)) {
2489 WL_ERR("cfg80211_inform_bss_frame error\n");
2497 wl_inform_ibss(struct wl_priv *wl, struct net_device *dev, const u8 *bssid)
2499 struct wiphy *wiphy = wl_to_wiphy(wl);
2500 struct ieee80211_channel *notify_channel;
2501 struct wl_bss_info *bi = NULL;
2502 struct ieee80211_supported_band *band;
2507 u64 notify_timestamp;
2508 u16 notify_capability;
2509 u16 notify_interval;
2511 size_t notify_ielen;
2514 WL_TRACE("Enter\n");
2516 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2518 WL_ERR("kzalloc() failed\n");
2523 *(u32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2525 err = wl_dev_ioctl(dev, WLC_GET_BSS_INFO, buf, WL_BSS_INFO_MAX);
2526 if (unlikely(err)) {
2527 WL_ERR("WLC_GET_BSS_INFO failed: %d\n", err);
2531 bi = (wl_bss_info_t *)(buf + 4);
2533 channel = bi->ctl_ch ? bi->ctl_ch :
2534 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2536 if (channel <= CH_MAX_2G_CHANNEL)
2537 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2539 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2541 freq = ieee80211_channel_to_frequency(channel, band->band);
2542 notify_channel = ieee80211_get_channel(wiphy, freq);
2544 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2545 notify_capability = le16_to_cpu(bi->capability);
2546 notify_interval = le16_to_cpu(bi->beacon_period);
2547 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2548 notify_ielen = le16_to_cpu(bi->ie_length);
2549 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2551 WL_CONN("channel: %d(%d)\n", channel, freq);
2552 WL_CONN("capability: %X\n", notify_capability);
2553 WL_CONN("beacon interval: %d\n", notify_interval);
2554 WL_CONN("signal: %d\n", notify_signal);
2555 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2557 cfg80211_inform_bss(wiphy, notify_channel, bssid,
2558 notify_timestamp, notify_capability, notify_interval,
2559 notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
2570 static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e)
2572 u32 event = be32_to_cpu(e->event_type);
2573 u32 status = be32_to_cpu(e->status);
2575 if (event == WLC_E_SET_SSID && status == WLC_E_STATUS_SUCCESS) {
2576 WL_CONN("Processing set ssid\n");
2584 static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e)
2586 u32 event = be32_to_cpu(e->event_type);
2587 u16 flags = be16_to_cpu(e->flags);
2589 if (event == WLC_E_LINK && (!(flags & WLC_EVENT_MSG_LINK))) {
2590 WL_CONN("Processing link down\n");
2596 static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e)
2598 u32 event = be32_to_cpu(e->event_type);
2599 u32 status = be32_to_cpu(e->status);
2601 if (event == WLC_E_LINK && status == WLC_E_STATUS_NO_NETWORKS) {
2602 WL_CONN("Processing Link %s & no network found\n",
2603 be16_to_cpu(e->flags) & WLC_EVENT_MSG_LINK ?
2608 if (event == WLC_E_SET_SSID && status != WLC_E_STATUS_SUCCESS) {
2609 WL_CONN("Processing connecting & no network found\n");
2617 wl_notify_connect_status(struct wl_priv *wl, struct net_device *ndev,
2618 const wl_event_msg_t *e, void *data)
2622 if (wl_is_linkup(wl, e)) {
2623 WL_CONN("Linkup\n");
2624 if (wl_is_ibssmode(wl)) {
2625 wl_update_prof(wl, NULL, (void *)e->addr,
2627 wl_inform_ibss(wl, ndev, e->addr);
2628 cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
2629 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2630 set_bit(WL_STATUS_CONNECTED, &wl->status);
2632 wl_bss_connect_done(wl, ndev, e, data, true);
2633 } else if (wl_is_linkdown(wl, e)) {
2634 WL_CONN("Linkdown\n");
2635 if (wl_is_ibssmode(wl)) {
2636 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2637 if (test_and_clear_bit(WL_STATUS_CONNECTED,
2641 wl_bss_connect_done(wl, ndev, e, data, false);
2642 if (test_and_clear_bit(WL_STATUS_CONNECTED,
2644 cfg80211_disconnected(ndev, 0, NULL, 0,
2649 wl_init_prof(wl->profile);
2650 } else if (wl_is_nonetwork(wl, e)) {
2651 if (wl_is_ibssmode(wl))
2652 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2654 wl_bss_connect_done(wl, ndev, e, data, false);
2661 wl_notify_roaming_status(struct wl_priv *wl, struct net_device *ndev,
2662 const wl_event_msg_t *e, void *data)
2665 u32 event = be32_to_cpu(e->event_type);
2666 u32 status = be32_to_cpu(e->status);
2668 if (event == WLC_E_ROAM && status == WLC_E_STATUS_SUCCESS) {
2669 if (test_bit(WL_STATUS_CONNECTED, &wl->status))
2670 wl_bss_roaming_done(wl, ndev, e, data);
2672 wl_bss_connect_done(wl, ndev, e, data, true);
2679 wl_dev_bufvar_set(struct net_device *dev, s8 *name, s8 *buf, s32 len)
2681 struct wl_priv *wl = ndev_to_wl(dev);
2684 buflen = brcmu_mkiovar(name, buf, len, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2687 return wl_dev_ioctl(dev, WLC_SET_VAR, wl->ioctl_buf, buflen);
2691 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
2694 struct wl_priv *wl = ndev_to_wl(dev);
2698 len = brcmu_mkiovar(name, NULL, 0, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2700 err = wl_dev_ioctl(dev, WLC_GET_VAR, (void *)wl->ioctl_buf,
2702 if (unlikely(err)) {
2703 WL_ERR("error (%d)\n", err);
2706 memcpy(buf, wl->ioctl_buf, buf_len);
2711 static s32 wl_get_assoc_ies(struct wl_priv *wl)
2713 struct net_device *ndev = wl_to_ndev(wl);
2714 struct wl_assoc_ielen *assoc_info;
2715 struct wl_connect_info *conn_info = wl_to_conn(wl);
2720 wl_clear_assoc_ies(wl);
2722 err = wl_dev_bufvar_get(ndev, "assoc_info", wl->extra_buf,
2724 if (unlikely(err)) {
2725 WL_ERR("could not get assoc info (%d)\n", err);
2728 assoc_info = (struct wl_assoc_ielen *)wl->extra_buf;
2729 req_len = assoc_info->req_len;
2730 resp_len = assoc_info->resp_len;
2732 err = wl_dev_bufvar_get(ndev, "assoc_req_ies", wl->extra_buf,
2734 if (unlikely(err)) {
2735 WL_ERR("could not get assoc req (%d)\n", err);
2738 conn_info->req_ie_len = req_len;
2740 kmemdup(wl->extra_buf, conn_info->req_ie_len, GFP_KERNEL);
2742 conn_info->req_ie_len = 0;
2743 conn_info->req_ie = NULL;
2746 err = wl_dev_bufvar_get(ndev, "assoc_resp_ies", wl->extra_buf,
2748 if (unlikely(err)) {
2749 WL_ERR("could not get assoc resp (%d)\n", err);
2752 conn_info->resp_ie_len = resp_len;
2753 conn_info->resp_ie =
2754 kmemdup(wl->extra_buf, conn_info->resp_ie_len, GFP_KERNEL);
2756 conn_info->resp_ie_len = 0;
2757 conn_info->resp_ie = NULL;
2759 WL_CONN("req len (%d) resp len (%d)\n",
2760 conn_info->req_ie_len, conn_info->resp_ie_len);
2765 static void wl_clear_assoc_ies(struct wl_priv *wl)
2767 struct wl_connect_info *conn_info = wl_to_conn(wl);
2769 kfree(conn_info->req_ie);
2770 conn_info->req_ie = NULL;
2771 conn_info->req_ie_len = 0;
2772 kfree(conn_info->resp_ie);
2773 conn_info->resp_ie = NULL;
2774 conn_info->resp_ie_len = 0;
2778 static void wl_ch_to_chanspec(int ch, struct wl_join_params *join_params,
2779 size_t *join_params_size)
2781 chanspec_t chanspec = 0;
2784 join_params->params.chanspec_num = 1;
2785 join_params->params.chanspec_list[0] = ch;
2787 if (join_params->params.chanspec_list[0] <= CH_MAX_2G_CHANNEL)
2788 chanspec |= WL_CHANSPEC_BAND_2G;
2790 chanspec |= WL_CHANSPEC_BAND_5G;
2792 chanspec |= WL_CHANSPEC_BW_20;
2793 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
2795 *join_params_size += WL_ASSOC_PARAMS_FIXED_SIZE +
2796 join_params->params.chanspec_num * sizeof(chanspec_t);
2798 join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
2799 join_params->params.chanspec_list[0] |= chanspec;
2800 join_params->params.chanspec_list[0] =
2801 cpu_to_le16(join_params->params.chanspec_list[0]);
2803 join_params->params.chanspec_num =
2804 cpu_to_le32(join_params->params.chanspec_num);
2806 WL_CONN("join_params->params.chanspec_list[0]= %#X,"
2807 "channel %d, chanspec %#X\n",
2808 join_params->params.chanspec_list[0], ch, chanspec);
2812 static s32 wl_update_bss_info(struct wl_priv *wl)
2814 struct wl_bss_info *bi;
2815 struct wlc_ssid *ssid;
2816 struct brcmu_tlv *tim;
2817 u16 beacon_interval;
2823 WL_TRACE("Enter\n");
2824 if (wl_is_ibssmode(wl))
2827 ssid = (struct wlc_ssid *)wl_read_prof(wl, WL_PROF_SSID);
2829 *(u32 *)wl->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2830 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_BSS_INFO,
2831 wl->extra_buf, WL_EXTRA_BUF_MAX);
2832 if (unlikely(err)) {
2833 WL_ERR("Could not get bss info %d\n", err);
2834 goto update_bss_info_out;
2837 bi = (struct wl_bss_info *)(wl->extra_buf + 4);
2838 err = wl_inform_single_bss(wl, bi);
2840 goto update_bss_info_out;
2842 ie = ((u8 *)bi) + bi->ie_offset;
2843 ie_len = bi->ie_length;
2844 beacon_interval = cpu_to_le16(bi->beacon_period);
2846 tim = brcmu_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2848 dtim_period = tim->data[1];
2851 * active scan was done so we could not get dtim
2852 * information out of probe response.
2853 * so we speficially query dtim information to dongle.
2856 err = wl_dev_intvar_get(wl_to_ndev(wl), "dtim_assoc", &var);
2857 if (unlikely(err)) {
2858 WL_ERR("wl dtim_assoc failed (%d)\n", err);
2859 goto update_bss_info_out;
2861 dtim_period = (u8)var;
2864 wl_update_prof(wl, NULL, &beacon_interval, WL_PROF_BEACONINT);
2865 wl_update_prof(wl, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
2867 update_bss_info_out:
2873 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
2874 const wl_event_msg_t *e, void *data)
2876 struct wl_connect_info *conn_info = wl_to_conn(wl);
2879 WL_TRACE("Enter\n");
2881 wl_get_assoc_ies(wl);
2882 wl_update_prof(wl, NULL, &e->addr, WL_PROF_BSSID);
2883 wl_update_bss_info(wl);
2885 cfg80211_roamed(ndev, NULL,
2886 (u8 *)wl_read_prof(wl, WL_PROF_BSSID),
2887 conn_info->req_ie, conn_info->req_ie_len,
2888 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
2889 WL_CONN("Report roaming result\n");
2891 set_bit(WL_STATUS_CONNECTED, &wl->status);
2897 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
2898 const wl_event_msg_t *e, void *data, bool completed)
2900 struct wl_connect_info *conn_info = wl_to_conn(wl);
2903 WL_TRACE("Enter\n");
2905 if (test_and_clear_bit(WL_STATUS_CONNECTING, &wl->status)) {
2907 wl_get_assoc_ies(wl);
2908 wl_update_prof(wl, NULL, &e->addr, WL_PROF_BSSID);
2909 wl_update_bss_info(wl);
2911 cfg80211_connect_result(ndev,
2912 (u8 *)wl_read_prof(wl, WL_PROF_BSSID),
2914 conn_info->req_ie_len,
2916 conn_info->resp_ie_len,
2917 completed ? WLAN_STATUS_SUCCESS : WLAN_STATUS_AUTH_TIMEOUT,
2920 set_bit(WL_STATUS_CONNECTED, &wl->status);
2921 WL_CONN("Report connect result - connection %s\n",
2922 completed ? "succeeded" : "failed");
2929 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
2930 const wl_event_msg_t *e, void *data)
2932 u16 flags = be16_to_cpu(e->flags);
2933 enum nl80211_key_type key_type;
2936 if (flags & WLC_EVENT_MSG_GROUP)
2937 key_type = NL80211_KEYTYPE_GROUP;
2939 key_type = NL80211_KEYTYPE_PAIRWISE;
2941 cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
2949 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
2950 const wl_event_msg_t *e, void *data)
2952 struct channel_info channel_inform;
2953 struct wl_scan_results *bss_list;
2954 u32 len = WL_SCAN_BUF_MAX;
2956 bool scan_abort = false;
2958 WL_TRACE("Enter\n");
2960 if (wl->iscan_on && wl->iscan_kickstart) {
2962 return wl_wakeup_iscan(wl_to_iscan(wl));
2965 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
2966 WL_ERR("Scan complete while device not scanning\n");
2972 err = wl_dev_ioctl(ndev, WLC_GET_CHANNEL, &channel_inform,
2973 sizeof(channel_inform));
2974 if (unlikely(err)) {
2975 WL_ERR("scan busy (%d)\n", err);
2979 channel_inform.scan_channel = le32_to_cpu(channel_inform.scan_channel);
2980 if (unlikely(channel_inform.scan_channel)) {
2982 WL_CONN("channel_inform.scan_channel (%d)\n",
2983 channel_inform.scan_channel);
2985 wl->bss_list = wl->scan_results;
2986 bss_list = wl->bss_list;
2987 memset(bss_list, 0, len);
2988 bss_list->buflen = cpu_to_le32(len);
2990 err = wl_dev_ioctl(ndev, WLC_SCAN_RESULTS, bss_list, len);
2991 if (unlikely(err)) {
2992 WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
2997 bss_list->buflen = le32_to_cpu(bss_list->buflen);
2998 bss_list->version = le32_to_cpu(bss_list->version);
2999 bss_list->count = le32_to_cpu(bss_list->count);
3001 err = wl_inform_bss(wl);
3008 if (wl->scan_request) {
3009 WL_SCAN("calling cfg80211_scan_done\n");
3010 cfg80211_scan_done(wl->scan_request, scan_abort);
3011 wl_set_mpc(ndev, 1);
3012 wl->scan_request = NULL;
3020 static void wl_init_conf(struct wl_conf *conf)
3022 conf->mode = (u32)-1;
3023 conf->frag_threshold = (u32)-1;
3024 conf->rts_threshold = (u32)-1;
3025 conf->retry_short = (u32)-1;
3026 conf->retry_long = (u32)-1;
3027 conf->tx_power = -1;
3030 static void wl_init_prof(struct wl_profile *prof)
3032 memset(prof, 0, sizeof(*prof));
3035 static void wl_init_eloop_handler(struct wl_event_loop *el)
3037 memset(el, 0, sizeof(*el));
3038 el->handler[WLC_E_SCAN_COMPLETE] = wl_notify_scan_status;
3039 el->handler[WLC_E_LINK] = wl_notify_connect_status;
3040 el->handler[WLC_E_ROAM] = wl_notify_roaming_status;
3041 el->handler[WLC_E_MIC_ERROR] = wl_notify_mic_status;
3042 el->handler[WLC_E_SET_SSID] = wl_notify_connect_status;
3045 static s32 wl_init_priv_mem(struct wl_priv *wl)
3047 wl->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
3048 if (unlikely(!wl->scan_results)) {
3049 WL_ERR("Scan results alloc failed\n");
3050 goto init_priv_mem_out;
3052 wl->conf = kzalloc(sizeof(*wl->conf), GFP_KERNEL);
3053 if (unlikely(!wl->conf)) {
3054 WL_ERR("wl_conf alloc failed\n");
3055 goto init_priv_mem_out;
3057 wl->profile = kzalloc(sizeof(*wl->profile), GFP_KERNEL);
3058 if (unlikely(!wl->profile)) {
3059 WL_ERR("wl_profile alloc failed\n");
3060 goto init_priv_mem_out;
3062 wl->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
3063 if (unlikely(!wl->bss_info)) {
3064 WL_ERR("Bss information alloc failed\n");
3065 goto init_priv_mem_out;
3067 wl->scan_req_int = kzalloc(sizeof(*wl->scan_req_int), GFP_KERNEL);
3068 if (unlikely(!wl->scan_req_int)) {
3069 WL_ERR("Scan req alloc failed\n");
3070 goto init_priv_mem_out;
3072 wl->ioctl_buf = kzalloc(WL_IOCTL_LEN_MAX, GFP_KERNEL);
3073 if (unlikely(!wl->ioctl_buf)) {
3074 WL_ERR("Ioctl buf alloc failed\n");
3075 goto init_priv_mem_out;
3077 wl->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3078 if (unlikely(!wl->extra_buf)) {
3079 WL_ERR("Extra buf alloc failed\n");
3080 goto init_priv_mem_out;
3082 wl->iscan = kzalloc(sizeof(*wl->iscan), GFP_KERNEL);
3083 if (unlikely(!wl->iscan)) {
3084 WL_ERR("Iscan buf alloc failed\n");
3085 goto init_priv_mem_out;
3087 wl->fw = kzalloc(sizeof(*wl->fw), GFP_KERNEL);
3088 if (unlikely(!wl->fw)) {
3089 WL_ERR("fw object alloc failed\n");
3090 goto init_priv_mem_out;
3092 wl->pmk_list = kzalloc(sizeof(*wl->pmk_list), GFP_KERNEL);
3093 if (unlikely(!wl->pmk_list)) {
3094 WL_ERR("pmk list alloc failed\n");
3095 goto init_priv_mem_out;
3101 wl_deinit_priv_mem(wl);
3106 static void wl_deinit_priv_mem(struct wl_priv *wl)
3108 kfree(wl->scan_results);
3109 wl->scan_results = NULL;
3110 kfree(wl->bss_info);
3111 wl->bss_info = NULL;
3116 kfree(wl->scan_req_int);
3117 wl->scan_req_int = NULL;
3118 kfree(wl->ioctl_buf);
3119 wl->ioctl_buf = NULL;
3120 kfree(wl->extra_buf);
3121 wl->extra_buf = NULL;
3126 kfree(wl->pmk_list);
3127 wl->pmk_list = NULL;
3130 static s32 wl_create_event_handler(struct wl_priv *wl)
3132 sema_init(&wl->event_sync, 0);
3133 wl->event_tsk = kthread_run(wl_event_handler, wl, "wl_event_handler");
3134 if (IS_ERR(wl->event_tsk)) {
3135 wl->event_tsk = NULL;
3136 WL_ERR("failed to create event thread\n");
3142 static void wl_destroy_event_handler(struct wl_priv *wl)
3144 if (wl->event_tsk) {
3145 send_sig(SIGTERM, wl->event_tsk, 1);
3146 kthread_stop(wl->event_tsk);
3147 wl->event_tsk = NULL;
3151 static void wl_term_iscan(struct wl_priv *wl)
3153 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3155 if (wl->iscan_on && iscan->tsk) {
3156 iscan->state = WL_ISCAN_STATE_IDLE;
3157 send_sig(SIGTERM, iscan->tsk, 1);
3158 kthread_stop(iscan->tsk);
3163 static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted)
3165 struct wl_priv *wl = iscan_to_wl(iscan);
3166 struct net_device *ndev = wl_to_ndev(wl);
3168 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
3169 WL_ERR("Scan complete while device not scanning\n");
3172 if (likely(wl->scan_request)) {
3173 WL_SCAN("ISCAN Completed scan: %s\n",
3174 aborted ? "Aborted" : "Done");
3175 cfg80211_scan_done(wl->scan_request, aborted);
3176 wl_set_mpc(ndev, 1);
3177 wl->scan_request = NULL;
3179 wl->iscan_kickstart = false;
3182 static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan)
3184 if (likely(iscan->state != WL_ISCAN_STATE_IDLE)) {
3185 WL_SCAN("wake up iscan\n");
3194 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
3195 struct wl_scan_results **bss_list)
3197 struct wl_iscan_results list;
3198 struct wl_scan_results *results;
3199 struct wl_iscan_results *list_buf;
3202 memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
3203 list_buf = (struct wl_iscan_results *)iscan->scan_buf;
3204 results = &list_buf->results;
3205 results->buflen = WL_ISCAN_RESULTS_FIXED_SIZE;
3206 results->version = 0;
3209 memset(&list, 0, sizeof(list));
3210 list.results.buflen = cpu_to_le32(WL_ISCAN_BUF_MAX);
3211 err = wl_dev_iovar_getbuf(iscan->dev, "iscanresults", &list,
3212 WL_ISCAN_RESULTS_FIXED_SIZE, iscan->scan_buf,
3214 if (unlikely(err)) {
3215 WL_ERR("error (%d)\n", err);
3218 results->buflen = le32_to_cpu(results->buflen);
3219 results->version = le32_to_cpu(results->version);
3220 results->count = le32_to_cpu(results->count);
3221 WL_SCAN("results->count = %d\n", results->count);
3222 WL_SCAN("results->buflen = %d\n", results->buflen);
3223 *status = le32_to_cpu(list_buf->status);
3224 *bss_list = results;
3229 static s32 wl_iscan_done(struct wl_priv *wl)
3231 struct wl_iscan_ctrl *iscan = wl->iscan;
3234 iscan->state = WL_ISCAN_STATE_IDLE;
3237 wl_notify_iscan_complete(iscan, false);
3243 static s32 wl_iscan_pending(struct wl_priv *wl)
3245 struct wl_iscan_ctrl *iscan = wl->iscan;
3248 /* Reschedule the timer */
3249 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3250 iscan->timer_on = 1;
3255 static s32 wl_iscan_inprogress(struct wl_priv *wl)
3257 struct wl_iscan_ctrl *iscan = wl->iscan;
3262 wl_run_iscan(iscan, NULL, WL_SCAN_ACTION_CONTINUE);
3264 /* Reschedule the timer */
3265 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3266 iscan->timer_on = 1;
3271 static s32 wl_iscan_aborted(struct wl_priv *wl)
3273 struct wl_iscan_ctrl *iscan = wl->iscan;
3276 iscan->state = WL_ISCAN_STATE_IDLE;
3278 wl_notify_iscan_complete(iscan, true);
3284 static s32 wl_iscan_thread(void *data)
3286 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3287 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
3288 struct wl_priv *wl = iscan_to_wl(iscan);
3289 struct wl_iscan_eloop *el = &iscan->el;
3293 sched_setscheduler(current, SCHED_FIFO, ¶m);
3294 allow_signal(SIGTERM);
3295 status = WL_SCAN_RESULTS_PARTIAL;
3296 while (likely(!down_interruptible(&iscan->sync))) {
3297 if (kthread_should_stop())
3299 if (iscan->timer_on) {
3300 del_timer_sync(&iscan->timer);
3301 iscan->timer_on = 0;
3304 err = wl_get_iscan_results(iscan, &status, &wl->bss_list);
3305 if (unlikely(err)) {
3306 status = WL_SCAN_RESULTS_ABORTED;
3307 WL_ERR("Abort iscan\n");
3310 el->handler[status] (wl);
3312 if (iscan->timer_on) {
3313 del_timer_sync(&iscan->timer);
3314 iscan->timer_on = 0;
3316 WL_SCAN("ISCAN thread terminated\n");
3321 static void wl_iscan_timer(unsigned long data)
3323 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
3326 iscan->timer_on = 0;
3327 WL_SCAN("timer expired\n");
3328 wl_wakeup_iscan(iscan);
3332 static s32 wl_invoke_iscan(struct wl_priv *wl)
3334 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3337 if (wl->iscan_on && !iscan->tsk) {
3338 iscan->state = WL_ISCAN_STATE_IDLE;
3339 sema_init(&iscan->sync, 0);
3340 iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
3341 if (IS_ERR(iscan->tsk)) {
3342 WL_ERR("Could not create iscan thread\n");
3351 static void wl_init_iscan_eloop(struct wl_iscan_eloop *el)
3353 memset(el, 0, sizeof(*el));
3354 el->handler[WL_SCAN_RESULTS_SUCCESS] = wl_iscan_done;
3355 el->handler[WL_SCAN_RESULTS_PARTIAL] = wl_iscan_inprogress;
3356 el->handler[WL_SCAN_RESULTS_PENDING] = wl_iscan_pending;
3357 el->handler[WL_SCAN_RESULTS_ABORTED] = wl_iscan_aborted;
3358 el->handler[WL_SCAN_RESULTS_NO_MEM] = wl_iscan_aborted;
3361 static s32 wl_init_iscan(struct wl_priv *wl)
3363 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3367 iscan->dev = wl_to_ndev(wl);
3368 iscan->state = WL_ISCAN_STATE_IDLE;
3369 wl_init_iscan_eloop(&iscan->el);
3370 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
3371 init_timer(&iscan->timer);
3372 iscan->timer.data = (unsigned long) iscan;
3373 iscan->timer.function = wl_iscan_timer;
3374 sema_init(&iscan->sync, 0);
3375 iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
3376 if (IS_ERR(iscan->tsk)) {
3377 WL_ERR("Could not create iscan thread\n");
3387 static void wl_init_fw(struct wl_fw_ctrl *fw)
3389 fw->status = 0; /* init fw loading status.
3390 0 means nothing was loaded yet */
3393 static s32 wl_init_priv(struct wl_priv *wl)
3395 struct wiphy *wiphy = wl_to_wiphy(wl);
3398 wl->scan_request = NULL;
3399 wl->pwr_save = !!(wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT);
3400 wl->iscan_on = true; /* iscan on & off switch.
3401 we enable iscan per default */
3402 wl->roam_on = false; /* roam on & off switch.
3403 we enable roam per default */
3405 wl->iscan_kickstart = false;
3406 wl->active_scan = true; /* we do active scan for
3407 specific scan per default */
3408 wl->dongle_up = false; /* dongle is not up yet */
3410 err = wl_init_priv_mem(wl);
3413 if (unlikely(wl_create_event_handler(wl)))
3415 wl_init_eloop_handler(&wl->el);
3416 mutex_init(&wl->usr_sync);
3417 err = wl_init_iscan(wl);
3421 wl_init_conf(wl->conf);
3422 wl_init_prof(wl->profile);
3428 static void wl_deinit_priv(struct wl_priv *wl)
3430 wl_destroy_event_handler(wl);
3431 wl->dongle_up = false; /* dongle down */
3435 wl_deinit_priv_mem(wl);
3438 s32 wl_cfg80211_attach(struct net_device *ndev, void *data)
3440 struct wireless_dev *wdev;
3442 struct wl_iface *ci;
3445 if (unlikely(!ndev)) {
3446 WL_ERR("ndev is invalid\n");
3449 wl_cfg80211_dev = kzalloc(sizeof(struct wl_dev), GFP_KERNEL);
3450 if (unlikely(!wl_cfg80211_dev)) {
3451 WL_ERR("wl_cfg80211_dev is invalid\n");
3454 WL_INFO("func %p\n", wl_cfg80211_get_sdio_func());
3455 wdev = wl_alloc_wdev(sizeof(struct wl_iface), &wl_cfg80211_get_sdio_func()->dev);
3459 wdev->iftype = wl_mode_to_nl80211_iftype(WL_MODE_BSS);
3460 wl = wdev_to_wl(wdev);
3463 ci = (struct wl_iface *)wl_to_ci(wl);
3465 ndev->ieee80211_ptr = wdev;
3466 SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
3467 wdev->netdev = ndev;
3468 err = wl_init_priv(wl);
3469 if (unlikely(err)) {
3470 WL_ERR("Failed to init iwm_priv (%d)\n", err);
3471 goto cfg80211_attach_out;
3473 wl_set_drvdata(wl_cfg80211_dev, ci);
3477 cfg80211_attach_out:
3482 void wl_cfg80211_detach(void)
3490 wl_set_drvdata(wl_cfg80211_dev, NULL);
3491 kfree(wl_cfg80211_dev);
3492 wl_cfg80211_dev = NULL;
3493 wl_clear_sdio_func();
3496 static void wl_wakeup_event(struct wl_priv *wl)
3498 up(&wl->event_sync);
3501 static s32 wl_event_handler(void *data)
3503 struct wl_priv *wl = (struct wl_priv *)data;
3504 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3505 struct wl_event_q *e;
3507 sched_setscheduler(current, SCHED_FIFO, ¶m);
3508 allow_signal(SIGTERM);
3509 while (likely(!down_interruptible(&wl->event_sync))) {
3510 if (kthread_should_stop())
3512 e = wl_deq_event(wl);
3514 WL_ERR("event queue empty...\n");
3517 WL_INFO("event type (%d)\n", e->etype);
3518 if (wl->el.handler[e->etype]) {
3519 wl->el.handler[e->etype] (wl, wl_to_ndev(wl), &e->emsg,
3522 WL_INFO("Unknown Event (%d): ignoring\n", e->etype);
3526 WL_INFO("was terminated\n");
3531 wl_cfg80211_event(struct net_device *ndev, const wl_event_msg_t * e, void *data)
3533 u32 event_type = be32_to_cpu(e->event_type);
3534 struct wl_priv *wl = ndev_to_wl(ndev);
3536 if (likely(!wl_enq_event(wl, event_type, e, data)))
3537 wl_wakeup_event(wl);
3540 static void wl_init_eq(struct wl_priv *wl)
3542 wl_init_eq_lock(wl);
3543 INIT_LIST_HEAD(&wl->eq_list);
3546 static void wl_flush_eq(struct wl_priv *wl)
3548 struct wl_event_q *e;
3551 while (!list_empty(&wl->eq_list)) {
3552 e = list_first_entry(&wl->eq_list, struct wl_event_q, eq_list);
3553 list_del(&e->eq_list);
3560 * retrieve first queued event from head
3563 static struct wl_event_q *wl_deq_event(struct wl_priv *wl)
3565 struct wl_event_q *e = NULL;
3568 if (likely(!list_empty(&wl->eq_list))) {
3569 e = list_first_entry(&wl->eq_list, struct wl_event_q, eq_list);
3570 list_del(&e->eq_list);
3578 ** push event to tail of the queue
3582 wl_enq_event(struct wl_priv *wl, u32 event, const wl_event_msg_t *msg,
3585 struct wl_event_q *e;
3588 e = kzalloc(sizeof(struct wl_event_q), GFP_KERNEL);
3590 WL_ERR("event alloc failed\n");
3595 memcpy(&e->emsg, msg, sizeof(wl_event_msg_t));
3599 list_add_tail(&e->eq_list, &wl->eq_list);
3605 static void wl_put_event(struct wl_event_q *e)
3610 void wl_cfg80211_sdio_func(void *func)
3612 cfg80211_sdio_func = (struct sdio_func *)func;
3615 static void wl_clear_sdio_func(void)
3617 cfg80211_sdio_func = NULL;
3620 struct sdio_func *wl_cfg80211_get_sdio_func(void)
3622 return cfg80211_sdio_func;
3625 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype)
3631 case NL80211_IFTYPE_MONITOR:
3632 case NL80211_IFTYPE_WDS:
3633 WL_ERR("type (%d) : currently we do not support this mode\n",
3637 case NL80211_IFTYPE_ADHOC:
3640 case NL80211_IFTYPE_STATION:
3645 WL_ERR("invalid type (%d)\n", iftype);
3648 infra = cpu_to_le32(infra);
3649 err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
3650 if (unlikely(err)) {
3651 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
3658 #ifndef EMBEDDED_PLATFORM
3659 static s32 wl_dongle_country(struct net_device *ndev, u8 ccode)
3667 static s32 wl_dongle_up(struct net_device *ndev, u32 up)
3671 err = wl_dev_ioctl(ndev, WLC_UP, &up, sizeof(up));
3672 if (unlikely(err)) {
3673 WL_ERR("WLC_UP error (%d)\n", err);
3678 static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode)
3682 err = wl_dev_ioctl(ndev, WLC_SET_PM, &power_mode, sizeof(power_mode));
3683 if (unlikely(err)) {
3684 WL_ERR("WLC_SET_PM error (%d)\n", err);
3690 wl_dongle_glom(struct net_device *ndev, u32 glom, u32 dongle_align)
3692 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3696 /* Match Host and Dongle rx alignment */
3697 brcmu_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf,
3699 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3700 if (unlikely(err)) {
3701 WL_ERR("txglomalign error (%d)\n", err);
3702 goto dongle_glom_out;
3704 /* disable glom option per default */
3705 brcmu_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));
3706 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3707 if (unlikely(err)) {
3708 WL_ERR("txglom error (%d)\n", err);
3709 goto dongle_glom_out;
3716 wl_dongle_offload(struct net_device *ndev, s32 arpoe, s32 arp_ol)
3718 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3722 /* Set ARP offload */
3723 brcmu_mkiovar("arpoe", (char *)&arpoe, 4, iovbuf, sizeof(iovbuf));
3724 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3726 if (err == -EOPNOTSUPP)
3727 WL_INFO("arpoe is not supported\n");
3729 WL_ERR("arpoe error (%d)\n", err);
3731 goto dongle_offload_out;
3733 brcmu_mkiovar("arp_ol", (char *)&arp_ol, 4, iovbuf, sizeof(iovbuf));
3734 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3736 if (err == -EOPNOTSUPP)
3737 WL_INFO("arp_ol is not supported\n");
3739 WL_ERR("arp_ol error (%d)\n", err);
3741 goto dongle_offload_out;
3748 static s32 wl_pattern_atoh(s8 *src, s8 *dst)
3751 if (strncmp(src, "0x", 2) != 0 && strncmp(src, "0X", 2) != 0) {
3752 WL_ERR("Mask invalid format. Needs to start with 0x\n");
3755 src = src + 2; /* Skip past 0x */
3756 if (strlen(src) % 2 != 0) {
3757 WL_ERR("Mask invalid format. Needs to be of even length\n");
3760 for (i = 0; *src != '\0'; i++) {
3762 strncpy(num, src, 2);
3764 dst[i] = (u8) simple_strtoul(num, NULL, 16);
3770 static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode)
3772 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3775 struct wl_pkt_filter pkt_filter;
3776 struct wl_pkt_filter *pkt_filterp;
3784 /* add a default packet filter pattern */
3785 str = "pkt_filter_add";
3786 str_len = strlen(str);
3787 strncpy(buf, str, str_len);
3788 buf[str_len] = '\0';
3789 buf_len = str_len + 1;
3791 pkt_filterp = (struct wl_pkt_filter *)(buf + str_len + 1);
3793 /* Parse packet filter id. */
3794 pkt_filter.id = cpu_to_le32(100);
3796 /* Parse filter polarity. */
3797 pkt_filter.negate_match = cpu_to_le32(0);
3799 /* Parse filter type. */
3800 pkt_filter.type = cpu_to_le32(0);
3802 /* Parse pattern filter offset. */
3803 pkt_filter.u.pattern.offset = cpu_to_le32(0);
3805 /* Parse pattern filter mask. */
3806 mask_size = cpu_to_le32(wl_pattern_atoh("0xff",
3807 (char *)pkt_filterp->u.pattern.
3810 /* Parse pattern filter pattern. */
3811 pattern_size = cpu_to_le32(wl_pattern_atoh("0x00",
3812 (char *)&pkt_filterp->u.
3817 if (mask_size != pattern_size) {
3818 WL_ERR("Mask and pattern not the same size\n");
3820 goto dongle_filter_out;
3823 pkt_filter.u.pattern.size_bytes = mask_size;
3824 buf_len += WL_PKT_FILTER_FIXED_LEN;
3825 buf_len += (WL_PKT_FILTER_PATTERN_FIXED_LEN + 2 * mask_size);
3827 /* Keep-alive attributes are set in local
3828 * variable (keep_alive_pkt), and
3829 * then memcpy'ed into buffer (keep_alive_pktp) since there is no
3830 * guarantee that the buffer is properly aligned.
3832 memcpy((char *)pkt_filterp, &pkt_filter,
3833 WL_PKT_FILTER_FIXED_LEN + WL_PKT_FILTER_PATTERN_FIXED_LEN);
3835 err = wl_dev_ioctl(ndev, WLC_SET_VAR, buf, buf_len);
3837 if (err == -EOPNOTSUPP) {
3838 WL_INFO("filter not supported\n");
3840 WL_ERR("filter (%d)\n", err);
3842 goto dongle_filter_out;
3845 /* set mode to allow pattern */
3846 brcmu_mkiovar("pkt_filter_mode", (char *)&filter_mode, 4, iovbuf,
3848 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3850 if (err == -EOPNOTSUPP) {
3851 WL_INFO("filter_mode not supported\n");
3853 WL_ERR("filter_mode (%d)\n", err);
3855 goto dongle_filter_out;
3861 #endif /* !EMBEDDED_PLATFORM */
3863 static s32 wl_dongle_eventmsg(struct net_device *ndev)
3865 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3867 s8 eventmask[WL_EVENTING_MASK_LEN];
3870 WL_TRACE("Enter\n");
3872 /* Setup event_msgs */
3873 brcmu_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
3875 err = wl_dev_ioctl(ndev, WLC_GET_VAR, iovbuf, sizeof(iovbuf));
3876 if (unlikely(err)) {
3877 WL_ERR("Get event_msgs error (%d)\n", err);
3878 goto dongle_eventmsg_out;
3880 memcpy(eventmask, iovbuf, WL_EVENTING_MASK_LEN);
3882 setbit(eventmask, WLC_E_SET_SSID);
3883 setbit(eventmask, WLC_E_ROAM);
3884 setbit(eventmask, WLC_E_PRUNE);
3885 setbit(eventmask, WLC_E_AUTH);
3886 setbit(eventmask, WLC_E_REASSOC);
3887 setbit(eventmask, WLC_E_REASSOC_IND);
3888 setbit(eventmask, WLC_E_DEAUTH_IND);
3889 setbit(eventmask, WLC_E_DISASSOC_IND);
3890 setbit(eventmask, WLC_E_DISASSOC);
3891 setbit(eventmask, WLC_E_JOIN);
3892 setbit(eventmask, WLC_E_ASSOC_IND);
3893 setbit(eventmask, WLC_E_PSK_SUP);
3894 setbit(eventmask, WLC_E_LINK);
3895 setbit(eventmask, WLC_E_NDIS_LINK);
3896 setbit(eventmask, WLC_E_MIC_ERROR);
3897 setbit(eventmask, WLC_E_PMKID_CACHE);
3898 setbit(eventmask, WLC_E_TXFAIL);
3899 setbit(eventmask, WLC_E_JOIN_START);
3900 setbit(eventmask, WLC_E_SCAN_COMPLETE);
3902 brcmu_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
3904 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3905 if (unlikely(err)) {
3906 WL_ERR("Set event_msgs error (%d)\n", err);
3907 goto dongle_eventmsg_out;
3910 dongle_eventmsg_out:
3916 wl_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
3924 * Setup timeout if Beacons are lost and roam is
3925 * off to report link down
3928 brcmu_mkiovar("bcn_timeout", (char *)&bcn_timeout,
3929 sizeof(bcn_timeout), iovbuf, sizeof(iovbuf));
3930 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3931 if (unlikely(err)) {
3932 WL_ERR("bcn_timeout error (%d)\n", err);
3933 goto dongle_rom_out;
3938 * Enable/Disable built-in roaming to allow supplicant
3939 * to take care of roaming
3941 WL_INFO("Internal Roaming = %s\n", roamvar ? "Off" : "On");
3942 brcmu_mkiovar("roam_off", (char *)&roamvar,
3943 sizeof(roamvar), iovbuf, sizeof(iovbuf));
3944 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3945 if (unlikely(err)) {
3946 WL_ERR("roam_off error (%d)\n", err);
3947 goto dongle_rom_out;
3950 roamtrigger[0] = WL_ROAM_TRIGGER_LEVEL;
3951 roamtrigger[1] = WLC_BAND_ALL;
3952 err = wl_dev_ioctl(ndev, WLC_SET_ROAM_TRIGGER,
3953 (void *)roamtrigger, sizeof(roamtrigger));
3954 if (unlikely(err)) {
3955 WL_ERR("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
3956 goto dongle_rom_out;
3959 roam_delta[0] = WL_ROAM_DELTA;
3960 roam_delta[1] = WLC_BAND_ALL;
3961 err = wl_dev_ioctl(ndev, WLC_SET_ROAM_DELTA,
3962 (void *)roam_delta, sizeof(roam_delta));
3963 if (unlikely(err)) {
3964 WL_ERR("WLC_SET_ROAM_DELTA error (%d)\n", err);
3965 goto dongle_rom_out;
3973 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
3974 s32 scan_unassoc_time, s32 scan_passive_time)
3978 err = wl_dev_ioctl(ndev, WLC_SET_SCAN_CHANNEL_TIME, &scan_assoc_time,
3979 sizeof(scan_assoc_time));
3981 if (err == -EOPNOTSUPP)
3982 WL_INFO("Scan assoc time is not supported\n");
3984 WL_ERR("Scan assoc time error (%d)\n", err);
3985 goto dongle_scantime_out;
3987 err = wl_dev_ioctl(ndev, WLC_SET_SCAN_UNASSOC_TIME, &scan_unassoc_time,
3988 sizeof(scan_unassoc_time));
3990 if (err == -EOPNOTSUPP)
3991 WL_INFO("Scan unassoc time is not supported\n");
3993 WL_ERR("Scan unassoc time error (%d)\n", err);
3994 goto dongle_scantime_out;
3997 err = wl_dev_ioctl(ndev, WLC_SET_SCAN_PASSIVE_TIME, &scan_passive_time,
3998 sizeof(scan_passive_time));
4000 if (err == -EOPNOTSUPP)
4001 WL_INFO("Scan passive time is not supported\n");
4003 WL_ERR("Scan passive time error (%d)\n", err);
4004 goto dongle_scantime_out;
4007 dongle_scantime_out:
4011 s32 wl_config_dongle(struct wl_priv *wl, bool need_lock)
4014 #define DHD_SDALIGN 32
4016 struct net_device *ndev;
4017 struct wireless_dev *wdev;
4023 ndev = wl_to_ndev(wl);
4024 wdev = ndev->ieee80211_ptr;
4028 #ifndef EMBEDDED_PLATFORM
4029 err = wl_dongle_up(ndev, 0);
4031 goto default_conf_out;
4032 err = wl_dongle_country(ndev, 0);
4034 goto default_conf_out;
4035 err = wl_dongle_power(ndev, PM_FAST);
4037 goto default_conf_out;
4038 err = wl_dongle_glom(ndev, 0, DHD_SDALIGN);
4040 goto default_conf_out;
4042 wl_dongle_offload(ndev, 1, 0xf);
4043 wl_dongle_filter(ndev, 1);
4044 #endif /* !EMBEDDED_PLATFORM */
4046 wl_dongle_scantime(ndev, WL_SCAN_CHANNEL_TIME,
4047 WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
4049 err = wl_dongle_eventmsg(ndev);
4051 goto default_conf_out;
4052 err = wl_dongle_roam(ndev, (wl->roam_on ? 0 : 1), WL_BEACON_TIMEOUT);
4054 goto default_conf_out;
4055 err = wl_dongle_mode(ndev, wdev->iftype);
4056 if (unlikely(err && err != -EINPROGRESS))
4057 goto default_conf_out;
4058 err = wl_dongle_probecap(wl);
4060 goto default_conf_out;
4062 /* -EINPROGRESS: Call commit handler */
4068 wl->dongle_up = true;
4074 static s32 wl_update_wiphybands(struct wl_priv *wl)
4076 struct wiphy *wiphy;
4081 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_PHYLIST, &phy_list,
4083 if (unlikely(err)) {
4084 WL_ERR("error (%d)\n", err);
4088 phy = ((char *)&phy_list)[1];
4089 WL_INFO("%c phy\n", phy);
4090 if (phy == 'n' || phy == 'a') {
4091 wiphy = wl_to_wiphy(wl);
4092 wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
4098 static s32 __wl_cfg80211_up(struct wl_priv *wl)
4102 set_bit(WL_STATUS_READY, &wl->status);
4104 wl_debugfs_add_netdev_params(wl);
4106 err = wl_config_dongle(wl, false);
4110 wl_invoke_iscan(wl);
4115 static s32 __wl_cfg80211_down(struct wl_priv *wl)
4118 * While going down, if associated with AP disassociate
4119 * from AP to save power
4121 if ((test_bit(WL_STATUS_CONNECTED, &wl->status) ||
4122 test_bit(WL_STATUS_CONNECTING, &wl->status)) &&
4123 test_bit(WL_STATUS_READY, &wl->status)) {
4124 WL_INFO("Disassociating from AP");
4127 /* Make sure WPA_Supplicant receives all the event
4128 generated due to DISASSOC call to the fw to keep
4129 the state fw and WPA_Supplicant state consistent
4136 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
4138 if (wl->scan_request) {
4139 cfg80211_scan_done(wl->scan_request, true);
4140 /* May need to perform this to cover rmmod */
4141 /* wl_set_mpc(wl_to_ndev(wl), 1); */
4142 wl->scan_request = NULL;
4144 clear_bit(WL_STATUS_READY, &wl->status);
4145 clear_bit(WL_STATUS_SCANNING, &wl->status);
4146 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
4148 wl_debugfs_remove_netdev(wl);
4153 s32 wl_cfg80211_up(void)
4159 mutex_lock(&wl->usr_sync);
4160 err = __wl_cfg80211_up(wl);
4161 mutex_unlock(&wl->usr_sync);
4166 s32 wl_cfg80211_down(void)
4172 mutex_lock(&wl->usr_sync);
4173 err = __wl_cfg80211_down(wl);
4174 mutex_unlock(&wl->usr_sync);
4179 static s32 wl_dongle_probecap(struct wl_priv *wl)
4181 return wl_update_wiphybands(wl);
4184 static void *wl_read_prof(struct wl_priv *wl, s32 item)
4188 return &wl->profile->sec;
4190 return &wl->profile->bssid;
4192 return &wl->profile->ssid;
4194 WL_ERR("invalid item (%d)\n", item);
4199 wl_update_prof(struct wl_priv *wl, const wl_event_msg_t *e, void *data,
4203 struct wlc_ssid *ssid;
4207 ssid = (wlc_ssid_t *) data;
4208 memset(wl->profile->ssid.SSID, 0,
4209 sizeof(wl->profile->ssid.SSID));
4210 memcpy(wl->profile->ssid.SSID, ssid->SSID, ssid->SSID_len);
4211 wl->profile->ssid.SSID_len = ssid->SSID_len;
4215 memcpy(wl->profile->bssid, data, ETH_ALEN);
4217 memset(wl->profile->bssid, 0, ETH_ALEN);
4220 memcpy(&wl->profile->sec, data, sizeof(wl->profile->sec));
4222 case WL_PROF_BEACONINT:
4223 wl->profile->beacon_interval = *(u16 *)data;
4225 case WL_PROF_DTIMPERIOD:
4226 wl->profile->dtim_period = *(u8 *)data;
4229 WL_ERR("unsupported item (%d)\n", item);
4237 static bool wl_is_ibssmode(struct wl_priv *wl)
4239 return wl->conf->mode == WL_MODE_IBSS;
4242 static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v)
4244 struct wl_ie *ie = wl_to_ie(wl);
4247 if (unlikely(ie->offset + l + 2 > WL_TLV_INFO_MAX)) {
4248 WL_ERR("ei crosses buffer boundary\n");
4251 ie->buf[ie->offset] = t;
4252 ie->buf[ie->offset + 1] = l;
4253 memcpy(&ie->buf[ie->offset + 2], v, l);
4254 ie->offset += l + 2;
4259 static void wl_link_down(struct wl_priv *wl)
4261 struct net_device *dev = NULL;
4264 WL_TRACE("Enter\n");
4267 dev = wl_to_ndev(wl);
4268 WL_INFO("Call WLC_DISASSOC to stop excess roaming\n ");
4269 err = wl_dev_ioctl(dev, WLC_DISASSOC, NULL, 0);
4271 WL_ERR("WLC_DISASSOC failed (%d)\n", err);
4272 wl->link_up = false;
4277 static void wl_lock_eq(struct wl_priv *wl)
4279 spin_lock_irq(&wl->eq_lock);
4282 static void wl_unlock_eq(struct wl_priv *wl)
4284 spin_unlock_irq(&wl->eq_lock);
4287 static void wl_init_eq_lock(struct wl_priv *wl)
4289 spin_lock_init(&wl->eq_lock);
4292 static void wl_delay(u32 ms)
4294 if (ms < 1000 / HZ) {
4302 static void wl_set_drvdata(struct wl_dev *dev, void *data)
4304 dev->driver_data = data;
4307 static void *wl_get_drvdata(struct wl_dev *dev)
4312 data = dev->driver_data;
4316 s32 wl_cfg80211_read_fw(s8 *buf, u32 size)
4318 const struct firmware *fw_entry;
4323 fw_entry = wl->fw->fw_entry;
4325 if (fw_entry->size < wl->fw->ptr + size)
4326 size = fw_entry->size - wl->fw->ptr;
4328 memcpy(buf, &fw_entry->data[wl->fw->ptr], size);
4329 wl->fw->ptr += size;
4333 void wl_cfg80211_release_fw(void)
4338 release_firmware(wl->fw->fw_entry);
4342 void *wl_cfg80211_request_fw(s8 *file_name)
4345 const struct firmware *fw_entry = NULL;
4348 WL_INFO("file name : \"%s\"\n", file_name);
4351 if (!test_bit(WL_FW_LOADING_DONE, &wl->fw->status)) {
4352 err = request_firmware(&wl->fw->fw_entry, file_name,
4353 &wl_cfg80211_get_sdio_func()->dev);
4354 if (unlikely(err)) {
4355 WL_ERR("Could not download fw (%d)\n", err);
4358 set_bit(WL_FW_LOADING_DONE, &wl->fw->status);
4359 fw_entry = wl->fw->fw_entry;
4361 WL_INFO("fw size (%zd), data (%p)\n",
4362 fw_entry->size, fw_entry->data);
4364 } else if (!test_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status)) {
4365 err = request_firmware(&wl->fw->fw_entry, file_name,
4366 &wl_cfg80211_get_sdio_func()->dev);
4367 if (unlikely(err)) {
4368 WL_ERR("Could not download nvram (%d)\n", err);
4371 set_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status);
4372 fw_entry = wl->fw->fw_entry;
4374 WL_INFO("nvram size (%zd), data (%p)\n",
4375 fw_entry->size, fw_entry->data);
4378 WL_INFO("Downloading already done. Nothing to do more\n");
4383 if (unlikely(err)) {
4387 return (void *)fw_entry->data;
4390 s8 *wl_cfg80211_get_fwname(void)
4395 strcpy(wl->fw->fw_name, WL_4329_FW_FILE);
4396 return wl->fw->fw_name;
4399 s8 *wl_cfg80211_get_nvramname(void)
4404 strcpy(wl->fw->nvram_name, WL_4329_NVRAM_FILE);
4405 return wl->fw->nvram_name;
4408 static void wl_set_mpc(struct net_device *ndev, int mpc)
4411 struct wl_priv *wl = ndev_to_wl(ndev);
4413 if (test_bit(WL_STATUS_READY, &wl->status)) {
4414 err = wl_dev_intvar_set(ndev, "mpc", mpc);
4415 if (unlikely(err)) {
4416 WL_ERR("fail to set mpc\n");
4419 WL_INFO("MPC : %d\n", mpc);
4423 static int wl_debugfs_add_netdev_params(struct wl_priv *wl)
4425 char buf[10+IFNAMSIZ];
4429 sprintf(buf, "netdev:%s", wl_to_ndev(wl)->name);
4430 wl->debugfsdir = debugfs_create_dir(buf, wl_to_wiphy(wl)->debugfsdir);
4432 fd = debugfs_create_u16("beacon_int", S_IRUGO, wl->debugfsdir,
4433 (u16 *)&wl->profile->beacon_interval);
4439 fd = debugfs_create_u8("dtim_period", S_IRUGO, wl->debugfsdir,
4440 (u8 *)&wl->profile->dtim_period);
4450 static void wl_debugfs_remove_netdev(struct wl_priv *wl)
4452 debugfs_remove_recursive(wl->debugfsdir);
4453 wl->debugfsdir = NULL;