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>
22 #include <asm/uaccess.h>
24 #include <dngl_stats.h>
29 #include <linux/kthread.h>
30 #include <linux/netdevice.h>
31 #include <linux/sched.h>
32 #include <linux/etherdevice.h>
33 #include <linux/wireless.h>
34 #include <linux/ieee80211.h>
35 #include <net/cfg80211.h>
37 #include <net/rtnetlink.h>
38 #include <linux/mmc/sdio_func.h>
39 #include <linux/firmware.h>
40 #include <wl_cfg80211.h>
42 void sdioh_sdio_set_host_pm_flags(int flag);
44 static struct sdio_func *cfg80211_sdio_func;
45 static struct wl_dev *wl_cfg80211_dev;
46 static const u8 ether_bcast[ETH_ALEN] = {255, 255, 255, 255, 255, 255};
48 u32 wl_dbg_level = WL_DBG_ERR;
50 #define WL_4329_FW_FILE "brcm/bcm4329-fullmac-4.bin"
51 #define WL_4329_NVRAM_FILE "brcm/bcm4329-fullmac-4.txt"
54 ** cfg80211_ops api/callback list
56 static s32 wl_cfg80211_change_iface(struct wiphy *wiphy,
57 struct net_device *ndev,
58 enum nl80211_iftype type, u32 *flags,
59 struct vif_params *params);
60 static s32 __wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
61 struct cfg80211_scan_request *request,
62 struct cfg80211_ssid *this_ssid);
63 static s32 wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
64 struct cfg80211_scan_request *request);
65 static s32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed);
66 static s32 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
67 struct cfg80211_ibss_params *params);
68 static s32 wl_cfg80211_leave_ibss(struct wiphy *wiphy,
69 struct net_device *dev);
70 static s32 wl_cfg80211_get_station(struct wiphy *wiphy,
71 struct net_device *dev, u8 *mac,
72 struct station_info *sinfo);
73 static s32 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
74 struct net_device *dev, bool enabled,
76 static s32 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
77 struct net_device *dev,
79 const struct cfg80211_bitrate_mask
81 static int wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
82 struct cfg80211_connect_params *sme);
83 static s32 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
85 static s32 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
86 enum nl80211_tx_power_setting type,
88 static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm);
89 static s32 wl_cfg80211_config_default_key(struct wiphy *wiphy,
90 struct net_device *dev, u8 key_idx,
91 bool unicast, bool multicast);
92 static s32 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
93 u8 key_idx, bool pairwise, const u8 *mac_addr,
94 struct key_params *params);
95 static s32 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
96 u8 key_idx, bool pairwise, const u8 *mac_addr);
97 static s32 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
98 u8 key_idx, bool pairwise, const u8 *mac_addr,
99 void *cookie, void (*callback) (void *cookie,
103 static s32 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
104 struct net_device *dev,
106 static s32 wl_cfg80211_resume(struct wiphy *wiphy);
107 static s32 wl_cfg80211_suspend(struct wiphy *wiphy);
108 static s32 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
109 struct cfg80211_pmksa *pmksa);
110 static s32 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
111 struct cfg80211_pmksa *pmksa);
112 static s32 wl_cfg80211_flush_pmksa(struct wiphy *wiphy,
113 struct net_device *dev);
115 ** event & event Q handlers for cfg80211 interfaces
117 static s32 wl_create_event_handler(struct wl_priv *wl);
118 static void wl_destroy_event_handler(struct wl_priv *wl);
119 static s32 wl_event_handler(void *data);
120 static void wl_init_eq(struct wl_priv *wl);
121 static void wl_flush_eq(struct wl_priv *wl);
122 static void wl_lock_eq(struct wl_priv *wl);
123 static void wl_unlock_eq(struct wl_priv *wl);
124 static void wl_init_eq_lock(struct wl_priv *wl);
125 static void wl_init_eloop_handler(struct wl_event_loop *el);
126 static struct wl_event_q *wl_deq_event(struct wl_priv *wl);
127 static s32 wl_enq_event(struct wl_priv *wl, u32 type,
128 const wl_event_msg_t *msg, void *data);
129 static void wl_put_event(struct wl_event_q *e);
130 static void wl_wakeup_event(struct wl_priv *wl);
131 static s32 wl_notify_connect_status(struct wl_priv *wl,
132 struct net_device *ndev,
133 const wl_event_msg_t *e, void *data);
134 static s32 wl_notify_roaming_status(struct wl_priv *wl,
135 struct net_device *ndev,
136 const wl_event_msg_t *e, void *data);
137 static s32 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
138 const wl_event_msg_t *e, void *data);
139 static s32 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
140 const wl_event_msg_t *e, void *data,
142 static s32 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
143 const wl_event_msg_t *e, void *data);
144 static s32 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
145 const wl_event_msg_t *e, void *data);
148 ** register/deregister sdio function
150 struct sdio_func *wl_cfg80211_get_sdio_func(void);
151 static void wl_clear_sdio_func(void);
156 static s32 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
158 static __used s32 wl_dev_bufvar_set(struct net_device *dev, s8 *name,
160 static s32 wl_dev_intvar_set(struct net_device *dev, s8 *name, s32 val);
161 static s32 wl_dev_intvar_get(struct net_device *dev, s8 *name,
163 static s32 wl_dev_ioctl(struct net_device *dev, u32 cmd, void *arg,
167 ** cfg80211 set_wiphy_params utilities
169 static s32 wl_set_frag(struct net_device *dev, u32 frag_threshold);
170 static s32 wl_set_rts(struct net_device *dev, u32 frag_threshold);
171 static s32 wl_set_retry(struct net_device *dev, u32 retry, bool l);
174 ** wl profile utilities
176 static s32 wl_update_prof(struct wl_priv *wl, const wl_event_msg_t *e,
177 void *data, s32 item);
178 static void *wl_read_prof(struct wl_priv *wl, s32 item);
179 static void wl_init_prof(struct wl_profile *prof);
182 ** cfg80211 connect utilites
184 static s32 wl_set_wpa_version(struct net_device *dev,
185 struct cfg80211_connect_params *sme);
186 static s32 wl_set_auth_type(struct net_device *dev,
187 struct cfg80211_connect_params *sme);
188 static s32 wl_set_set_cipher(struct net_device *dev,
189 struct cfg80211_connect_params *sme);
190 static s32 wl_set_key_mgmt(struct net_device *dev,
191 struct cfg80211_connect_params *sme);
192 static s32 wl_set_set_sharedkey(struct net_device *dev,
193 struct cfg80211_connect_params *sme);
194 static s32 wl_get_assoc_ies(struct wl_priv *wl);
195 static void wl_clear_assoc_ies(struct wl_priv *wl);
196 static void wl_ch_to_chanspec(int ch,
197 struct wl_join_params *join_params, size_t *join_params_size);
200 ** information element utilities
202 static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v);
203 static s32 wl_mode_to_nl80211_iftype(s32 mode);
204 static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
206 static void wl_free_wdev(struct wl_priv *wl);
207 static s32 wl_inform_bss(struct wl_priv *wl);
208 static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi);
209 static s32 wl_update_bss_info(struct wl_priv *wl);
210 static s32 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
211 u8 key_idx, const u8 *mac_addr,
212 struct key_params *params);
215 ** key indianess swap utilities
217 static void swap_key_from_BE(struct wl_wsec_key *key);
218 static void swap_key_to_BE(struct wl_wsec_key *key);
221 ** wl_priv memory init/deinit utilities
223 static s32 wl_init_priv_mem(struct wl_priv *wl);
224 static void wl_deinit_priv_mem(struct wl_priv *wl);
226 static void wl_delay(u32 ms);
229 ** store/restore cfg80211 instance data
231 static void wl_set_drvdata(struct wl_dev *dev, void *data);
232 static void *wl_get_drvdata(struct wl_dev *dev);
235 ** ibss mode utilities
237 static bool wl_is_ibssmode(struct wl_priv *wl);
240 ** dongle up/down , default configuration utilities
242 static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e);
243 static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e);
244 static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e);
245 static void wl_link_down(struct wl_priv *wl);
246 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
247 static s32 __wl_cfg80211_up(struct wl_priv *wl);
248 static s32 __wl_cfg80211_down(struct wl_priv *wl);
249 static s32 wl_dongle_probecap(struct wl_priv *wl);
250 static void wl_init_conf(struct wl_conf *conf);
253 ** dongle configuration utilities
255 #ifndef EMBEDDED_PLATFORM
256 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
257 static s32 wl_dongle_country(struct net_device *ndev, u8 ccode);
258 static s32 wl_dongle_up(struct net_device *ndev, u32 up);
259 static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode);
260 static s32 wl_dongle_glom(struct net_device *ndev, u32 glom,
262 static s32 wl_dongle_offload(struct net_device *ndev, s32 arpoe,
264 static s32 wl_pattern_atoh(s8 *src, s8 *dst);
265 static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode);
266 static s32 wl_update_wiphybands(struct wl_priv *wl);
267 #endif /* !EMBEDDED_PLATFORM */
269 static s32 wl_dongle_eventmsg(struct net_device *ndev);
270 static s32 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
271 s32 scan_unassoc_time, s32 scan_passive_time);
272 static s32 wl_config_dongle(struct wl_priv *wl, bool need_lock);
273 static s32 wl_dongle_roam(struct net_device *ndev, u32 roamvar,
279 static void wl_iscan_timer(unsigned long data);
280 static void wl_term_iscan(struct wl_priv *wl);
281 static s32 wl_init_iscan(struct wl_priv *wl);
282 static s32 wl_iscan_thread(void *data);
283 static s32 wl_dev_iovar_setbuf(struct net_device *dev, s8 *iovar,
284 void *param, s32 paramlen, void *bufptr,
286 static s32 wl_dev_iovar_getbuf(struct net_device *dev, s8 *iovar,
287 void *param, s32 paramlen, void *bufptr,
289 static s32 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid,
291 static s32 wl_do_iscan(struct wl_priv *wl);
292 static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan);
293 static s32 wl_invoke_iscan(struct wl_priv *wl);
294 static s32 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
295 struct wl_scan_results **bss_list);
296 static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted);
297 static void wl_init_iscan_eloop(struct wl_iscan_eloop *el);
298 static s32 wl_iscan_done(struct wl_priv *wl);
299 static s32 wl_iscan_pending(struct wl_priv *wl);
300 static s32 wl_iscan_inprogress(struct wl_priv *wl);
301 static s32 wl_iscan_aborted(struct wl_priv *wl);
304 ** fw/nvram downloading handler
306 static void wl_init_fw(struct wl_fw_ctrl *fw);
309 * find most significant bit set
311 static __used u32 wl_find_msb(u16 bit16);
314 * update pmklist to dongle
316 static __used s32 wl_update_pmklist(struct net_device *dev,
317 struct wl_pmk_list *pmk_list, s32 err);
319 static void wl_set_mpc(struct net_device *ndev, int mpc);
324 static int wl_debugfs_add_netdev_params(struct wl_priv *wl);
325 static void wl_debugfs_remove_netdev(struct wl_priv *wl);
327 #define WL_PRIV_GET() \
329 struct wl_iface *ci; \
330 if (unlikely(!(wl_cfg80211_dev && \
331 (ci = wl_get_drvdata(wl_cfg80211_dev))))) { \
332 WL_ERR("wl_cfg80211_dev is unavailable\n"); \
338 #define CHECK_SYS_UP() \
340 struct wl_priv *wl = wiphy_to_wl(wiphy); \
341 if (unlikely(!test_bit(WL_STATUS_READY, &wl->status))) { \
342 WL_INFO("device is not ready : status (%d)\n", \
348 extern int dhd_wait_pend8021x(struct net_device *dev);
349 #define CHAN2G(_channel, _freq, _flags) { \
350 .band = IEEE80211_BAND_2GHZ, \
351 .center_freq = (_freq), \
352 .hw_value = (_channel), \
354 .max_antenna_gain = 0, \
358 #define CHAN5G(_channel, _flags) { \
359 .band = IEEE80211_BAND_5GHZ, \
360 .center_freq = 5000 + (5 * (_channel)), \
361 .hw_value = (_channel), \
363 .max_antenna_gain = 0, \
367 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
368 #define RATETAB_ENT(_rateid, _flags) \
370 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
371 .hw_value = (_rateid), \
375 static struct ieee80211_rate __wl_rates[] = {
376 RATETAB_ENT(WLC_RATE_1M, 0),
377 RATETAB_ENT(WLC_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
378 RATETAB_ENT(WLC_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
379 RATETAB_ENT(WLC_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
380 RATETAB_ENT(WLC_RATE_6M, 0),
381 RATETAB_ENT(WLC_RATE_9M, 0),
382 RATETAB_ENT(WLC_RATE_12M, 0),
383 RATETAB_ENT(WLC_RATE_18M, 0),
384 RATETAB_ENT(WLC_RATE_24M, 0),
385 RATETAB_ENT(WLC_RATE_36M, 0),
386 RATETAB_ENT(WLC_RATE_48M, 0),
387 RATETAB_ENT(WLC_RATE_54M, 0),
390 #define wl_a_rates (__wl_rates + 4)
391 #define wl_a_rates_size 8
392 #define wl_g_rates (__wl_rates + 0)
393 #define wl_g_rates_size 12
395 static struct ieee80211_channel __wl_2ghz_channels[] = {
412 static struct ieee80211_channel __wl_5ghz_a_channels[] = {
413 CHAN5G(34, 0), CHAN5G(36, 0),
414 CHAN5G(38, 0), CHAN5G(40, 0),
415 CHAN5G(42, 0), CHAN5G(44, 0),
416 CHAN5G(46, 0), CHAN5G(48, 0),
417 CHAN5G(52, 0), CHAN5G(56, 0),
418 CHAN5G(60, 0), CHAN5G(64, 0),
419 CHAN5G(100, 0), CHAN5G(104, 0),
420 CHAN5G(108, 0), CHAN5G(112, 0),
421 CHAN5G(116, 0), CHAN5G(120, 0),
422 CHAN5G(124, 0), CHAN5G(128, 0),
423 CHAN5G(132, 0), CHAN5G(136, 0),
424 CHAN5G(140, 0), CHAN5G(149, 0),
425 CHAN5G(153, 0), CHAN5G(157, 0),
426 CHAN5G(161, 0), CHAN5G(165, 0),
427 CHAN5G(184, 0), CHAN5G(188, 0),
428 CHAN5G(192, 0), CHAN5G(196, 0),
429 CHAN5G(200, 0), CHAN5G(204, 0),
430 CHAN5G(208, 0), CHAN5G(212, 0),
434 static struct ieee80211_channel __wl_5ghz_n_channels[] = {
435 CHAN5G(32, 0), CHAN5G(34, 0),
436 CHAN5G(36, 0), CHAN5G(38, 0),
437 CHAN5G(40, 0), CHAN5G(42, 0),
438 CHAN5G(44, 0), CHAN5G(46, 0),
439 CHAN5G(48, 0), CHAN5G(50, 0),
440 CHAN5G(52, 0), CHAN5G(54, 0),
441 CHAN5G(56, 0), CHAN5G(58, 0),
442 CHAN5G(60, 0), CHAN5G(62, 0),
443 CHAN5G(64, 0), CHAN5G(66, 0),
444 CHAN5G(68, 0), CHAN5G(70, 0),
445 CHAN5G(72, 0), CHAN5G(74, 0),
446 CHAN5G(76, 0), CHAN5G(78, 0),
447 CHAN5G(80, 0), CHAN5G(82, 0),
448 CHAN5G(84, 0), CHAN5G(86, 0),
449 CHAN5G(88, 0), CHAN5G(90, 0),
450 CHAN5G(92, 0), CHAN5G(94, 0),
451 CHAN5G(96, 0), CHAN5G(98, 0),
452 CHAN5G(100, 0), CHAN5G(102, 0),
453 CHAN5G(104, 0), CHAN5G(106, 0),
454 CHAN5G(108, 0), CHAN5G(110, 0),
455 CHAN5G(112, 0), CHAN5G(114, 0),
456 CHAN5G(116, 0), CHAN5G(118, 0),
457 CHAN5G(120, 0), CHAN5G(122, 0),
458 CHAN5G(124, 0), CHAN5G(126, 0),
459 CHAN5G(128, 0), CHAN5G(130, 0),
460 CHAN5G(132, 0), CHAN5G(134, 0),
461 CHAN5G(136, 0), CHAN5G(138, 0),
462 CHAN5G(140, 0), CHAN5G(142, 0),
463 CHAN5G(144, 0), CHAN5G(145, 0),
464 CHAN5G(146, 0), CHAN5G(147, 0),
465 CHAN5G(148, 0), CHAN5G(149, 0),
466 CHAN5G(150, 0), CHAN5G(151, 0),
467 CHAN5G(152, 0), CHAN5G(153, 0),
468 CHAN5G(154, 0), CHAN5G(155, 0),
469 CHAN5G(156, 0), CHAN5G(157, 0),
470 CHAN5G(158, 0), CHAN5G(159, 0),
471 CHAN5G(160, 0), CHAN5G(161, 0),
472 CHAN5G(162, 0), CHAN5G(163, 0),
473 CHAN5G(164, 0), CHAN5G(165, 0),
474 CHAN5G(166, 0), CHAN5G(168, 0),
475 CHAN5G(170, 0), CHAN5G(172, 0),
476 CHAN5G(174, 0), CHAN5G(176, 0),
477 CHAN5G(178, 0), CHAN5G(180, 0),
478 CHAN5G(182, 0), CHAN5G(184, 0),
479 CHAN5G(186, 0), CHAN5G(188, 0),
480 CHAN5G(190, 0), CHAN5G(192, 0),
481 CHAN5G(194, 0), CHAN5G(196, 0),
482 CHAN5G(198, 0), CHAN5G(200, 0),
483 CHAN5G(202, 0), CHAN5G(204, 0),
484 CHAN5G(206, 0), CHAN5G(208, 0),
485 CHAN5G(210, 0), CHAN5G(212, 0),
486 CHAN5G(214, 0), CHAN5G(216, 0),
487 CHAN5G(218, 0), CHAN5G(220, 0),
488 CHAN5G(222, 0), CHAN5G(224, 0),
489 CHAN5G(226, 0), CHAN5G(228, 0),
492 static struct ieee80211_supported_band __wl_band_2ghz = {
493 .band = IEEE80211_BAND_2GHZ,
494 .channels = __wl_2ghz_channels,
495 .n_channels = ARRAY_SIZE(__wl_2ghz_channels),
496 .bitrates = wl_g_rates,
497 .n_bitrates = wl_g_rates_size,
500 static struct ieee80211_supported_band __wl_band_5ghz_a = {
501 .band = IEEE80211_BAND_5GHZ,
502 .channels = __wl_5ghz_a_channels,
503 .n_channels = ARRAY_SIZE(__wl_5ghz_a_channels),
504 .bitrates = wl_a_rates,
505 .n_bitrates = wl_a_rates_size,
508 static struct ieee80211_supported_band __wl_band_5ghz_n = {
509 .band = IEEE80211_BAND_5GHZ,
510 .channels = __wl_5ghz_n_channels,
511 .n_channels = ARRAY_SIZE(__wl_5ghz_n_channels),
512 .bitrates = wl_a_rates,
513 .n_bitrates = wl_a_rates_size,
516 static const u32 __wl_cipher_suites[] = {
517 WLAN_CIPHER_SUITE_WEP40,
518 WLAN_CIPHER_SUITE_WEP104,
519 WLAN_CIPHER_SUITE_TKIP,
520 WLAN_CIPHER_SUITE_CCMP,
521 WLAN_CIPHER_SUITE_AES_CMAC,
524 static void swap_key_from_BE(struct wl_wsec_key *key)
526 key->index = cpu_to_le32(key->index);
527 key->len = cpu_to_le32(key->len);
528 key->algo = cpu_to_le32(key->algo);
529 key->flags = cpu_to_le32(key->flags);
530 key->rxiv.hi = cpu_to_le32(key->rxiv.hi);
531 key->rxiv.lo = cpu_to_le16(key->rxiv.lo);
532 key->iv_initialized = cpu_to_le32(key->iv_initialized);
535 static void swap_key_to_BE(struct wl_wsec_key *key)
537 key->index = le32_to_cpu(key->index);
538 key->len = le32_to_cpu(key->len);
539 key->algo = le32_to_cpu(key->algo);
540 key->flags = le32_to_cpu(key->flags);
541 key->rxiv.hi = le32_to_cpu(key->rxiv.hi);
542 key->rxiv.lo = le16_to_cpu(key->rxiv.lo);
543 key->iv_initialized = le32_to_cpu(key->iv_initialized);
547 wl_dev_ioctl(struct net_device *dev, u32 cmd, void *arg, u32 len)
554 memset(&ioc, 0, sizeof(ioc));
558 strcpy(ifr.ifr_name, dev->name);
559 ifr.ifr_data = (caddr_t)&ioc;
563 err = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
570 wl_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
571 enum nl80211_iftype type, u32 *flags,
572 struct vif_params *params)
574 struct wl_priv *wl = wiphy_to_wl(wiphy);
575 struct wireless_dev *wdev;
583 case NL80211_IFTYPE_MONITOR:
584 case NL80211_IFTYPE_WDS:
585 WL_ERR("type (%d) : currently we do not support this type\n",
588 case NL80211_IFTYPE_ADHOC:
589 wl->conf->mode = WL_MODE_IBSS;
592 case NL80211_IFTYPE_STATION:
593 wl->conf->mode = WL_MODE_BSS;
601 infra = cpu_to_le32(infra);
602 err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
604 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
607 wdev = ndev->ieee80211_ptr;
611 WL_INFO("IF Type = %s\n",
612 (wl->conf->mode == WL_MODE_IBSS) ? "Adhoc" : "Infra");
620 static void wl_iscan_prep(struct wl_scan_params *params, struct wlc_ssid *ssid)
622 memcpy(params->bssid, ether_bcast, ETH_ALEN);
623 params->bss_type = DOT11_BSSTYPE_ANY;
624 params->scan_type = 0;
625 params->nprobes = -1;
626 params->active_time = -1;
627 params->passive_time = -1;
628 params->home_time = -1;
629 params->channel_num = 0;
631 params->nprobes = cpu_to_le32(params->nprobes);
632 params->active_time = cpu_to_le32(params->active_time);
633 params->passive_time = cpu_to_le32(params->passive_time);
634 params->home_time = cpu_to_le32(params->home_time);
635 if (ssid && ssid->SSID_len)
636 memcpy(¶ms->ssid, ssid, sizeof(wlc_ssid_t));
641 wl_dev_iovar_setbuf(struct net_device *dev, s8 * iovar, void *param,
642 s32 paramlen, void *bufptr, s32 buflen)
646 iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
649 return wl_dev_ioctl(dev, WLC_SET_VAR, bufptr, iolen);
653 wl_dev_iovar_getbuf(struct net_device *dev, s8 * iovar, void *param,
654 s32 paramlen, void *bufptr, s32 buflen)
658 iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
661 return wl_dev_ioctl(dev, WLC_GET_VAR, bufptr, buflen);
665 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid, u16 action)
668 (WL_SCAN_PARAMS_FIXED_SIZE + offsetof(wl_iscan_params_t, params));
669 struct wl_iscan_params *params;
672 if (ssid && ssid->SSID_len)
673 params_size += sizeof(struct wlc_ssid);
674 params = kzalloc(params_size, GFP_KERNEL);
675 if (unlikely(!params))
677 BUG_ON(params_size >= WLC_IOCTL_SMLEN);
679 wl_iscan_prep(¶ms->params, ssid);
681 params->version = cpu_to_le32(ISCAN_REQ_VERSION);
682 params->action = cpu_to_le16(action);
683 params->scan_duration = cpu_to_le16(0);
685 /* params_size += offsetof(wl_iscan_params_t, params); */
686 err = wl_dev_iovar_setbuf(iscan->dev, "iscan", params, params_size,
687 iscan->ioctl_buf, WLC_IOCTL_SMLEN);
690 WL_INFO("system busy : iscan canceled\n");
692 WL_ERR("error (%d)\n", err);
699 static s32 wl_do_iscan(struct wl_priv *wl)
701 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
702 struct net_device *ndev = wl_to_ndev(wl);
703 struct wlc_ssid ssid;
707 /* Broadcast scan by default */
708 memset(&ssid, 0, sizeof(ssid));
710 iscan->state = WL_ISCAN_STATE_SCANING;
712 passive_scan = wl->active_scan ? 0 : 1;
713 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_SET_PASSIVE_SCAN,
714 &passive_scan, sizeof(passive_scan));
716 WL_ERR("error (%d)\n", err);
720 wl->iscan_kickstart = true;
721 wl_run_iscan(iscan, &ssid, WL_SCAN_ACTION_START);
722 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
729 __wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
730 struct cfg80211_scan_request *request,
731 struct cfg80211_ssid *this_ssid)
733 struct wl_priv *wl = ndev_to_wl(ndev);
734 struct cfg80211_ssid *ssids;
735 struct wl_scan_req *sr = wl_to_sr(wl);
741 if (unlikely(test_bit(WL_STATUS_SCANNING, &wl->status))) {
742 WL_ERR("Scanning already : status (%d)\n", (int)wl->status);
745 if (unlikely(test_bit(WL_STATUS_SCAN_ABORTING, &wl->status))) {
746 WL_ERR("Scanning being aborted : status (%d)\n",
750 if (test_bit(WL_STATUS_CONNECTING, &wl->status)) {
751 WL_ERR("Connecting : status (%d)\n",
760 ssids = request->ssids;
761 if (wl->iscan_on && (!ssids || !ssids->ssid_len))
765 /* we don't do iscan in ibss */
769 wl->scan_request = request;
770 set_bit(WL_STATUS_SCANNING, &wl->status);
772 err = wl_do_iscan(wl);
778 WL_SCAN("ssid \"%s\", ssid_len (%d)\n",
779 ssids->ssid, ssids->ssid_len);
780 memset(&sr->ssid, 0, sizeof(sr->ssid));
782 min_t(u8, sizeof(sr->ssid.SSID), ssids->ssid_len);
783 if (sr->ssid.SSID_len) {
784 memcpy(sr->ssid.SSID, ssids->ssid, sr->ssid.SSID_len);
785 sr->ssid.SSID_len = cpu_to_le32(sr->ssid.SSID_len);
788 WL_SCAN("Broadcast scan\n");
791 passive_scan = wl->active_scan ? 0 : 1;
792 err = wl_dev_ioctl(ndev, WLC_SET_PASSIVE_SCAN,
793 &passive_scan, sizeof(passive_scan));
795 WL_ERR("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
799 err = wl_dev_ioctl(ndev, WLC_SCAN, &sr->ssid,
803 WL_INFO("system busy : scan for \"%s\" canceled\n",
806 WL_ERR("WLC_SCAN error (%d)\n", err);
816 clear_bit(WL_STATUS_SCANNING, &wl->status);
817 wl->scan_request = NULL;
822 wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
823 struct cfg80211_scan_request *request)
831 err = __wl_cfg80211_scan(wiphy, ndev, request, NULL);
833 WL_ERR("scan error (%d)\n", err);
839 static s32 wl_dev_intvar_set(struct net_device *dev, s8 *name, s32 val)
841 s8 buf[WLC_IOCTL_SMLEN];
845 val = cpu_to_le32(val);
846 len = bcm_mkiovar(name, (char *)(&val), sizeof(val), buf, sizeof(buf));
849 err = wl_dev_ioctl(dev, WLC_SET_VAR, buf, len);
851 WL_ERR("error (%d)\n", err);
857 wl_dev_intvar_get(struct net_device *dev, s8 *name, s32 *retval)
860 s8 buf[WLC_IOCTL_SMLEN];
868 bcm_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
871 err = wl_dev_ioctl(dev, WLC_GET_VAR, &var, len);
873 WL_ERR("error (%d)\n", err);
875 *retval = le32_to_cpu(var.val);
880 static s32 wl_set_rts(struct net_device *dev, u32 rts_threshold)
884 err = wl_dev_intvar_set(dev, "rtsthresh", rts_threshold);
886 WL_ERR("Error (%d)\n", err);
891 static s32 wl_set_frag(struct net_device *dev, u32 frag_threshold)
895 err = wl_dev_intvar_set(dev, "fragthresh", frag_threshold);
897 WL_ERR("Error (%d)\n", err);
902 static s32 wl_set_retry(struct net_device *dev, u32 retry, bool l)
905 u32 cmd = (l ? WLC_SET_LRL : WLC_SET_SRL);
907 retry = cpu_to_le32(retry);
908 err = wl_dev_ioctl(dev, cmd, &retry, sizeof(retry));
910 WL_ERR("cmd (%d) , error (%d)\n", cmd, err);
916 static s32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
918 struct wl_priv *wl = wiphy_to_wl(wiphy);
919 struct net_device *ndev = wl_to_ndev(wl);
925 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
926 (wl->conf->rts_threshold != wiphy->rts_threshold)) {
927 wl->conf->rts_threshold = wiphy->rts_threshold;
928 err = wl_set_rts(ndev, wl->conf->rts_threshold);
932 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
933 (wl->conf->frag_threshold != wiphy->frag_threshold)) {
934 wl->conf->frag_threshold = wiphy->frag_threshold;
935 err = wl_set_frag(ndev, wl->conf->frag_threshold);
939 if (changed & WIPHY_PARAM_RETRY_LONG
940 && (wl->conf->retry_long != wiphy->retry_long)) {
941 wl->conf->retry_long = wiphy->retry_long;
942 err = wl_set_retry(ndev, wl->conf->retry_long, true);
946 if (changed & WIPHY_PARAM_RETRY_SHORT
947 && (wl->conf->retry_short != wiphy->retry_short)) {
948 wl->conf->retry_short = wiphy->retry_short;
949 err = wl_set_retry(ndev, wl->conf->retry_short, false);
960 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
961 struct cfg80211_ibss_params *params)
963 struct wl_priv *wl = wiphy_to_wl(wiphy);
964 struct wl_join_params join_params;
965 size_t join_params_size = 0;
974 WL_CONN("SSID: %s\n", params->ssid);
976 WL_CONN("SSID: NULL, Not supported\n");
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);
1093 set_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");
1387 ieee80211_frequency_to_channel(chan->center_freq);
1388 WL_CONN("channel (%d), center_req (%d)\n",
1389 wl->channel, chan->center_freq);
1393 WL_INFO("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1395 err = wl_set_wpa_version(dev, sme);
1399 err = wl_set_auth_type(dev, sme);
1403 err = wl_set_set_cipher(dev, sme);
1407 err = wl_set_key_mgmt(dev, sme);
1411 err = wl_set_set_sharedkey(dev, sme);
1415 wl_update_prof(wl, NULL, sme->bssid, WL_PROF_BSSID);
1417 ** Join with specific BSSID and cached SSID
1418 ** If SSID is zero join based on BSSID only
1420 memset(&join_params, 0, sizeof(join_params));
1421 join_params_size = sizeof(join_params.ssid);
1423 join_params.ssid.SSID_len = min(sizeof(join_params.ssid.SSID), sme->ssid_len);
1424 memcpy(&join_params.ssid.SSID, sme->ssid, join_params.ssid.SSID_len);
1425 join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1426 wl_update_prof(wl, NULL, &join_params.ssid, WL_PROF_SSID);
1429 memcpy(join_params.params.bssid, sme->bssid, ETH_ALEN);
1431 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1433 if (join_params.ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
1434 WL_CONN("ssid \"%s\", len (%d)\n",
1435 join_params.ssid.SSID, join_params.ssid.SSID_len);
1438 wl_ch_to_chanspec(wl->channel, &join_params, &join_params_size);
1439 err = wl_dev_ioctl(dev, WLC_SET_SSID, &join_params, join_params_size);
1440 if (unlikely(err)) {
1441 WL_ERR("error (%d)\n", err);
1444 set_bit(WL_STATUS_CONNECTING, &wl->status);
1451 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1454 struct wl_priv *wl = wiphy_to_wl(wiphy);
1458 WL_TRACE("Enter. Reason code = %d\n", reason_code);
1461 clear_bit(WL_STATUS_CONNECTED, &wl->status);
1463 scbval.val = reason_code;
1464 memcpy(&scbval.ea, wl_read_prof(wl, WL_PROF_BSSID), ETH_ALEN);
1465 scbval.val = cpu_to_le32(scbval.val);
1466 err = wl_dev_ioctl(dev, WLC_DISASSOC, &scbval,
1469 WL_ERR("error (%d)\n", err);
1471 wl->link_up = false;
1478 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
1479 enum nl80211_tx_power_setting type, s32 dbm)
1482 struct wl_priv *wl = wiphy_to_wl(wiphy);
1483 struct net_device *ndev = wl_to_ndev(wl);
1488 WL_TRACE("Enter\n");
1492 case NL80211_TX_POWER_AUTOMATIC:
1494 case NL80211_TX_POWER_LIMITED:
1496 WL_ERR("TX_POWER_LIMITED - dbm is negative\n");
1501 case NL80211_TX_POWER_FIXED:
1503 WL_ERR("TX_POWER_FIXED - dbm is negative\n");
1509 /* Make sure radio is off or on as far as software is concerned */
1510 disable = WL_RADIO_SW_DISABLE << 16;
1511 disable = cpu_to_le32(disable);
1512 err = wl_dev_ioctl(ndev, WLC_SET_RADIO, &disable, sizeof(disable));
1514 WL_ERR("WLC_SET_RADIO error (%d)\n", err);
1519 txpwrmw = (u16) dbm;
1520 err = wl_dev_intvar_set(ndev, "qtxpower",
1521 (s32) (bcm_mw_to_qdbm(txpwrmw)));
1523 WL_ERR("qtxpower error (%d)\n", err);
1524 wl->conf->tx_power = dbm;
1531 static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1533 struct wl_priv *wl = wiphy_to_wl(wiphy);
1534 struct net_device *ndev = wl_to_ndev(wl);
1539 WL_TRACE("Enter\n");
1542 err = wl_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1543 if (unlikely(err)) {
1544 WL_ERR("error (%d)\n", err);
1548 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1549 *dbm = (s32) bcm_qdbm_to_mw(result);
1557 wl_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
1558 u8 key_idx, bool unicast, bool multicast)
1564 WL_TRACE("Enter\n");
1565 WL_CONN("key index (%d)\n", key_idx);
1568 err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
1569 if (unlikely(err)) {
1570 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1574 wsec = le32_to_cpu(wsec);
1575 if (wsec & WEP_ENABLED) {
1576 /* Just select a new current key */
1577 index = (u32) key_idx;
1578 index = cpu_to_le32(index);
1579 err = wl_dev_ioctl(dev, WLC_SET_KEY_PRIMARY, &index,
1582 WL_ERR("error (%d)\n", err);
1590 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
1591 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1593 struct wl_wsec_key key;
1596 memset(&key, 0, sizeof(key));
1597 key.index = (u32) key_idx;
1598 /* Instead of bcast for ea address for default wep keys,
1599 driver needs it to be Null */
1600 if (!is_multicast_ether_addr(mac_addr))
1601 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1602 key.len = (u32) params->key_len;
1603 /* check for key index change */
1606 swap_key_from_BE(&key);
1607 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1608 if (unlikely(err)) {
1609 WL_ERR("key delete error (%d)\n", err);
1613 if (key.len > sizeof(key.data)) {
1614 WL_ERR("Invalid key length (%d)\n", key.len);
1618 WL_CONN("Setting the key index %d\n", key.index);
1619 memcpy(key.data, params->key, key.len);
1621 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1623 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1624 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1625 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1628 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1629 if (params->seq && params->seq_len == 6) {
1632 ivptr = (u8 *) params->seq;
1633 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1634 (ivptr[3] << 8) | ivptr[2];
1635 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1636 key.iv_initialized = true;
1639 switch (params->cipher) {
1640 case WLAN_CIPHER_SUITE_WEP40:
1641 key.algo = CRYPTO_ALGO_WEP1;
1642 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1644 case WLAN_CIPHER_SUITE_WEP104:
1645 key.algo = CRYPTO_ALGO_WEP128;
1646 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1648 case WLAN_CIPHER_SUITE_TKIP:
1649 key.algo = CRYPTO_ALGO_TKIP;
1650 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1652 case WLAN_CIPHER_SUITE_AES_CMAC:
1653 key.algo = CRYPTO_ALGO_AES_CCM;
1654 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1656 case WLAN_CIPHER_SUITE_CCMP:
1657 key.algo = CRYPTO_ALGO_AES_CCM;
1658 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1661 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1664 swap_key_from_BE(&key);
1666 dhd_wait_pend8021x(dev);
1667 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1668 if (unlikely(err)) {
1669 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1677 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
1678 u8 key_idx, bool pairwise, const u8 *mac_addr,
1679 struct key_params *params)
1681 struct wl_wsec_key key;
1687 WL_TRACE("Enter\n");
1688 WL_CONN("key index (%d)\n", key_idx);
1693 return wl_add_keyext(wiphy, dev, key_idx, mac_addr, params);
1695 memset(&key, 0, sizeof(key));
1697 key.len = (u32) params->key_len;
1698 key.index = (u32) key_idx;
1700 if (unlikely(key.len > sizeof(key.data))) {
1701 WL_ERR("Too long key length (%u)\n", key.len);
1705 memcpy(key.data, params->key, key.len);
1707 key.flags = WL_PRIMARY_KEY;
1708 switch (params->cipher) {
1709 case WLAN_CIPHER_SUITE_WEP40:
1710 key.algo = CRYPTO_ALGO_WEP1;
1711 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1713 case WLAN_CIPHER_SUITE_WEP104:
1714 key.algo = CRYPTO_ALGO_WEP128;
1715 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1717 case WLAN_CIPHER_SUITE_TKIP:
1718 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1719 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1720 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1721 key.algo = CRYPTO_ALGO_TKIP;
1722 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1724 case WLAN_CIPHER_SUITE_AES_CMAC:
1725 key.algo = CRYPTO_ALGO_AES_CCM;
1726 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1728 case WLAN_CIPHER_SUITE_CCMP:
1729 key.algo = CRYPTO_ALGO_AES_CCM;
1730 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1733 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1738 /* Set the new key/index */
1739 swap_key_from_BE(&key);
1740 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1741 if (unlikely(err)) {
1742 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1747 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1748 if (unlikely(err)) {
1749 WL_ERR("get wsec error (%d)\n", err);
1752 wsec &= ~(WEP_ENABLED);
1754 err = wl_dev_intvar_set(dev, "wsec", wsec);
1755 if (unlikely(err)) {
1756 WL_ERR("set wsec error (%d)\n", err);
1760 val = 1; /* assume shared key. otherwise 0 */
1761 val = cpu_to_le32(val);
1762 err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
1764 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1771 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
1772 u8 key_idx, bool pairwise, const u8 *mac_addr)
1774 struct wl_wsec_key key;
1779 WL_TRACE("Enter\n");
1781 memset(&key, 0, sizeof(key));
1783 key.index = (u32) key_idx;
1784 key.flags = WL_PRIMARY_KEY;
1785 key.algo = CRYPTO_ALGO_OFF;
1787 WL_CONN("key index (%d)\n", key_idx);
1788 /* Set the new key/index */
1789 swap_key_from_BE(&key);
1790 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1791 if (unlikely(err)) {
1792 if (err == -EINVAL) {
1793 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
1794 /* we ignore this key index in this case */
1795 WL_ERR("invalid key index (%d)\n", key_idx);
1797 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1799 /* Ignore this error, may happen during DISASSOC */
1805 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1806 if (unlikely(err)) {
1807 WL_ERR("get wsec error (%d)\n", err);
1808 /* Ignore this error, may happen during DISASSOC */
1812 wsec &= ~(WEP_ENABLED);
1814 err = wl_dev_intvar_set(dev, "wsec", wsec);
1815 if (unlikely(err)) {
1816 WL_ERR("set wsec error (%d)\n", err);
1817 /* Ignore this error, may happen during DISASSOC */
1822 val = 0; /* assume open key. otherwise 1 */
1823 val = cpu_to_le32(val);
1824 err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
1825 if (unlikely(err)) {
1826 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1827 /* Ignore this error, may happen during DISASSOC */
1836 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
1837 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
1838 void (*callback) (void *cookie, struct key_params * params))
1840 struct key_params params;
1841 struct wl_wsec_key key;
1842 struct wl_priv *wl = wiphy_to_wl(wiphy);
1843 struct wl_security *sec;
1847 WL_TRACE("Enter\n");
1848 WL_CONN("key index (%d)\n", key_idx);
1851 memset(&key, 0, sizeof(key));
1852 key.index = key_idx;
1853 swap_key_to_BE(&key);
1854 memset(¶ms, 0, sizeof(params));
1855 params.key_len = (u8) min_t(u8, WLAN_MAX_KEY_LEN, key.len);
1856 memcpy(params.key, key.data, params.key_len);
1858 err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
1859 if (unlikely(err)) {
1860 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1861 /* Ignore this error, may happen during DISASSOC */
1865 wsec = le32_to_cpu(wsec);
1868 sec = wl_read_prof(wl, WL_PROF_SEC);
1869 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1870 params.cipher = WLAN_CIPHER_SUITE_WEP40;
1871 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1872 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1873 params.cipher = WLAN_CIPHER_SUITE_WEP104;
1874 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1878 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1879 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1882 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1883 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1886 WL_ERR("Invalid algo (0x%x)\n", wsec);
1890 callback(cookie, ¶ms);
1898 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1899 struct net_device *dev, u8 key_idx)
1901 WL_INFO("Not supported\n");
1908 wl_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
1909 u8 *mac, struct station_info *sinfo)
1911 struct wl_priv *wl = wiphy_to_wl(wiphy);
1916 u8 *bssid = wl_read_prof(wl, WL_PROF_BSSID);
1918 WL_TRACE("Enter\n");
1922 (memcmp(mac, bssid, ETH_ALEN))) {
1923 WL_ERR("Wrong Mac address cfg_mac-%X:%X:%X:%X:%X:%X"
1924 "wl_bssid-%X:%X:%X:%X:%X:%X\n",
1925 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
1926 bssid[0], bssid[1], bssid[2], bssid[3],
1927 bssid[4], bssid[5]);
1932 /* Report the current tx rate */
1933 err = wl_dev_ioctl(dev, WLC_GET_RATE, &rate, sizeof(rate));
1935 WL_ERR("Could not get rate (%d)\n", err);
1937 rate = le32_to_cpu(rate);
1938 sinfo->filled |= STATION_INFO_TX_BITRATE;
1939 sinfo->txrate.legacy = rate * 5;
1940 WL_CONN("Rate %d Mbps\n", rate / 2);
1943 if (test_bit(WL_STATUS_CONNECTED, &wl->status)) {
1945 err = wl_dev_ioctl(dev, WLC_GET_RSSI, &scb_val,
1947 if (unlikely(err)) {
1948 WL_ERR("Could not get rssi (%d)\n", err);
1950 rssi = le32_to_cpu(scb_val.val);
1951 sinfo->filled |= STATION_INFO_SIGNAL;
1952 sinfo->signal = rssi;
1953 WL_CONN("RSSI %d dBm\n", rssi);
1962 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1963 bool enabled, s32 timeout)
1968 WL_TRACE("Enter\n");
1971 pm = enabled ? PM_FAST : PM_OFF;
1972 pm = cpu_to_le32(pm);
1973 WL_INFO("power save %s\n", (pm ? "enabled" : "disabled"));
1975 err = wl_dev_ioctl(dev, WLC_SET_PM, &pm, sizeof(pm));
1976 if (unlikely(err)) {
1978 WL_ERR("net_device is not ready yet\n");
1980 WL_ERR("error (%d)\n", err);
1986 static __used u32 wl_find_msb(u16 bit16)
1990 if (bit16 & 0xff00) {
2014 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
2016 const struct cfg80211_bitrate_mask *mask)
2018 struct wl_rateset rateset;
2026 WL_TRACE("Enter\n");
2029 /* addr param is always NULL. ignore it */
2030 /* Get current rateset */
2031 err = wl_dev_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
2033 if (unlikely(err)) {
2034 WL_ERR("could not get current rateset (%d)\n", err);
2038 rateset.count = le32_to_cpu(rateset.count);
2040 legacy = wl_find_msb(mask->control[IEEE80211_BAND_2GHZ].legacy);
2042 legacy = wl_find_msb(mask->control[IEEE80211_BAND_5GHZ].legacy);
2044 val = wl_g_rates[legacy - 1].bitrate * 100000;
2046 if (val < rateset.count)
2047 /* Select rate by rateset index */
2048 rate = rateset.rates[val] & 0x7f;
2050 /* Specified rate in bps */
2051 rate = val / 500000;
2053 WL_CONN("rate %d mbps\n", rate / 2);
2057 * Set rate override,
2058 * Since the is a/b/g-blind, both a/bg_rate are enforced.
2060 err_bg = wl_dev_intvar_set(dev, "bg_rate", rate);
2061 err_a = wl_dev_intvar_set(dev, "a_rate", rate);
2062 if (unlikely(err_bg && err_a)) {
2063 WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
2064 err = err_bg | err_a;
2072 static s32 wl_cfg80211_resume(struct wiphy *wiphy)
2074 struct wl_priv *wl = wiphy_to_wl(wiphy);
2075 struct net_device *ndev = wl_to_ndev(wl);
2078 * Check for WL_STATUS_READY before any function call which
2079 * could result is bus access. Don't block the resume for
2080 * any driver error conditions
2082 WL_TRACE("Enter\n");
2084 #if defined(CONFIG_PM_SLEEP)
2085 atomic_set(&dhd_mmc_suspend, false);
2086 #endif /* defined(CONFIG_PM_SLEEP) */
2088 if (test_bit(WL_STATUS_READY, &wl->status)) {
2089 /* Turn on Watchdog timer */
2090 wl_os_wd_timer(ndev, dhd_watchdog_ms);
2091 wl_invoke_iscan(wiphy_to_wl(wiphy));
2098 static s32 wl_cfg80211_suspend(struct wiphy *wiphy)
2100 struct wl_priv *wl = wiphy_to_wl(wiphy);
2101 struct net_device *ndev = wl_to_ndev(wl);
2103 WL_TRACE("Enter\n");
2106 * Check for WL_STATUS_READY before any function call which
2107 * could result is bus access. Don't block the suspend for
2108 * any driver error conditions
2112 * While going to suspend if associated with AP disassociate
2113 * from AP to save power while system is in suspended state
2115 if (test_bit(WL_STATUS_CONNECTED, &wl->status) &&
2116 test_bit(WL_STATUS_READY, &wl->status)) {
2117 WL_INFO("Disassociating from AP"
2118 " while entering suspend state\n");
2122 * Make sure WPA_Supplicant receives all the event
2123 * generated due to DISASSOC call to the fw to keep
2124 * the state fw and WPA_Supplicant state consistent
2131 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
2132 if (test_bit(WL_STATUS_READY, &wl->status))
2135 if (wl->scan_request) {
2136 /* Indidate scan abort to cfg80211 layer */
2137 WL_INFO("Terminating scan in progress\n");
2138 cfg80211_scan_done(wl->scan_request, true);
2139 wl->scan_request = NULL;
2141 clear_bit(WL_STATUS_SCANNING, &wl->status);
2142 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
2143 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2144 clear_bit(WL_STATUS_CONNECTED, &wl->status);
2146 /* Inform SDIO stack not to switch off power to the chip */
2147 sdioh_sdio_set_host_pm_flags(MMC_PM_KEEP_POWER);
2149 /* Turn off watchdog timer */
2150 if (test_bit(WL_STATUS_READY, &wl->status)) {
2151 WL_INFO("Terminate watchdog timer and enable MPC\n");
2152 wl_set_mpc(ndev, 1);
2153 wl_os_wd_timer(ndev, 0);
2156 #if defined(CONFIG_PM_SLEEP)
2157 atomic_set(&dhd_mmc_suspend, true);
2158 #endif /* defined(CONFIG_PM_SLEEP) */
2166 wl_update_pmklist(struct net_device *dev, struct wl_pmk_list *pmk_list,
2171 WL_CONN("No of elements %d\n", pmk_list->pmkids.npmkid);
2172 for (i = 0; i < pmk_list->pmkids.npmkid; i++) {
2173 WL_CONN("PMKID[%d]: %pM =\n", i,
2174 &pmk_list->pmkids.pmkid[i].BSSID);
2175 for (j = 0; j < WLAN_PMKID_LEN; j++)
2176 WL_CONN("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
2180 wl_dev_bufvar_set(dev, "pmkid_info", (char *)pmk_list,
2187 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
2188 struct cfg80211_pmksa *pmksa)
2190 struct wl_priv *wl = wiphy_to_wl(wiphy);
2194 WL_TRACE("Enter\n");
2197 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2198 if (!memcmp(pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2201 if (i < WL_NUM_PMKIDS_MAX) {
2202 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID, pmksa->bssid,
2204 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID, pmksa->pmkid,
2206 if (i == wl->pmk_list->pmkids.npmkid)
2207 wl->pmk_list->pmkids.npmkid++;
2211 WL_CONN("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
2212 &wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].BSSID);
2213 for (i = 0; i < WLAN_PMKID_LEN; i++)
2215 wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].
2218 err = wl_update_pmklist(dev, wl->pmk_list, err);
2225 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
2226 struct cfg80211_pmksa *pmksa)
2228 struct wl_priv *wl = wiphy_to_wl(wiphy);
2229 struct _pmkid_list pmkid;
2233 WL_TRACE("Enter\n");
2235 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2236 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2238 WL_CONN("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2239 &pmkid.pmkid[0].BSSID);
2240 for (i = 0; i < WLAN_PMKID_LEN; i++)
2241 WL_CONN("%02x\n", pmkid.pmkid[0].PMKID[i]);
2243 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2245 (pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2249 if ((wl->pmk_list->pmkids.npmkid > 0)
2250 && (i < wl->pmk_list->pmkids.npmkid)) {
2251 memset(&wl->pmk_list->pmkids.pmkid[i], 0, sizeof(pmkid_t));
2252 for (; i < (wl->pmk_list->pmkids.npmkid - 1); i++) {
2253 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID,
2254 &wl->pmk_list->pmkids.pmkid[i + 1].BSSID,
2256 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID,
2257 &wl->pmk_list->pmkids.pmkid[i + 1].PMKID,
2260 wl->pmk_list->pmkids.npmkid--;
2264 err = wl_update_pmklist(dev, wl->pmk_list, err);
2272 wl_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *dev)
2274 struct wl_priv *wl = wiphy_to_wl(wiphy);
2277 WL_TRACE("Enter\n");
2280 memset(wl->pmk_list, 0, sizeof(*wl->pmk_list));
2281 err = wl_update_pmklist(dev, wl->pmk_list, err);
2288 static struct cfg80211_ops wl_cfg80211_ops = {
2289 .change_virtual_intf = wl_cfg80211_change_iface,
2290 .scan = wl_cfg80211_scan,
2291 .set_wiphy_params = wl_cfg80211_set_wiphy_params,
2292 .join_ibss = wl_cfg80211_join_ibss,
2293 .leave_ibss = wl_cfg80211_leave_ibss,
2294 .get_station = wl_cfg80211_get_station,
2295 .set_tx_power = wl_cfg80211_set_tx_power,
2296 .get_tx_power = wl_cfg80211_get_tx_power,
2297 .add_key = wl_cfg80211_add_key,
2298 .del_key = wl_cfg80211_del_key,
2299 .get_key = wl_cfg80211_get_key,
2300 .set_default_key = wl_cfg80211_config_default_key,
2301 .set_default_mgmt_key = wl_cfg80211_config_default_mgmt_key,
2302 .set_power_mgmt = wl_cfg80211_set_power_mgmt,
2303 .set_bitrate_mask = wl_cfg80211_set_bitrate_mask,
2304 .connect = wl_cfg80211_connect,
2305 .disconnect = wl_cfg80211_disconnect,
2306 .suspend = wl_cfg80211_suspend,
2307 .resume = wl_cfg80211_resume,
2308 .set_pmksa = wl_cfg80211_set_pmksa,
2309 .del_pmksa = wl_cfg80211_del_pmksa,
2310 .flush_pmksa = wl_cfg80211_flush_pmksa
2313 static s32 wl_mode_to_nl80211_iftype(s32 mode)
2319 return NL80211_IFTYPE_STATION;
2321 return NL80211_IFTYPE_ADHOC;
2323 return NL80211_IFTYPE_UNSPECIFIED;
2329 static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
2332 struct wireless_dev *wdev;
2335 wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2336 if (unlikely(!wdev)) {
2337 WL_ERR("Could not allocate wireless device\n");
2338 return ERR_PTR(-ENOMEM);
2341 wiphy_new(&wl_cfg80211_ops, sizeof(struct wl_priv) + sizeof_iface);
2342 if (unlikely(!wdev->wiphy)) {
2343 WL_ERR("Couldn not allocate wiphy device\n");
2347 set_wiphy_dev(wdev->wiphy, dev);
2348 wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2349 wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2350 wdev->wiphy->interface_modes =
2351 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2352 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2353 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a; /* Set
2354 * it as 11a by default.
2355 * This will be updated with
2358 * if phy has 11n capability
2360 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2361 wdev->wiphy->cipher_suites = __wl_cipher_suites;
2362 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2363 #ifndef WL_POWERSAVE_DISABLED
2364 wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; /* enable power
2369 wdev->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
2370 #endif /* !WL_POWERSAVE_DISABLED */
2371 err = wiphy_register(wdev->wiphy);
2372 if (unlikely(err < 0)) {
2373 WL_ERR("Couldn not register wiphy device (%d)\n", err);
2374 goto wiphy_register_out;
2379 wiphy_free(wdev->wiphy);
2384 return ERR_PTR(err);
2387 static void wl_free_wdev(struct wl_priv *wl)
2389 struct wireless_dev *wdev = wl_to_wdev(wl);
2391 if (unlikely(!wdev)) {
2392 WL_ERR("wdev is invalid\n");
2395 wiphy_unregister(wdev->wiphy);
2396 wiphy_free(wdev->wiphy);
2398 wl_to_wdev(wl) = NULL;
2401 static s32 wl_inform_bss(struct wl_priv *wl)
2403 struct wl_scan_results *bss_list;
2404 struct wl_bss_info *bi = NULL; /* must be initialized */
2408 bss_list = wl->bss_list;
2409 if (unlikely(bss_list->version != WL_BSS_INFO_VERSION)) {
2410 WL_ERR("Version %d != WL_BSS_INFO_VERSION\n",
2414 WL_SCAN("scanned AP count (%d)\n", bss_list->count);
2415 bi = next_bss(bss_list, bi);
2416 for_each_bss(bss_list, bi, i) {
2417 err = wl_inform_single_bss(wl, bi);
2425 static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
2427 struct wiphy *wiphy = wl_to_wiphy(wl);
2428 struct ieee80211_channel *notify_channel;
2429 struct cfg80211_bss *bss;
2430 struct ieee80211_supported_band *band;
2434 u64 notify_timestamp;
2435 u16 notify_capability;
2436 u16 notify_interval;
2438 size_t notify_ielen;
2441 if (unlikely(le32_to_cpu(bi->length) > WL_BSS_INFO_MAX)) {
2442 WL_ERR("Bss info is larger than buffer. Discarding\n");
2446 channel = bi->ctl_ch ? bi->ctl_ch :
2447 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2449 if (channel <= CH_MAX_2G_CHANNEL)
2450 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2452 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2454 freq = ieee80211_channel_to_frequency(channel, band->band);
2455 notify_channel = ieee80211_get_channel(wiphy, freq);
2457 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2458 notify_capability = le16_to_cpu(bi->capability);
2459 notify_interval = le16_to_cpu(bi->beacon_period);
2460 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2461 notify_ielen = le16_to_cpu(bi->ie_length);
2462 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2464 WL_CONN("bssid: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2465 bi->BSSID[0], bi->BSSID[1], bi->BSSID[2],
2466 bi->BSSID[3], bi->BSSID[4], bi->BSSID[5]);
2467 WL_CONN("Channel: %d(%d)\n", channel, freq);
2468 WL_CONN("Capability: %X\n", notify_capability);
2469 WL_CONN("Beacon interval: %d\n", notify_interval);
2470 WL_CONN("Signal: %d\n", notify_signal);
2471 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2473 bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
2474 notify_timestamp, notify_capability, notify_interval, notify_ie,
2475 notify_ielen, notify_signal, GFP_KERNEL);
2477 if (unlikely(!bss)) {
2478 WL_ERR("cfg80211_inform_bss_frame error\n");
2486 wl_inform_ibss(struct wl_priv *wl, struct net_device *dev, const u8 *bssid)
2488 struct wiphy *wiphy = wl_to_wiphy(wl);
2489 struct ieee80211_channel *notify_channel;
2490 struct wl_bss_info *bi = NULL;
2491 struct ieee80211_supported_band *band;
2496 u64 notify_timestamp;
2497 u16 notify_capability;
2498 u16 notify_interval;
2500 size_t notify_ielen;
2503 WL_TRACE("Enter\n");
2505 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2507 WL_ERR("kzalloc() failed\n");
2512 *(u32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2514 err = wl_dev_ioctl(dev, WLC_GET_BSS_INFO, buf, WL_BSS_INFO_MAX);
2515 if (unlikely(err)) {
2516 WL_ERR("WLC_GET_BSS_INFO failed: %d\n", err);
2520 bi = (wl_bss_info_t *)(buf + 4);
2522 channel = bi->ctl_ch ? bi->ctl_ch :
2523 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2525 if (channel <= CH_MAX_2G_CHANNEL)
2526 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2528 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2530 freq = ieee80211_channel_to_frequency(channel, band->band);
2531 notify_channel = ieee80211_get_channel(wiphy, freq);
2533 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2534 notify_capability = le16_to_cpu(bi->capability);
2535 notify_interval = le16_to_cpu(bi->beacon_period);
2536 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2537 notify_ielen = le16_to_cpu(bi->ie_length);
2538 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2540 WL_CONN("channel: %d(%d)\n", channel, freq);
2541 WL_CONN("capability: %X\n", notify_capability);
2542 WL_CONN("beacon interval: %d\n", notify_interval);
2543 WL_CONN("signal: %d\n", notify_signal);
2544 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2546 cfg80211_inform_bss(wiphy, notify_channel, bssid,
2547 notify_timestamp, notify_capability, notify_interval,
2548 notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
2559 static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e)
2561 u32 event = be32_to_cpu(e->event_type);
2562 u32 status = be32_to_cpu(e->status);
2564 if (event == WLC_E_SET_SSID && status == WLC_E_STATUS_SUCCESS) {
2565 WL_CONN("Processing set ssid\n");
2573 static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e)
2575 u32 event = be32_to_cpu(e->event_type);
2576 u16 flags = be16_to_cpu(e->flags);
2578 if (event == WLC_E_LINK && (!(flags & WLC_EVENT_MSG_LINK))) {
2579 WL_CONN("Processing link down\n");
2585 static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e)
2587 u32 event = be32_to_cpu(e->event_type);
2588 u32 status = be32_to_cpu(e->status);
2589 u16 flags = be16_to_cpu(e->flags);
2591 if (event == WLC_E_LINK && status == WLC_E_STATUS_NO_NETWORKS) {
2592 WL_CONN("Processing Link %s & no network found\n",
2593 flags & WLC_EVENT_MSG_LINK ? "up" : "down");
2597 if (event == WLC_E_SET_SSID && status != WLC_E_STATUS_SUCCESS) {
2598 WL_CONN("Processing connecting & no network found\n");
2606 wl_notify_connect_status(struct wl_priv *wl, struct net_device *ndev,
2607 const wl_event_msg_t *e, void *data)
2611 if (wl_is_linkup(wl, e)) {
2612 WL_CONN("Linkup\n");
2613 if (wl_is_ibssmode(wl)) {
2614 wl_update_prof(wl, NULL, (void *)e->addr,
2616 wl_inform_ibss(wl, ndev, e->addr);
2617 cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
2618 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2619 set_bit(WL_STATUS_CONNECTED, &wl->status);
2621 wl_bss_connect_done(wl, ndev, e, data, true);
2622 } else if (wl_is_linkdown(wl, e)) {
2623 WL_CONN("Linkdown\n");
2624 if (wl_is_ibssmode(wl)) {
2625 if (test_and_clear_bit(WL_STATUS_CONNECTED,
2629 if (test_and_clear_bit(WL_STATUS_CONNECTED,
2631 cfg80211_disconnected(ndev, 0, NULL, 0,
2636 wl_init_prof(wl->profile);
2637 } else if (wl_is_nonetwork(wl, e)) {
2638 if (wl_is_ibssmode(wl))
2639 clear_bit(WL_STATUS_CONNECTING, &wl->status);
2641 wl_bss_connect_done(wl, ndev, e, data, false);
2648 wl_notify_roaming_status(struct wl_priv *wl, struct net_device *ndev,
2649 const wl_event_msg_t *e, void *data)
2652 u32 event = be32_to_cpu(e->event_type);
2653 u32 status = be32_to_cpu(e->status);
2655 if (event == WLC_E_ROAM && status == WLC_E_STATUS_SUCCESS) {
2656 if (test_bit(WL_STATUS_CONNECTED, &wl->status))
2657 wl_bss_roaming_done(wl, ndev, e, data);
2659 wl_bss_connect_done(wl, ndev, e, data, true);
2666 wl_dev_bufvar_set(struct net_device *dev, s8 *name, s8 *buf, s32 len)
2668 struct wl_priv *wl = ndev_to_wl(dev);
2671 buflen = bcm_mkiovar(name, buf, len, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2674 return wl_dev_ioctl(dev, WLC_SET_VAR, wl->ioctl_buf, buflen);
2678 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
2681 struct wl_priv *wl = ndev_to_wl(dev);
2685 len = bcm_mkiovar(name, NULL, 0, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2687 err = wl_dev_ioctl(dev, WLC_GET_VAR, (void *)wl->ioctl_buf,
2689 if (unlikely(err)) {
2690 WL_ERR("error (%d)\n", err);
2693 memcpy(buf, wl->ioctl_buf, buf_len);
2698 static s32 wl_get_assoc_ies(struct wl_priv *wl)
2700 struct net_device *ndev = wl_to_ndev(wl);
2701 struct wl_assoc_ielen *assoc_info;
2702 struct wl_connect_info *conn_info = wl_to_conn(wl);
2707 wl_clear_assoc_ies(wl);
2709 err = wl_dev_bufvar_get(ndev, "assoc_info", wl->extra_buf,
2711 if (unlikely(err)) {
2712 WL_ERR("could not get assoc info (%d)\n", err);
2715 assoc_info = (struct wl_assoc_ielen *)wl->extra_buf;
2716 req_len = assoc_info->req_len;
2717 resp_len = assoc_info->resp_len;
2719 err = wl_dev_bufvar_get(ndev, "assoc_req_ies", wl->extra_buf,
2721 if (unlikely(err)) {
2722 WL_ERR("could not get assoc req (%d)\n", err);
2725 conn_info->req_ie_len = req_len;
2727 kmemdup(wl->extra_buf, conn_info->req_ie_len, GFP_KERNEL);
2729 conn_info->req_ie_len = 0;
2730 conn_info->req_ie = NULL;
2733 err = wl_dev_bufvar_get(ndev, "assoc_resp_ies", wl->extra_buf,
2735 if (unlikely(err)) {
2736 WL_ERR("could not get assoc resp (%d)\n", err);
2739 conn_info->resp_ie_len = resp_len;
2740 conn_info->resp_ie =
2741 kmemdup(wl->extra_buf, conn_info->resp_ie_len, GFP_KERNEL);
2743 conn_info->resp_ie_len = 0;
2744 conn_info->resp_ie = NULL;
2746 WL_CONN("req len (%d) resp len (%d)\n",
2747 conn_info->req_ie_len, conn_info->resp_ie_len);
2752 static void wl_clear_assoc_ies(struct wl_priv *wl)
2754 struct wl_connect_info *conn_info = wl_to_conn(wl);
2756 kfree(conn_info->req_ie);
2757 conn_info->req_ie = NULL;
2758 conn_info->req_ie_len = 0;
2759 kfree(conn_info->resp_ie);
2760 conn_info->resp_ie = NULL;
2761 conn_info->resp_ie_len = 0;
2765 static void wl_ch_to_chanspec(int ch, struct wl_join_params *join_params,
2766 size_t *join_params_size)
2768 chanspec_t chanspec = 0;
2771 join_params->params.chanspec_num = 1;
2772 join_params->params.chanspec_list[0] = ch;
2774 if (join_params->params.chanspec_list[0] <= CH_MAX_2G_CHANNEL)
2775 chanspec |= WL_CHANSPEC_BAND_2G;
2777 chanspec |= WL_CHANSPEC_BAND_5G;
2779 chanspec |= WL_CHANSPEC_BW_20;
2780 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
2782 *join_params_size += WL_ASSOC_PARAMS_FIXED_SIZE +
2783 join_params->params.chanspec_num * sizeof(chanspec_t);
2785 join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
2786 join_params->params.chanspec_list[0] |= chanspec;
2787 join_params->params.chanspec_list[0] =
2788 cpu_to_le16(join_params->params.chanspec_list[0]);
2790 join_params->params.chanspec_num =
2791 cpu_to_le32(join_params->params.chanspec_num);
2793 WL_CONN("join_params->params.chanspec_list[0]= %#X,"
2794 "channel %d, chanspec %#X\n",
2795 join_params->params.chanspec_list[0], ch, chanspec);
2799 static s32 wl_update_bss_info(struct wl_priv *wl)
2801 struct wl_bss_info *bi;
2802 struct wlc_ssid *ssid;
2803 struct bcm_tlv *tim;
2804 u16 beacon_interval;
2810 WL_TRACE("Enter\n");
2811 if (wl_is_ibssmode(wl))
2814 ssid = (struct wlc_ssid *)wl_read_prof(wl, WL_PROF_SSID);
2816 *(u32 *)wl->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2817 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_BSS_INFO,
2818 wl->extra_buf, WL_EXTRA_BUF_MAX);
2819 if (unlikely(err)) {
2820 WL_ERR("Could not get bss info %d\n", err);
2821 goto update_bss_info_out;
2824 bi = (struct wl_bss_info *)(wl->extra_buf + 4);
2825 err = wl_inform_single_bss(wl, bi);
2827 goto update_bss_info_out;
2829 ie = ((u8 *)bi) + bi->ie_offset;
2830 ie_len = bi->ie_length;
2831 beacon_interval = cpu_to_le16(bi->beacon_period);
2833 tim = bcm_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2835 dtim_period = tim->data[1];
2838 * active scan was done so we could not get dtim
2839 * information out of probe response.
2840 * so we speficially query dtim information to dongle.
2843 err = wl_dev_intvar_get(wl_to_ndev(wl), "dtim_assoc", &var);
2844 if (unlikely(err)) {
2845 WL_ERR("wl dtim_assoc failed (%d)\n", err);
2846 goto update_bss_info_out;
2848 dtim_period = (u8)var;
2851 wl_update_prof(wl, NULL, &beacon_interval, WL_PROF_BEACONINT);
2852 wl_update_prof(wl, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
2854 update_bss_info_out:
2860 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
2861 const wl_event_msg_t *e, void *data)
2863 struct wl_connect_info *conn_info = wl_to_conn(wl);
2866 WL_TRACE("Enter\n");
2868 wl_get_assoc_ies(wl);
2869 wl_update_prof(wl, NULL, &e->addr, WL_PROF_BSSID);
2870 wl_update_bss_info(wl);
2872 cfg80211_roamed(ndev,
2873 (u8 *)wl_read_prof(wl, WL_PROF_BSSID),
2874 conn_info->req_ie, conn_info->req_ie_len,
2875 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
2876 WL_CONN("Report roaming result\n");
2878 set_bit(WL_STATUS_CONNECTED, &wl->status);
2884 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
2885 const wl_event_msg_t *e, void *data, bool completed)
2887 struct wl_connect_info *conn_info = wl_to_conn(wl);
2890 WL_TRACE("Enter\n");
2892 if (test_and_clear_bit(WL_STATUS_CONNECTING, &wl->status)) {
2894 wl_get_assoc_ies(wl);
2895 wl_update_prof(wl, NULL, &e->addr, WL_PROF_BSSID);
2896 wl_update_bss_info(wl);
2898 cfg80211_connect_result(ndev,
2899 (u8 *)wl_read_prof(wl, WL_PROF_BSSID),
2901 conn_info->req_ie_len,
2903 conn_info->resp_ie_len,
2904 completed ? WLAN_STATUS_SUCCESS : WLAN_STATUS_AUTH_TIMEOUT,
2907 set_bit(WL_STATUS_CONNECTED, &wl->status);
2908 WL_CONN("Report connect result - connection %s\n",
2909 completed ? "succeeded" : "failed");
2916 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
2917 const wl_event_msg_t *e, void *data)
2919 u16 flags = be16_to_cpu(e->flags);
2920 enum nl80211_key_type key_type;
2923 if (flags & WLC_EVENT_MSG_GROUP)
2924 key_type = NL80211_KEYTYPE_GROUP;
2926 key_type = NL80211_KEYTYPE_PAIRWISE;
2928 cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
2936 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
2937 const wl_event_msg_t *e, void *data)
2939 struct channel_info channel_inform;
2940 struct wl_scan_results *bss_list;
2941 u32 len = WL_SCAN_BUF_MAX;
2943 bool scan_abort = false;
2945 WL_TRACE("Enter\n");
2947 if (wl->iscan_on && wl->iscan_kickstart) {
2949 return wl_wakeup_iscan(wl_to_iscan(wl));
2952 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
2953 WL_ERR("Scan complete while device not scanning\n");
2959 err = wl_dev_ioctl(ndev, WLC_GET_CHANNEL, &channel_inform,
2960 sizeof(channel_inform));
2961 if (unlikely(err)) {
2962 WL_ERR("scan busy (%d)\n", err);
2966 channel_inform.scan_channel = le32_to_cpu(channel_inform.scan_channel);
2967 if (unlikely(channel_inform.scan_channel)) {
2969 WL_CONN("channel_inform.scan_channel (%d)\n",
2970 channel_inform.scan_channel);
2972 wl->bss_list = wl->scan_results;
2973 bss_list = wl->bss_list;
2974 memset(bss_list, 0, len);
2975 bss_list->buflen = cpu_to_le32(len);
2977 err = wl_dev_ioctl(ndev, WLC_SCAN_RESULTS, bss_list, len);
2978 if (unlikely(err)) {
2979 WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
2984 bss_list->buflen = le32_to_cpu(bss_list->buflen);
2985 bss_list->version = le32_to_cpu(bss_list->version);
2986 bss_list->count = le32_to_cpu(bss_list->count);
2988 err = wl_inform_bss(wl);
2995 if (wl->scan_request) {
2996 WL_SCAN("calling cfg80211_scan_done\n");
2997 cfg80211_scan_done(wl->scan_request, scan_abort);
2998 wl_set_mpc(ndev, 1);
2999 wl->scan_request = NULL;
3007 static void wl_init_conf(struct wl_conf *conf)
3009 conf->mode = (u32)-1;
3010 conf->frag_threshold = (u32)-1;
3011 conf->rts_threshold = (u32)-1;
3012 conf->retry_short = (u32)-1;
3013 conf->retry_long = (u32)-1;
3014 conf->tx_power = -1;
3017 static void wl_init_prof(struct wl_profile *prof)
3019 memset(prof, 0, sizeof(*prof));
3022 static void wl_init_eloop_handler(struct wl_event_loop *el)
3024 memset(el, 0, sizeof(*el));
3025 el->handler[WLC_E_SCAN_COMPLETE] = wl_notify_scan_status;
3026 el->handler[WLC_E_LINK] = wl_notify_connect_status;
3027 el->handler[WLC_E_ROAM] = wl_notify_roaming_status;
3028 el->handler[WLC_E_MIC_ERROR] = wl_notify_mic_status;
3029 el->handler[WLC_E_SET_SSID] = wl_notify_connect_status;
3032 static s32 wl_init_priv_mem(struct wl_priv *wl)
3034 wl->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
3035 if (unlikely(!wl->scan_results)) {
3036 WL_ERR("Scan results alloc failed\n");
3037 goto init_priv_mem_out;
3039 wl->conf = kzalloc(sizeof(*wl->conf), GFP_KERNEL);
3040 if (unlikely(!wl->conf)) {
3041 WL_ERR("wl_conf alloc failed\n");
3042 goto init_priv_mem_out;
3044 wl->profile = kzalloc(sizeof(*wl->profile), GFP_KERNEL);
3045 if (unlikely(!wl->profile)) {
3046 WL_ERR("wl_profile alloc failed\n");
3047 goto init_priv_mem_out;
3049 wl->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
3050 if (unlikely(!wl->bss_info)) {
3051 WL_ERR("Bss information alloc failed\n");
3052 goto init_priv_mem_out;
3054 wl->scan_req_int = kzalloc(sizeof(*wl->scan_req_int), GFP_KERNEL);
3055 if (unlikely(!wl->scan_req_int)) {
3056 WL_ERR("Scan req alloc failed\n");
3057 goto init_priv_mem_out;
3059 wl->ioctl_buf = kzalloc(WL_IOCTL_LEN_MAX, GFP_KERNEL);
3060 if (unlikely(!wl->ioctl_buf)) {
3061 WL_ERR("Ioctl buf alloc failed\n");
3062 goto init_priv_mem_out;
3064 wl->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3065 if (unlikely(!wl->extra_buf)) {
3066 WL_ERR("Extra buf alloc failed\n");
3067 goto init_priv_mem_out;
3069 wl->iscan = kzalloc(sizeof(*wl->iscan), GFP_KERNEL);
3070 if (unlikely(!wl->iscan)) {
3071 WL_ERR("Iscan buf alloc failed\n");
3072 goto init_priv_mem_out;
3074 wl->fw = kzalloc(sizeof(*wl->fw), GFP_KERNEL);
3075 if (unlikely(!wl->fw)) {
3076 WL_ERR("fw object alloc failed\n");
3077 goto init_priv_mem_out;
3079 wl->pmk_list = kzalloc(sizeof(*wl->pmk_list), GFP_KERNEL);
3080 if (unlikely(!wl->pmk_list)) {
3081 WL_ERR("pmk list alloc failed\n");
3082 goto init_priv_mem_out;
3088 wl_deinit_priv_mem(wl);
3093 static void wl_deinit_priv_mem(struct wl_priv *wl)
3095 kfree(wl->scan_results);
3096 wl->scan_results = NULL;
3097 kfree(wl->bss_info);
3098 wl->bss_info = NULL;
3103 kfree(wl->scan_req_int);
3104 wl->scan_req_int = NULL;
3105 kfree(wl->ioctl_buf);
3106 wl->ioctl_buf = NULL;
3107 kfree(wl->extra_buf);
3108 wl->extra_buf = NULL;
3113 kfree(wl->pmk_list);
3114 wl->pmk_list = NULL;
3117 static s32 wl_create_event_handler(struct wl_priv *wl)
3119 sema_init(&wl->event_sync, 0);
3120 wl->event_tsk = kthread_run(wl_event_handler, wl, "wl_event_handler");
3121 if (IS_ERR(wl->event_tsk)) {
3122 wl->event_tsk = NULL;
3123 WL_ERR("failed to create event thread\n");
3129 static void wl_destroy_event_handler(struct wl_priv *wl)
3131 if (wl->event_tsk) {
3132 send_sig(SIGTERM, wl->event_tsk, 1);
3133 kthread_stop(wl->event_tsk);
3134 wl->event_tsk = NULL;
3138 static void wl_term_iscan(struct wl_priv *wl)
3140 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3142 if (wl->iscan_on && iscan->tsk) {
3143 iscan->state = WL_ISCAN_STATE_IDLE;
3144 send_sig(SIGTERM, iscan->tsk, 1);
3145 kthread_stop(iscan->tsk);
3150 static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted)
3152 struct wl_priv *wl = iscan_to_wl(iscan);
3153 struct net_device *ndev = wl_to_ndev(wl);
3155 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
3156 WL_ERR("Scan complete while device not scanning\n");
3159 if (likely(wl->scan_request)) {
3160 WL_SCAN("ISCAN Completed scan: %s\n",
3161 aborted ? "Aborted" : "Done");
3162 cfg80211_scan_done(wl->scan_request, aborted);
3163 wl_set_mpc(ndev, 1);
3164 wl->scan_request = NULL;
3166 wl->iscan_kickstart = false;
3169 static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan)
3171 if (likely(iscan->state != WL_ISCAN_STATE_IDLE)) {
3172 WL_SCAN("wake up iscan\n");
3181 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
3182 struct wl_scan_results **bss_list)
3184 struct wl_iscan_results list;
3185 struct wl_scan_results *results;
3186 struct wl_iscan_results *list_buf;
3189 memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
3190 list_buf = (struct wl_iscan_results *)iscan->scan_buf;
3191 results = &list_buf->results;
3192 results->buflen = WL_ISCAN_RESULTS_FIXED_SIZE;
3193 results->version = 0;
3196 memset(&list, 0, sizeof(list));
3197 list.results.buflen = cpu_to_le32(WL_ISCAN_BUF_MAX);
3198 err = wl_dev_iovar_getbuf(iscan->dev, "iscanresults", &list,
3199 WL_ISCAN_RESULTS_FIXED_SIZE, iscan->scan_buf,
3201 if (unlikely(err)) {
3202 WL_ERR("error (%d)\n", err);
3205 results->buflen = le32_to_cpu(results->buflen);
3206 results->version = le32_to_cpu(results->version);
3207 results->count = le32_to_cpu(results->count);
3208 WL_SCAN("results->count = %d\n", results->count);
3209 WL_SCAN("results->buflen = %d\n", results->buflen);
3210 *status = le32_to_cpu(list_buf->status);
3211 *bss_list = results;
3216 static s32 wl_iscan_done(struct wl_priv *wl)
3218 struct wl_iscan_ctrl *iscan = wl->iscan;
3221 iscan->state = WL_ISCAN_STATE_IDLE;
3224 wl_notify_iscan_complete(iscan, false);
3230 static s32 wl_iscan_pending(struct wl_priv *wl)
3232 struct wl_iscan_ctrl *iscan = wl->iscan;
3235 /* Reschedule the timer */
3236 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3237 iscan->timer_on = 1;
3242 static s32 wl_iscan_inprogress(struct wl_priv *wl)
3244 struct wl_iscan_ctrl *iscan = wl->iscan;
3249 wl_run_iscan(iscan, NULL, WL_SCAN_ACTION_CONTINUE);
3251 /* Reschedule the timer */
3252 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3253 iscan->timer_on = 1;
3258 static s32 wl_iscan_aborted(struct wl_priv *wl)
3260 struct wl_iscan_ctrl *iscan = wl->iscan;
3263 iscan->state = WL_ISCAN_STATE_IDLE;
3265 wl_notify_iscan_complete(iscan, true);
3271 static s32 wl_iscan_thread(void *data)
3273 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3274 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
3275 struct wl_priv *wl = iscan_to_wl(iscan);
3276 struct wl_iscan_eloop *el = &iscan->el;
3280 sched_setscheduler(current, SCHED_FIFO, ¶m);
3281 allow_signal(SIGTERM);
3282 status = WL_SCAN_RESULTS_PARTIAL;
3283 while (likely(!down_interruptible(&iscan->sync))) {
3284 if (kthread_should_stop())
3286 if (iscan->timer_on) {
3287 del_timer_sync(&iscan->timer);
3288 iscan->timer_on = 0;
3291 err = wl_get_iscan_results(iscan, &status, &wl->bss_list);
3292 if (unlikely(err)) {
3293 status = WL_SCAN_RESULTS_ABORTED;
3294 WL_ERR("Abort iscan\n");
3297 el->handler[status] (wl);
3299 if (iscan->timer_on) {
3300 del_timer_sync(&iscan->timer);
3301 iscan->timer_on = 0;
3303 WL_SCAN("ISCAN thread terminated\n");
3308 static void wl_iscan_timer(unsigned long data)
3310 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
3313 iscan->timer_on = 0;
3314 WL_SCAN("timer expired\n");
3315 wl_wakeup_iscan(iscan);
3319 static s32 wl_invoke_iscan(struct wl_priv *wl)
3321 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3324 if (wl->iscan_on && !iscan->tsk) {
3325 iscan->state = WL_ISCAN_STATE_IDLE;
3326 sema_init(&iscan->sync, 0);
3327 iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
3328 if (IS_ERR(iscan->tsk)) {
3329 WL_ERR("Could not create iscan thread\n");
3338 static void wl_init_iscan_eloop(struct wl_iscan_eloop *el)
3340 memset(el, 0, sizeof(*el));
3341 el->handler[WL_SCAN_RESULTS_SUCCESS] = wl_iscan_done;
3342 el->handler[WL_SCAN_RESULTS_PARTIAL] = wl_iscan_inprogress;
3343 el->handler[WL_SCAN_RESULTS_PENDING] = wl_iscan_pending;
3344 el->handler[WL_SCAN_RESULTS_ABORTED] = wl_iscan_aborted;
3345 el->handler[WL_SCAN_RESULTS_NO_MEM] = wl_iscan_aborted;
3348 static s32 wl_init_iscan(struct wl_priv *wl)
3350 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3354 iscan->dev = wl_to_ndev(wl);
3355 iscan->state = WL_ISCAN_STATE_IDLE;
3356 wl_init_iscan_eloop(&iscan->el);
3357 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
3358 init_timer(&iscan->timer);
3359 iscan->timer.data = (unsigned long) iscan;
3360 iscan->timer.function = wl_iscan_timer;
3361 sema_init(&iscan->sync, 0);
3362 iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
3363 if (IS_ERR(iscan->tsk)) {
3364 WL_ERR("Could not create iscan thread\n");
3374 static void wl_init_fw(struct wl_fw_ctrl *fw)
3376 fw->status = 0; /* init fw loading status.
3377 0 means nothing was loaded yet */
3380 static s32 wl_init_priv(struct wl_priv *wl)
3382 struct wiphy *wiphy = wl_to_wiphy(wl);
3385 wl->scan_request = NULL;
3386 wl->pwr_save = !!(wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT);
3387 wl->iscan_on = true; /* iscan on & off switch.
3388 we enable iscan per default */
3389 wl->roam_on = false; /* roam on & off switch.
3390 we enable roam per default */
3392 wl->iscan_kickstart = false;
3393 wl->active_scan = true; /* we do active scan for
3394 specific scan per default */
3395 wl->dongle_up = false; /* dongle is not up yet */
3397 err = wl_init_priv_mem(wl);
3400 if (unlikely(wl_create_event_handler(wl)))
3402 wl_init_eloop_handler(&wl->el);
3403 mutex_init(&wl->usr_sync);
3404 err = wl_init_iscan(wl);
3408 wl_init_conf(wl->conf);
3409 wl_init_prof(wl->profile);
3415 static void wl_deinit_priv(struct wl_priv *wl)
3417 wl_destroy_event_handler(wl);
3418 wl->dongle_up = false; /* dongle down */
3422 wl_deinit_priv_mem(wl);
3425 s32 wl_cfg80211_attach(struct net_device *ndev, void *data)
3427 struct wireless_dev *wdev;
3429 struct wl_iface *ci;
3432 if (unlikely(!ndev)) {
3433 WL_ERR("ndev is invalid\n");
3436 wl_cfg80211_dev = kzalloc(sizeof(struct wl_dev), GFP_KERNEL);
3437 if (unlikely(!wl_cfg80211_dev)) {
3438 WL_ERR("wl_cfg80211_dev is invalid\n");
3441 WL_INFO("func %p\n", wl_cfg80211_get_sdio_func());
3442 wdev = wl_alloc_wdev(sizeof(struct wl_iface), &wl_cfg80211_get_sdio_func()->dev);
3446 wdev->iftype = wl_mode_to_nl80211_iftype(WL_MODE_BSS);
3447 wl = wdev_to_wl(wdev);
3450 ci = (struct wl_iface *)wl_to_ci(wl);
3452 ndev->ieee80211_ptr = wdev;
3453 SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
3454 wdev->netdev = ndev;
3455 err = wl_init_priv(wl);
3456 if (unlikely(err)) {
3457 WL_ERR("Failed to init iwm_priv (%d)\n", err);
3458 goto cfg80211_attach_out;
3460 wl_set_drvdata(wl_cfg80211_dev, ci);
3464 cfg80211_attach_out:
3469 void wl_cfg80211_detach(void)
3477 wl_set_drvdata(wl_cfg80211_dev, NULL);
3478 kfree(wl_cfg80211_dev);
3479 wl_cfg80211_dev = NULL;
3480 wl_clear_sdio_func();
3483 static void wl_wakeup_event(struct wl_priv *wl)
3485 up(&wl->event_sync);
3488 static s32 wl_event_handler(void *data)
3490 struct wl_priv *wl = (struct wl_priv *)data;
3491 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3492 struct wl_event_q *e;
3494 sched_setscheduler(current, SCHED_FIFO, ¶m);
3495 allow_signal(SIGTERM);
3496 while (likely(!down_interruptible(&wl->event_sync))) {
3497 if (kthread_should_stop())
3499 e = wl_deq_event(wl);
3501 WL_ERR("event queue empty...\n");
3504 WL_INFO("event type (%d)\n", e->etype);
3505 if (wl->el.handler[e->etype]) {
3506 wl->el.handler[e->etype] (wl, wl_to_ndev(wl), &e->emsg,
3509 WL_INFO("Unknown Event (%d): ignoring\n", e->etype);
3513 WL_INFO("was terminated\n");
3518 wl_cfg80211_event(struct net_device *ndev, const wl_event_msg_t * e, void *data)
3520 u32 event_type = be32_to_cpu(e->event_type);
3521 struct wl_priv *wl = ndev_to_wl(ndev);
3523 if (likely(!wl_enq_event(wl, event_type, e, data)))
3524 wl_wakeup_event(wl);
3527 static void wl_init_eq(struct wl_priv *wl)
3529 wl_init_eq_lock(wl);
3530 INIT_LIST_HEAD(&wl->eq_list);
3533 static void wl_flush_eq(struct wl_priv *wl)
3535 struct wl_event_q *e;
3538 while (!list_empty(&wl->eq_list)) {
3539 e = list_first_entry(&wl->eq_list, struct wl_event_q, eq_list);
3540 list_del(&e->eq_list);
3547 * retrieve first queued event from head
3550 static struct wl_event_q *wl_deq_event(struct wl_priv *wl)
3552 struct wl_event_q *e = NULL;
3555 if (likely(!list_empty(&wl->eq_list))) {
3556 e = list_first_entry(&wl->eq_list, struct wl_event_q, eq_list);
3557 list_del(&e->eq_list);
3565 ** push event to tail of the queue
3569 wl_enq_event(struct wl_priv *wl, u32 event, const wl_event_msg_t *msg,
3572 struct wl_event_q *e;
3575 e = kzalloc(sizeof(struct wl_event_q), GFP_KERNEL);
3577 WL_ERR("event alloc failed\n");
3582 memcpy(&e->emsg, msg, sizeof(wl_event_msg_t));
3586 list_add_tail(&e->eq_list, &wl->eq_list);
3592 static void wl_put_event(struct wl_event_q *e)
3597 void wl_cfg80211_sdio_func(void *func)
3599 cfg80211_sdio_func = (struct sdio_func *)func;
3602 static void wl_clear_sdio_func(void)
3604 cfg80211_sdio_func = NULL;
3607 struct sdio_func *wl_cfg80211_get_sdio_func(void)
3609 return cfg80211_sdio_func;
3612 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype)
3618 case NL80211_IFTYPE_MONITOR:
3619 case NL80211_IFTYPE_WDS:
3620 WL_ERR("type (%d) : currently we do not support this mode\n",
3624 case NL80211_IFTYPE_ADHOC:
3627 case NL80211_IFTYPE_STATION:
3632 WL_ERR("invalid type (%d)\n", iftype);
3635 infra = cpu_to_le32(infra);
3636 err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
3637 if (unlikely(err)) {
3638 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
3645 #ifndef EMBEDDED_PLATFORM
3646 static s32 wl_dongle_country(struct net_device *ndev, u8 ccode)
3654 static s32 wl_dongle_up(struct net_device *ndev, u32 up)
3658 err = wl_dev_ioctl(ndev, WLC_UP, &up, sizeof(up));
3659 if (unlikely(err)) {
3660 WL_ERR("WLC_UP error (%d)\n", err);
3665 static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode)
3669 err = wl_dev_ioctl(ndev, WLC_SET_PM, &power_mode, sizeof(power_mode));
3670 if (unlikely(err)) {
3671 WL_ERR("WLC_SET_PM error (%d)\n", err);
3677 wl_dongle_glom(struct net_device *ndev, u32 glom, u32 dongle_align)
3679 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3683 /* Match Host and Dongle rx alignment */
3684 bcm_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf,
3686 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3687 if (unlikely(err)) {
3688 WL_ERR("txglomalign error (%d)\n", err);
3689 goto dongle_glom_out;
3691 /* disable glom option per default */
3692 bcm_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));
3693 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3694 if (unlikely(err)) {
3695 WL_ERR("txglom error (%d)\n", err);
3696 goto dongle_glom_out;
3703 wl_dongle_offload(struct net_device *ndev, s32 arpoe, s32 arp_ol)
3705 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3709 /* Set ARP offload */
3710 bcm_mkiovar("arpoe", (char *)&arpoe, 4, iovbuf, sizeof(iovbuf));
3711 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3713 if (err == -EOPNOTSUPP)
3714 WL_INFO("arpoe is not supported\n");
3716 WL_ERR("arpoe error (%d)\n", err);
3718 goto dongle_offload_out;
3720 bcm_mkiovar("arp_ol", (char *)&arp_ol, 4, iovbuf, sizeof(iovbuf));
3721 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3723 if (err == -EOPNOTSUPP)
3724 WL_INFO("arp_ol is not supported\n");
3726 WL_ERR("arp_ol error (%d)\n", err);
3728 goto dongle_offload_out;
3735 static s32 wl_pattern_atoh(s8 *src, s8 *dst)
3738 if (strncmp(src, "0x", 2) != 0 && strncmp(src, "0X", 2) != 0) {
3739 WL_ERR("Mask invalid format. Needs to start with 0x\n");
3742 src = src + 2; /* Skip past 0x */
3743 if (strlen(src) % 2 != 0) {
3744 WL_ERR("Mask invalid format. Needs to be of even length\n");
3747 for (i = 0; *src != '\0'; i++) {
3749 strncpy(num, src, 2);
3751 dst[i] = (u8) simple_strtoul(num, NULL, 16);
3757 static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode)
3759 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3762 struct wl_pkt_filter pkt_filter;
3763 struct wl_pkt_filter *pkt_filterp;
3771 /* add a default packet filter pattern */
3772 str = "pkt_filter_add";
3773 str_len = strlen(str);
3774 strncpy(buf, str, str_len);
3775 buf[str_len] = '\0';
3776 buf_len = str_len + 1;
3778 pkt_filterp = (struct wl_pkt_filter *)(buf + str_len + 1);
3780 /* Parse packet filter id. */
3781 pkt_filter.id = cpu_to_le32(100);
3783 /* Parse filter polarity. */
3784 pkt_filter.negate_match = cpu_to_le32(0);
3786 /* Parse filter type. */
3787 pkt_filter.type = cpu_to_le32(0);
3789 /* Parse pattern filter offset. */
3790 pkt_filter.u.pattern.offset = cpu_to_le32(0);
3792 /* Parse pattern filter mask. */
3793 mask_size = cpu_to_le32(wl_pattern_atoh("0xff",
3794 (char *)pkt_filterp->u.pattern.
3797 /* Parse pattern filter pattern. */
3798 pattern_size = cpu_to_le32(wl_pattern_atoh("0x00",
3799 (char *)&pkt_filterp->u.
3804 if (mask_size != pattern_size) {
3805 WL_ERR("Mask and pattern not the same size\n");
3807 goto dongle_filter_out;
3810 pkt_filter.u.pattern.size_bytes = mask_size;
3811 buf_len += WL_PKT_FILTER_FIXED_LEN;
3812 buf_len += (WL_PKT_FILTER_PATTERN_FIXED_LEN + 2 * mask_size);
3814 /* Keep-alive attributes are set in local
3815 * variable (keep_alive_pkt), and
3816 * then memcpy'ed into buffer (keep_alive_pktp) since there is no
3817 * guarantee that the buffer is properly aligned.
3819 memcpy((char *)pkt_filterp, &pkt_filter,
3820 WL_PKT_FILTER_FIXED_LEN + WL_PKT_FILTER_PATTERN_FIXED_LEN);
3822 err = wl_dev_ioctl(ndev, WLC_SET_VAR, buf, buf_len);
3824 if (err == -EOPNOTSUPP) {
3825 WL_INFO("filter not supported\n");
3827 WL_ERR("filter (%d)\n", err);
3829 goto dongle_filter_out;
3832 /* set mode to allow pattern */
3833 bcm_mkiovar("pkt_filter_mode", (char *)&filter_mode, 4, iovbuf,
3835 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3837 if (err == -EOPNOTSUPP) {
3838 WL_INFO("filter_mode not supported\n");
3840 WL_ERR("filter_mode (%d)\n", err);
3842 goto dongle_filter_out;
3848 #endif /* !EMBEDDED_PLATFORM */
3850 static s32 wl_dongle_eventmsg(struct net_device *ndev)
3852 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3854 s8 eventmask[WL_EVENTING_MASK_LEN];
3857 WL_TRACE("Enter\n");
3859 /* Setup event_msgs */
3860 bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
3862 err = wl_dev_ioctl(ndev, WLC_GET_VAR, iovbuf, sizeof(iovbuf));
3863 if (unlikely(err)) {
3864 WL_ERR("Get event_msgs error (%d)\n", err);
3865 goto dongle_eventmsg_out;
3867 memcpy(eventmask, iovbuf, WL_EVENTING_MASK_LEN);
3869 setbit(eventmask, WLC_E_SET_SSID);
3870 setbit(eventmask, WLC_E_ROAM);
3871 setbit(eventmask, WLC_E_PRUNE);
3872 setbit(eventmask, WLC_E_AUTH);
3873 setbit(eventmask, WLC_E_REASSOC);
3874 setbit(eventmask, WLC_E_REASSOC_IND);
3875 setbit(eventmask, WLC_E_DEAUTH_IND);
3876 setbit(eventmask, WLC_E_DISASSOC_IND);
3877 setbit(eventmask, WLC_E_DISASSOC);
3878 setbit(eventmask, WLC_E_JOIN);
3879 setbit(eventmask, WLC_E_ASSOC_IND);
3880 setbit(eventmask, WLC_E_PSK_SUP);
3881 setbit(eventmask, WLC_E_LINK);
3882 setbit(eventmask, WLC_E_NDIS_LINK);
3883 setbit(eventmask, WLC_E_MIC_ERROR);
3884 setbit(eventmask, WLC_E_PMKID_CACHE);
3885 setbit(eventmask, WLC_E_TXFAIL);
3886 setbit(eventmask, WLC_E_JOIN_START);
3887 setbit(eventmask, WLC_E_SCAN_COMPLETE);
3889 bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
3891 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3892 if (unlikely(err)) {
3893 WL_ERR("Set event_msgs error (%d)\n", err);
3894 goto dongle_eventmsg_out;
3897 dongle_eventmsg_out:
3903 wl_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
3911 * Setup timeout if Beacons are lost and roam is
3912 * off to report link down
3915 bcm_mkiovar("bcn_timeout", (char *)&bcn_timeout,
3916 sizeof(bcn_timeout), iovbuf, sizeof(iovbuf));
3917 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3918 if (unlikely(err)) {
3919 WL_ERR("bcn_timeout error (%d)\n", err);
3920 goto dongle_rom_out;
3925 * Enable/Disable built-in roaming to allow supplicant
3926 * to take care of roaming
3928 WL_INFO("Internal Roaming = %s\n", roamvar ? "Off" : "On");
3929 bcm_mkiovar("roam_off", (char *)&roamvar,
3930 sizeof(roamvar), iovbuf, sizeof(iovbuf));
3931 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3932 if (unlikely(err)) {
3933 WL_ERR("roam_off error (%d)\n", err);
3934 goto dongle_rom_out;
3937 roamtrigger[0] = WL_ROAM_TRIGGER_LEVEL;
3938 roamtrigger[1] = WLC_BAND_ALL;
3939 err = wl_dev_ioctl(ndev, WLC_SET_ROAM_TRIGGER,
3940 (void *)roamtrigger, sizeof(roamtrigger));
3941 if (unlikely(err)) {
3942 WL_ERR("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
3943 goto dongle_rom_out;
3946 roam_delta[0] = WL_ROAM_DELTA;
3947 roam_delta[1] = WLC_BAND_ALL;
3948 err = wl_dev_ioctl(ndev, WLC_SET_ROAM_DELTA,
3949 (void *)roam_delta, sizeof(roam_delta));
3950 if (unlikely(err)) {
3951 WL_ERR("WLC_SET_ROAM_DELTA error (%d)\n", err);
3952 goto dongle_rom_out;
3960 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
3961 s32 scan_unassoc_time, s32 scan_passive_time)
3965 err = wl_dev_ioctl(ndev, WLC_SET_SCAN_CHANNEL_TIME, &scan_assoc_time,
3966 sizeof(scan_assoc_time));
3968 if (err == -EOPNOTSUPP)
3969 WL_INFO("Scan assoc time is not supported\n");
3971 WL_ERR("Scan assoc time error (%d)\n", err);
3972 goto dongle_scantime_out;
3974 err = wl_dev_ioctl(ndev, WLC_SET_SCAN_UNASSOC_TIME, &scan_unassoc_time,
3975 sizeof(scan_unassoc_time));
3977 if (err == -EOPNOTSUPP)
3978 WL_INFO("Scan unassoc time is not supported\n");
3980 WL_ERR("Scan unassoc time error (%d)\n", err);
3981 goto dongle_scantime_out;
3984 err = wl_dev_ioctl(ndev, WLC_SET_SCAN_PASSIVE_TIME, &scan_passive_time,
3985 sizeof(scan_passive_time));
3987 if (err == -EOPNOTSUPP)
3988 WL_INFO("Scan passive time is not supported\n");
3990 WL_ERR("Scan passive time error (%d)\n", err);
3991 goto dongle_scantime_out;
3994 dongle_scantime_out:
3998 s32 wl_config_dongle(struct wl_priv *wl, bool need_lock)
4001 #define DHD_SDALIGN 32
4003 struct net_device *ndev;
4004 struct wireless_dev *wdev;
4010 ndev = wl_to_ndev(wl);
4011 wdev = ndev->ieee80211_ptr;
4015 #ifndef EMBEDDED_PLATFORM
4016 err = wl_dongle_up(ndev, 0);
4018 goto default_conf_out;
4019 err = wl_dongle_country(ndev, 0);
4021 goto default_conf_out;
4022 err = wl_dongle_power(ndev, PM_FAST);
4024 goto default_conf_out;
4025 err = wl_dongle_glom(ndev, 0, DHD_SDALIGN);
4027 goto default_conf_out;
4029 wl_dongle_offload(ndev, 1, 0xf);
4030 wl_dongle_filter(ndev, 1);
4031 #endif /* !EMBEDDED_PLATFORM */
4033 wl_dongle_scantime(ndev, WL_SCAN_CHANNEL_TIME,
4034 WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
4036 err = wl_dongle_eventmsg(ndev);
4038 goto default_conf_out;
4039 err = wl_dongle_roam(ndev, (wl->roam_on ? 0 : 1), WL_BEACON_TIMEOUT);
4041 goto default_conf_out;
4042 err = wl_dongle_mode(ndev, wdev->iftype);
4043 if (unlikely(err && err != -EINPROGRESS))
4044 goto default_conf_out;
4045 err = wl_dongle_probecap(wl);
4047 goto default_conf_out;
4049 /* -EINPROGRESS: Call commit handler */
4055 wl->dongle_up = true;
4061 static s32 wl_update_wiphybands(struct wl_priv *wl)
4063 struct wiphy *wiphy;
4068 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_PHYLIST, &phy_list,
4070 if (unlikely(err)) {
4071 WL_ERR("error (%d)\n", err);
4075 phy = ((char *)&phy_list)[1];
4076 WL_INFO("%c phy\n", phy);
4077 if (phy == 'n' || phy == 'a') {
4078 wiphy = wl_to_wiphy(wl);
4079 wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
4085 static s32 __wl_cfg80211_up(struct wl_priv *wl)
4089 set_bit(WL_STATUS_READY, &wl->status);
4091 wl_debugfs_add_netdev_params(wl);
4093 err = wl_config_dongle(wl, false);
4097 wl_invoke_iscan(wl);
4102 static s32 __wl_cfg80211_down(struct wl_priv *wl)
4104 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
4106 if (wl->scan_request) {
4107 cfg80211_scan_done(wl->scan_request, true);
4108 /* May need to perform this to cover rmmod */
4109 /* wl_set_mpc(wl_to_ndev(wl), 1); */
4110 wl->scan_request = NULL;
4112 clear_bit(WL_STATUS_READY, &wl->status);
4113 clear_bit(WL_STATUS_SCANNING, &wl->status);
4114 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
4115 clear_bit(WL_STATUS_CONNECTING, &wl->status);
4116 clear_bit(WL_STATUS_CONNECTED, &wl->status);
4118 wl_debugfs_remove_netdev(wl);
4123 s32 wl_cfg80211_up(void)
4129 mutex_lock(&wl->usr_sync);
4130 err = __wl_cfg80211_up(wl);
4131 mutex_unlock(&wl->usr_sync);
4136 s32 wl_cfg80211_down(void)
4142 mutex_lock(&wl->usr_sync);
4143 err = __wl_cfg80211_down(wl);
4144 mutex_unlock(&wl->usr_sync);
4149 static s32 wl_dongle_probecap(struct wl_priv *wl)
4153 err = wl_update_wiphybands(wl);
4160 static void *wl_read_prof(struct wl_priv *wl, s32 item)
4164 return &wl->profile->sec;
4166 return &wl->profile->bssid;
4168 return &wl->profile->ssid;
4170 WL_ERR("invalid item (%d)\n", item);
4175 wl_update_prof(struct wl_priv *wl, const wl_event_msg_t *e, void *data,
4179 struct wlc_ssid *ssid;
4183 ssid = (wlc_ssid_t *) data;
4184 memset(wl->profile->ssid.SSID, 0,
4185 sizeof(wl->profile->ssid.SSID));
4186 memcpy(wl->profile->ssid.SSID, ssid->SSID, ssid->SSID_len);
4187 wl->profile->ssid.SSID_len = ssid->SSID_len;
4191 memcpy(wl->profile->bssid, data, ETH_ALEN);
4193 memset(wl->profile->bssid, 0, ETH_ALEN);
4196 memcpy(&wl->profile->sec, data, sizeof(wl->profile->sec));
4198 case WL_PROF_BEACONINT:
4199 wl->profile->beacon_interval = *(u16 *)data;
4201 case WL_PROF_DTIMPERIOD:
4202 wl->profile->dtim_period = *(u8 *)data;
4205 WL_ERR("unsupported item (%d)\n", item);
4213 static bool wl_is_ibssmode(struct wl_priv *wl)
4215 return wl->conf->mode == WL_MODE_IBSS;
4218 static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v)
4220 struct wl_ie *ie = wl_to_ie(wl);
4223 if (unlikely(ie->offset + l + 2 > WL_TLV_INFO_MAX)) {
4224 WL_ERR("ei crosses buffer boundary\n");
4227 ie->buf[ie->offset] = t;
4228 ie->buf[ie->offset + 1] = l;
4229 memcpy(&ie->buf[ie->offset + 2], v, l);
4230 ie->offset += l + 2;
4236 static void wl_link_down(struct wl_priv *wl)
4238 struct net_device *dev = NULL;
4241 WL_TRACE("Enter\n");
4242 clear_bit(WL_STATUS_CONNECTED, &wl->status);
4245 dev = wl_to_ndev(wl);
4246 WL_INFO("Call WLC_DISASSOC to stop excess roaming\n ");
4247 err = wl_dev_ioctl(dev, WLC_DISASSOC, NULL, 0);
4249 WL_ERR("WLC_DISASSOC failed (%d)\n", err);
4250 wl->link_up = false;
4255 static void wl_lock_eq(struct wl_priv *wl)
4257 spin_lock_irq(&wl->eq_lock);
4260 static void wl_unlock_eq(struct wl_priv *wl)
4262 spin_unlock_irq(&wl->eq_lock);
4265 static void wl_init_eq_lock(struct wl_priv *wl)
4267 spin_lock_init(&wl->eq_lock);
4270 static void wl_delay(u32 ms)
4272 if (ms < 1000 / HZ) {
4280 static void wl_set_drvdata(struct wl_dev *dev, void *data)
4282 dev->driver_data = data;
4285 static void *wl_get_drvdata(struct wl_dev *dev)
4287 return dev->driver_data;
4290 s32 wl_cfg80211_read_fw(s8 *buf, u32 size)
4292 const struct firmware *fw_entry;
4297 fw_entry = wl->fw->fw_entry;
4299 if (fw_entry->size < wl->fw->ptr + size)
4300 size = fw_entry->size - wl->fw->ptr;
4302 memcpy(buf, &fw_entry->data[wl->fw->ptr], size);
4303 wl->fw->ptr += size;
4307 void wl_cfg80211_release_fw(void)
4312 release_firmware(wl->fw->fw_entry);
4316 void *wl_cfg80211_request_fw(s8 *file_name)
4319 const struct firmware *fw_entry = NULL;
4322 WL_INFO("file name : \"%s\"\n", file_name);
4325 if (!test_bit(WL_FW_LOADING_DONE, &wl->fw->status)) {
4326 err = request_firmware(&wl->fw->fw_entry, file_name,
4327 &wl_cfg80211_get_sdio_func()->dev);
4328 if (unlikely(err)) {
4329 WL_ERR("Could not download fw (%d)\n", err);
4332 set_bit(WL_FW_LOADING_DONE, &wl->fw->status);
4333 fw_entry = wl->fw->fw_entry;
4335 WL_INFO("fw size (%zd), data (%p)\n",
4336 fw_entry->size, fw_entry->data);
4338 } else if (!test_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status)) {
4339 err = request_firmware(&wl->fw->fw_entry, file_name,
4340 &wl_cfg80211_get_sdio_func()->dev);
4341 if (unlikely(err)) {
4342 WL_ERR("Could not download nvram (%d)\n", err);
4345 set_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status);
4346 fw_entry = wl->fw->fw_entry;
4348 WL_INFO("nvram size (%zd), data (%p)\n",
4349 fw_entry->size, fw_entry->data);
4352 WL_INFO("Downloading already done. Nothing to do more\n");
4357 if (unlikely(err)) {
4361 return (void *)fw_entry->data;
4364 s8 *wl_cfg80211_get_fwname(void)
4369 strcpy(wl->fw->fw_name, WL_4329_FW_FILE);
4370 return wl->fw->fw_name;
4373 s8 *wl_cfg80211_get_nvramname(void)
4378 strcpy(wl->fw->nvram_name, WL_4329_NVRAM_FILE);
4379 return wl->fw->nvram_name;
4382 static void wl_set_mpc(struct net_device *ndev, int mpc)
4385 struct wl_priv *wl = ndev_to_wl(ndev);
4387 if (test_bit(WL_STATUS_READY, &wl->status)) {
4388 err = wl_dev_intvar_set(ndev, "mpc", mpc);
4389 if (unlikely(err)) {
4390 WL_ERR("fail to set mpc\n");
4393 WL_INFO("MPC : %d\n", mpc);
4397 static int wl_debugfs_add_netdev_params(struct wl_priv *wl)
4399 char buf[10+IFNAMSIZ];
4403 sprintf(buf, "netdev:%s", wl_to_ndev(wl)->name);
4404 wl->debugfsdir = debugfs_create_dir(buf, wl_to_wiphy(wl)->debugfsdir);
4406 fd = debugfs_create_u16("beacon_int", S_IRUGO, wl->debugfsdir,
4407 (u16 *)&wl->profile->beacon_interval);
4413 fd = debugfs_create_u8("dtim_period", S_IRUGO, wl->debugfsdir,
4414 (u8 *)&wl->profile->dtim_period);
4424 static void wl_debugfs_remove_netdev(struct wl_priv *wl)
4426 debugfs_remove_recursive(wl->debugfsdir);
4427 wl->debugfsdir = NULL;