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 | WL_DBG_INFO;
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_ch_to_chanspec(int ch,
196 struct wl_join_params *join_params, size_t *join_params_size);
199 ** information element utilities
201 static void wl_rst_ie(struct wl_priv *wl);
202 static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v);
203 static s32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, u16 ie_size);
204 static s32 wl_cp_ie(struct wl_priv *wl, u8 *dst, u16 dst_size);
205 static u32 wl_get_ielen(struct wl_priv *wl);
207 static s32 wl_mode_to_nl80211_iftype(s32 mode);
209 static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
211 static void wl_free_wdev(struct wl_priv *wl);
213 static s32 wl_inform_bss(struct wl_priv *wl);
214 static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi);
215 static s32 wl_update_bss_info(struct wl_priv *wl);
217 static s32 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
218 u8 key_idx, const u8 *mac_addr,
219 struct key_params *params);
222 ** key indianess swap utilities
224 static void swap_key_from_BE(struct wl_wsec_key *key);
225 static void swap_key_to_BE(struct wl_wsec_key *key);
228 ** wl_priv memory init/deinit utilities
230 static s32 wl_init_priv_mem(struct wl_priv *wl);
231 static void wl_deinit_priv_mem(struct wl_priv *wl);
233 static void wl_delay(u32 ms);
236 ** store/restore cfg80211 instance data
238 static void wl_set_drvdata(struct wl_dev *dev, void *data);
239 static void *wl_get_drvdata(struct wl_dev *dev);
242 ** ibss mode utilities
244 static bool wl_is_ibssmode(struct wl_priv *wl);
245 static bool wl_is_ibssstarter(struct wl_priv *wl);
248 ** dongle up/down , default configuration utilities
250 static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e);
251 static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e);
252 static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e);
253 static void wl_link_up(struct wl_priv *wl);
254 static void wl_link_down(struct wl_priv *wl);
255 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
256 static s32 __wl_cfg80211_up(struct wl_priv *wl);
257 static s32 __wl_cfg80211_down(struct wl_priv *wl);
258 static s32 wl_dongle_probecap(struct wl_priv *wl);
259 static void wl_init_conf(struct wl_conf *conf);
262 ** dongle configuration utilities
264 #ifndef EMBEDDED_PLATFORM
265 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
266 static s32 wl_dongle_country(struct net_device *ndev, u8 ccode);
267 static s32 wl_dongle_up(struct net_device *ndev, u32 up);
268 static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode);
269 static s32 wl_dongle_glom(struct net_device *ndev, u32 glom,
271 static s32 wl_dongle_roam(struct net_device *ndev, u32 roamvar,
273 static s32 wl_dongle_eventmsg(struct net_device *ndev);
274 static s32 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
275 s32 scan_unassoc_time);
276 static s32 wl_dongle_offload(struct net_device *ndev, s32 arpoe,
278 static s32 wl_pattern_atoh(s8 *src, s8 *dst);
279 static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode);
280 static s32 wl_update_wiphybands(struct wl_priv *wl);
281 #endif /* !EMBEDDED_PLATFORM */
282 static s32 wl_config_dongle(struct wl_priv *wl, bool need_lock);
287 static void wl_iscan_timer(unsigned long data);
288 static void wl_term_iscan(struct wl_priv *wl);
289 static s32 wl_init_iscan(struct wl_priv *wl);
290 static s32 wl_iscan_thread(void *data);
291 static s32 wl_dev_iovar_setbuf(struct net_device *dev, s8 *iovar,
292 void *param, s32 paramlen, void *bufptr,
294 static s32 wl_dev_iovar_getbuf(struct net_device *dev, s8 *iovar,
295 void *param, s32 paramlen, void *bufptr,
297 static s32 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid,
299 static s32 wl_do_iscan(struct wl_priv *wl);
300 static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan);
301 static s32 wl_invoke_iscan(struct wl_priv *wl);
302 static s32 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
303 struct wl_scan_results **bss_list);
304 static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted);
305 static void wl_init_iscan_eloop(struct wl_iscan_eloop *el);
306 static s32 wl_iscan_done(struct wl_priv *wl);
307 static s32 wl_iscan_pending(struct wl_priv *wl);
308 static s32 wl_iscan_inprogress(struct wl_priv *wl);
309 static s32 wl_iscan_aborted(struct wl_priv *wl);
312 ** fw/nvram downloading handler
314 static void wl_init_fw(struct wl_fw_ctrl *fw);
317 * find most significant bit set
319 static __used u32 wl_find_msb(u16 bit16);
322 * update pmklist to dongle
324 static __used s32 wl_update_pmklist(struct net_device *dev,
325 struct wl_pmk_list *pmk_list, s32 err);
327 static void wl_set_mpc(struct net_device *ndev, int mpc);
332 static int wl_debugfs_add_netdev_params(struct wl_priv *wl);
333 static void wl_debugfs_remove_netdev(struct wl_priv *wl);
335 #define WL_PRIV_GET() \
337 struct wl_iface *ci; \
338 if (unlikely(!(wl_cfg80211_dev && \
339 (ci = wl_get_drvdata(wl_cfg80211_dev))))) { \
340 WL_ERR("wl_cfg80211_dev is unavailable\n"); \
346 #define CHECK_SYS_UP() \
348 struct wl_priv *wl = wiphy_to_wl(wiphy); \
349 if (unlikely(!test_bit(WL_STATUS_READY, &wl->status))) { \
350 WL_INFO("device is not ready : status (%d)\n", \
356 extern int dhd_wait_pend8021x(struct net_device *dev);
358 #if (WL_DBG_LEVEL > 0)
359 #define WL_DBG_ESTR_MAX 32
360 static s8 wl_dbg_estr[][WL_DBG_ESTR_MAX] = {
361 "SET_SSID", "JOIN", "START", "AUTH", "AUTH_IND",
362 "DEAUTH", "DEAUTH_IND", "ASSOC", "ASSOC_IND", "REASSOC",
363 "REASSOC_IND", "DISASSOC", "DISASSOC_IND", "QUIET_START", "QUIET_END",
364 "BEACON_RX", "LINK", "MIC_ERROR", "NDIS_LINK", "ROAM",
365 "TXFAIL", "PMKID_CACHE", "RETROGRADE_TSF", "PRUNE", "AUTOAUTH",
366 "EAPOL_MSG", "SCAN_COMPLETE", "ADDTS_IND", "DELTS_IND", "BCNSENT_IND",
367 "BCNRX_MSG", "BCNLOST_MSG", "ROAM_PREP", "PFN_NET_FOUND",
369 "RESET_COMPLETE", "JOIN_START", "ROAM_START", "ASSOC_START",
371 "RADIO", "PSM_WATCHDOG",
373 "SCAN_CONFIRM_IND", "PSK_SUP", "COUNTRY_CODE_CHANGED",
374 "EXCEEDED_MEDIUM_TIME", "ICV_ERROR",
375 "UNICAST_DECODE_ERROR", "MULTICAST_DECODE_ERROR", "TRACE",
377 "RSSI", "PFN_SCAN_COMPLETE", "ACTION_FRAME", "ACTION_FRAME_COMPLETE",
379 #endif /* WL_DBG_LEVEL */
381 #define CHAN2G(_channel, _freq, _flags) { \
382 .band = IEEE80211_BAND_2GHZ, \
383 .center_freq = (_freq), \
384 .hw_value = (_channel), \
386 .max_antenna_gain = 0, \
390 #define CHAN5G(_channel, _flags) { \
391 .band = IEEE80211_BAND_5GHZ, \
392 .center_freq = 5000 + (5 * (_channel)), \
393 .hw_value = (_channel), \
395 .max_antenna_gain = 0, \
399 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
400 #define RATETAB_ENT(_rateid, _flags) \
402 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
403 .hw_value = (_rateid), \
407 static struct ieee80211_rate __wl_rates[] = {
408 RATETAB_ENT(WLC_RATE_1M, 0),
409 RATETAB_ENT(WLC_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
410 RATETAB_ENT(WLC_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
411 RATETAB_ENT(WLC_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
412 RATETAB_ENT(WLC_RATE_6M, 0),
413 RATETAB_ENT(WLC_RATE_9M, 0),
414 RATETAB_ENT(WLC_RATE_12M, 0),
415 RATETAB_ENT(WLC_RATE_18M, 0),
416 RATETAB_ENT(WLC_RATE_24M, 0),
417 RATETAB_ENT(WLC_RATE_36M, 0),
418 RATETAB_ENT(WLC_RATE_48M, 0),
419 RATETAB_ENT(WLC_RATE_54M, 0),
422 #define wl_a_rates (__wl_rates + 4)
423 #define wl_a_rates_size 8
424 #define wl_g_rates (__wl_rates + 0)
425 #define wl_g_rates_size 12
427 static struct ieee80211_channel __wl_2ghz_channels[] = {
444 static struct ieee80211_channel __wl_5ghz_a_channels[] = {
445 CHAN5G(34, 0), CHAN5G(36, 0),
446 CHAN5G(38, 0), CHAN5G(40, 0),
447 CHAN5G(42, 0), CHAN5G(44, 0),
448 CHAN5G(46, 0), CHAN5G(48, 0),
449 CHAN5G(52, 0), CHAN5G(56, 0),
450 CHAN5G(60, 0), CHAN5G(64, 0),
451 CHAN5G(100, 0), CHAN5G(104, 0),
452 CHAN5G(108, 0), CHAN5G(112, 0),
453 CHAN5G(116, 0), CHAN5G(120, 0),
454 CHAN5G(124, 0), CHAN5G(128, 0),
455 CHAN5G(132, 0), CHAN5G(136, 0),
456 CHAN5G(140, 0), CHAN5G(149, 0),
457 CHAN5G(153, 0), CHAN5G(157, 0),
458 CHAN5G(161, 0), CHAN5G(165, 0),
459 CHAN5G(184, 0), CHAN5G(188, 0),
460 CHAN5G(192, 0), CHAN5G(196, 0),
461 CHAN5G(200, 0), CHAN5G(204, 0),
462 CHAN5G(208, 0), CHAN5G(212, 0),
466 static struct ieee80211_channel __wl_5ghz_n_channels[] = {
467 CHAN5G(32, 0), CHAN5G(34, 0),
468 CHAN5G(36, 0), CHAN5G(38, 0),
469 CHAN5G(40, 0), CHAN5G(42, 0),
470 CHAN5G(44, 0), CHAN5G(46, 0),
471 CHAN5G(48, 0), CHAN5G(50, 0),
472 CHAN5G(52, 0), CHAN5G(54, 0),
473 CHAN5G(56, 0), CHAN5G(58, 0),
474 CHAN5G(60, 0), CHAN5G(62, 0),
475 CHAN5G(64, 0), CHAN5G(66, 0),
476 CHAN5G(68, 0), CHAN5G(70, 0),
477 CHAN5G(72, 0), CHAN5G(74, 0),
478 CHAN5G(76, 0), CHAN5G(78, 0),
479 CHAN5G(80, 0), CHAN5G(82, 0),
480 CHAN5G(84, 0), CHAN5G(86, 0),
481 CHAN5G(88, 0), CHAN5G(90, 0),
482 CHAN5G(92, 0), CHAN5G(94, 0),
483 CHAN5G(96, 0), CHAN5G(98, 0),
484 CHAN5G(100, 0), CHAN5G(102, 0),
485 CHAN5G(104, 0), CHAN5G(106, 0),
486 CHAN5G(108, 0), CHAN5G(110, 0),
487 CHAN5G(112, 0), CHAN5G(114, 0),
488 CHAN5G(116, 0), CHAN5G(118, 0),
489 CHAN5G(120, 0), CHAN5G(122, 0),
490 CHAN5G(124, 0), CHAN5G(126, 0),
491 CHAN5G(128, 0), CHAN5G(130, 0),
492 CHAN5G(132, 0), CHAN5G(134, 0),
493 CHAN5G(136, 0), CHAN5G(138, 0),
494 CHAN5G(140, 0), CHAN5G(142, 0),
495 CHAN5G(144, 0), CHAN5G(145, 0),
496 CHAN5G(146, 0), CHAN5G(147, 0),
497 CHAN5G(148, 0), CHAN5G(149, 0),
498 CHAN5G(150, 0), CHAN5G(151, 0),
499 CHAN5G(152, 0), CHAN5G(153, 0),
500 CHAN5G(154, 0), CHAN5G(155, 0),
501 CHAN5G(156, 0), CHAN5G(157, 0),
502 CHAN5G(158, 0), CHAN5G(159, 0),
503 CHAN5G(160, 0), CHAN5G(161, 0),
504 CHAN5G(162, 0), CHAN5G(163, 0),
505 CHAN5G(164, 0), CHAN5G(165, 0),
506 CHAN5G(166, 0), CHAN5G(168, 0),
507 CHAN5G(170, 0), CHAN5G(172, 0),
508 CHAN5G(174, 0), CHAN5G(176, 0),
509 CHAN5G(178, 0), CHAN5G(180, 0),
510 CHAN5G(182, 0), CHAN5G(184, 0),
511 CHAN5G(186, 0), CHAN5G(188, 0),
512 CHAN5G(190, 0), CHAN5G(192, 0),
513 CHAN5G(194, 0), CHAN5G(196, 0),
514 CHAN5G(198, 0), CHAN5G(200, 0),
515 CHAN5G(202, 0), CHAN5G(204, 0),
516 CHAN5G(206, 0), CHAN5G(208, 0),
517 CHAN5G(210, 0), CHAN5G(212, 0),
518 CHAN5G(214, 0), CHAN5G(216, 0),
519 CHAN5G(218, 0), CHAN5G(220, 0),
520 CHAN5G(222, 0), CHAN5G(224, 0),
521 CHAN5G(226, 0), CHAN5G(228, 0),
524 static struct ieee80211_supported_band __wl_band_2ghz = {
525 .band = IEEE80211_BAND_2GHZ,
526 .channels = __wl_2ghz_channels,
527 .n_channels = ARRAY_SIZE(__wl_2ghz_channels),
528 .bitrates = wl_g_rates,
529 .n_bitrates = wl_g_rates_size,
532 static struct ieee80211_supported_band __wl_band_5ghz_a = {
533 .band = IEEE80211_BAND_5GHZ,
534 .channels = __wl_5ghz_a_channels,
535 .n_channels = ARRAY_SIZE(__wl_5ghz_a_channels),
536 .bitrates = wl_a_rates,
537 .n_bitrates = wl_a_rates_size,
540 static struct ieee80211_supported_band __wl_band_5ghz_n = {
541 .band = IEEE80211_BAND_5GHZ,
542 .channels = __wl_5ghz_n_channels,
543 .n_channels = ARRAY_SIZE(__wl_5ghz_n_channels),
544 .bitrates = wl_a_rates,
545 .n_bitrates = wl_a_rates_size,
548 static const u32 __wl_cipher_suites[] = {
549 WLAN_CIPHER_SUITE_WEP40,
550 WLAN_CIPHER_SUITE_WEP104,
551 WLAN_CIPHER_SUITE_TKIP,
552 WLAN_CIPHER_SUITE_CCMP,
553 WLAN_CIPHER_SUITE_AES_CMAC,
556 static void swap_key_from_BE(struct wl_wsec_key *key)
558 key->index = cpu_to_le32(key->index);
559 key->len = cpu_to_le32(key->len);
560 key->algo = cpu_to_le32(key->algo);
561 key->flags = cpu_to_le32(key->flags);
562 key->rxiv.hi = cpu_to_le32(key->rxiv.hi);
563 key->rxiv.lo = cpu_to_le16(key->rxiv.lo);
564 key->iv_initialized = cpu_to_le32(key->iv_initialized);
567 static void swap_key_to_BE(struct wl_wsec_key *key)
569 key->index = le32_to_cpu(key->index);
570 key->len = le32_to_cpu(key->len);
571 key->algo = le32_to_cpu(key->algo);
572 key->flags = le32_to_cpu(key->flags);
573 key->rxiv.hi = le32_to_cpu(key->rxiv.hi);
574 key->rxiv.lo = le16_to_cpu(key->rxiv.lo);
575 key->iv_initialized = le32_to_cpu(key->iv_initialized);
579 wl_dev_ioctl(struct net_device *dev, u32 cmd, void *arg, u32 len)
586 memset(&ioc, 0, sizeof(ioc));
590 strcpy(ifr.ifr_name, dev->name);
591 ifr.ifr_data = (caddr_t)&ioc;
595 err = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
602 wl_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
603 enum nl80211_iftype type, u32 *flags,
604 struct vif_params *params)
606 struct wl_priv *wl = wiphy_to_wl(wiphy);
607 struct wireless_dev *wdev;
614 case NL80211_IFTYPE_MONITOR:
615 case NL80211_IFTYPE_WDS:
616 WL_ERR("type (%d) : currently we do not support this type\n",
619 case NL80211_IFTYPE_ADHOC:
620 wl->conf->mode = WL_MODE_IBSS;
622 case NL80211_IFTYPE_STATION:
623 wl->conf->mode = WL_MODE_BSS;
629 infra = cpu_to_le32(infra);
630 ap = cpu_to_le32(ap);
631 wdev = ndev->ieee80211_ptr;
633 WL_DBG("%s : ap (%d), infra (%d)\n", ndev->name, ap, infra);
634 err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
636 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
639 err = wl_dev_ioctl(ndev, WLC_SET_AP, &ap, sizeof(ap));
641 WL_ERR("WLC_SET_AP error (%d)\n", err);
645 /* -EINPROGRESS: Call commit handler */
649 static void wl_iscan_prep(struct wl_scan_params *params, struct wlc_ssid *ssid)
651 memcpy(params->bssid, ether_bcast, ETH_ALEN);
652 params->bss_type = DOT11_BSSTYPE_ANY;
653 params->scan_type = 0;
654 params->nprobes = -1;
655 params->active_time = -1;
656 params->passive_time = -1;
657 params->home_time = -1;
658 params->channel_num = 0;
660 params->nprobes = cpu_to_le32(params->nprobes);
661 params->active_time = cpu_to_le32(params->active_time);
662 params->passive_time = cpu_to_le32(params->passive_time);
663 params->home_time = cpu_to_le32(params->home_time);
664 if (ssid && ssid->SSID_len)
665 memcpy(¶ms->ssid, ssid, sizeof(wlc_ssid_t));
670 wl_dev_iovar_setbuf(struct net_device *dev, s8 * iovar, void *param,
671 s32 paramlen, void *bufptr, s32 buflen)
675 iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
678 return wl_dev_ioctl(dev, WLC_SET_VAR, bufptr, iolen);
682 wl_dev_iovar_getbuf(struct net_device *dev, s8 * iovar, void *param,
683 s32 paramlen, void *bufptr, s32 buflen)
687 iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
690 return wl_dev_ioctl(dev, WLC_GET_VAR, bufptr, buflen);
694 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid, u16 action)
697 (WL_SCAN_PARAMS_FIXED_SIZE + offsetof(wl_iscan_params_t, params));
698 struct wl_iscan_params *params;
701 if (ssid && ssid->SSID_len)
702 params_size += sizeof(struct wlc_ssid);
703 params = kzalloc(params_size, GFP_KERNEL);
704 if (unlikely(!params))
706 BUG_ON(params_size >= WLC_IOCTL_SMLEN);
708 wl_iscan_prep(¶ms->params, ssid);
710 params->version = cpu_to_le32(ISCAN_REQ_VERSION);
711 params->action = cpu_to_le16(action);
712 params->scan_duration = cpu_to_le16(0);
714 /* params_size += offsetof(wl_iscan_params_t, params); */
715 err = wl_dev_iovar_setbuf(iscan->dev, "iscan", params, params_size,
716 iscan->ioctl_buf, WLC_IOCTL_SMLEN);
719 WL_INFO("system busy : iscan canceled\n");
721 WL_ERR("error (%d)\n", err);
728 static s32 wl_do_iscan(struct wl_priv *wl)
730 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
731 struct net_device *ndev = wl_to_ndev(wl);
732 struct wlc_ssid ssid;
736 /* Broadcast scan by default */
737 memset(&ssid, 0, sizeof(ssid));
739 iscan->state = WL_ISCAN_STATE_SCANING;
741 passive_scan = wl->active_scan ? 0 : 1;
742 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_SET_PASSIVE_SCAN,
743 &passive_scan, sizeof(passive_scan));
745 WL_DBG("error (%d)\n", err);
749 wl->iscan_kickstart = true;
750 wl_run_iscan(iscan, &ssid, WL_SCAN_ACTION_START);
751 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
758 __wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
759 struct cfg80211_scan_request *request,
760 struct cfg80211_ssid *this_ssid)
762 struct wl_priv *wl = ndev_to_wl(ndev);
763 struct cfg80211_ssid *ssids;
764 struct wl_scan_req *sr = wl_to_sr(wl);
770 if (unlikely(test_bit(WL_STATUS_SCANNING, &wl->status))) {
771 WL_ERR("Scanning already : status (%d)\n", (int)wl->status);
774 if (unlikely(test_bit(WL_STATUS_SCAN_ABORTING, &wl->status))) {
775 WL_ERR("Scanning being aborted : status (%d)\n",
782 if (request) { /* scan bss */
783 ssids = request->ssids;
784 if (wl->iscan_on && (!ssids || !ssids->ssid_len)) { /* for
786 * ssids->ssid_len has
787 * non-zero(ssid string)
789 * Otherwise this is 0.
790 * we do not iscan for
791 * specific scan request
795 } else { /* scan in ibss */
796 /* we don't do iscan in ibss */
799 wl->scan_request = request;
800 set_bit(WL_STATUS_SCANNING, &wl->status);
802 err = wl_do_iscan(wl);
808 WL_DBG("ssid \"%s\", ssid_len (%d)\n",
809 ssids->ssid, ssids->ssid_len);
810 memset(&sr->ssid, 0, sizeof(sr->ssid));
812 min_t(u8, sizeof(sr->ssid.SSID), ssids->ssid_len);
813 if (sr->ssid.SSID_len) {
814 memcpy(sr->ssid.SSID, ssids->ssid, sr->ssid.SSID_len);
815 sr->ssid.SSID_len = cpu_to_le32(sr->ssid.SSID_len);
816 WL_DBG("Specific scan ssid=\"%s\" len=%d\n",
817 sr->ssid.SSID, sr->ssid.SSID_len);
820 WL_DBG("Broadcast scan\n");
822 WL_DBG("sr->ssid.SSID_len (%d)\n", sr->ssid.SSID_len);
823 passive_scan = wl->active_scan ? 0 : 1;
824 err = wl_dev_ioctl(ndev, WLC_SET_PASSIVE_SCAN,
825 &passive_scan, sizeof(passive_scan));
827 WL_ERR("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
831 err = wl_dev_ioctl(ndev, WLC_SCAN, &sr->ssid,
835 WL_INFO("system busy : scan for \"%s\" canceled\n",
838 WL_ERR("WLC_SCAN error (%d)\n", err);
848 clear_bit(WL_STATUS_SCANNING, &wl->status);
849 wl->scan_request = NULL;
854 wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
855 struct cfg80211_scan_request *request)
860 err = __wl_cfg80211_scan(wiphy, ndev, request, NULL);
862 WL_DBG("scan error (%d)\n", err);
869 static s32 wl_dev_intvar_set(struct net_device *dev, s8 *name, s32 val)
871 s8 buf[WLC_IOCTL_SMLEN];
875 val = cpu_to_le32(val);
876 len = bcm_mkiovar(name, (char *)(&val), sizeof(val), buf, sizeof(buf));
879 err = wl_dev_ioctl(dev, WLC_SET_VAR, buf, len);
881 WL_ERR("error (%d)\n", err);
888 wl_dev_intvar_get(struct net_device *dev, s8 *name, s32 *retval)
891 s8 buf[WLC_IOCTL_SMLEN];
899 bcm_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
902 err = wl_dev_ioctl(dev, WLC_GET_VAR, &var, len);
904 WL_ERR("error (%d)\n", err);
906 *retval = le32_to_cpu(var.val);
911 static s32 wl_set_rts(struct net_device *dev, u32 rts_threshold)
915 err = wl_dev_intvar_set(dev, "rtsthresh", rts_threshold);
917 WL_ERR("Error (%d)\n", err);
923 static s32 wl_set_frag(struct net_device *dev, u32 frag_threshold)
927 err = wl_dev_intvar_set(dev, "fragthresh", frag_threshold);
929 WL_ERR("Error (%d)\n", err);
935 static s32 wl_set_retry(struct net_device *dev, u32 retry, bool l)
938 u32 cmd = (l ? WLC_SET_LRL : WLC_SET_SRL);
940 retry = cpu_to_le32(retry);
941 err = wl_dev_ioctl(dev, cmd, &retry, sizeof(retry));
943 WL_ERR("cmd (%d) , error (%d)\n", cmd, err);
949 static s32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
951 struct wl_priv *wl = wiphy_to_wl(wiphy);
952 struct net_device *ndev = wl_to_ndev(wl);
956 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
957 (wl->conf->rts_threshold != wiphy->rts_threshold)) {
958 wl->conf->rts_threshold = wiphy->rts_threshold;
959 err = wl_set_rts(ndev, wl->conf->rts_threshold);
963 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
964 (wl->conf->frag_threshold != wiphy->frag_threshold)) {
965 wl->conf->frag_threshold = wiphy->frag_threshold;
966 err = wl_set_frag(ndev, wl->conf->frag_threshold);
970 if (changed & WIPHY_PARAM_RETRY_LONG
971 && (wl->conf->retry_long != wiphy->retry_long)) {
972 wl->conf->retry_long = wiphy->retry_long;
973 err = wl_set_retry(ndev, wl->conf->retry_long, true);
977 if (changed & WIPHY_PARAM_RETRY_SHORT
978 && (wl->conf->retry_short != wiphy->retry_short)) {
979 wl->conf->retry_short = wiphy->retry_short;
980 err = wl_set_retry(ndev, wl->conf->retry_short, false);
990 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
991 struct cfg80211_ibss_params *params)
993 struct wl_priv *wl = wiphy_to_wl(wiphy);
994 struct cfg80211_bss *bss;
995 struct ieee80211_channel *chan;
996 struct wl_join_params join_params;
997 struct cfg80211_ssid ssid;
1002 if (params->bssid) {
1003 WL_ERR("Invalid bssid\n");
1006 bss = cfg80211_get_ibss(wiphy, NULL, params->ssid, params->ssid_len);
1008 memcpy(ssid.ssid, params->ssid, params->ssid_len);
1009 ssid.ssid_len = params->ssid_len;
1012 (__wl_cfg80211_scan(wiphy, dev, NULL, &ssid) ==
1018 } while (++scan_retry < WL_SCAN_RETRY_MAX);
1019 rtnl_unlock(); /* to allow scan_inform to paropagate
1020 to cfg80211 plane */
1021 schedule_timeout_interruptible(4 * HZ); /* wait 4 secons
1022 till scan done.... */
1024 bss = cfg80211_get_ibss(wiphy, NULL,
1025 params->ssid, params->ssid_len);
1028 wl->ibss_starter = false;
1029 WL_DBG("Found IBSS\n");
1031 wl->ibss_starter = true;
1033 chan = params->channel;
1035 wl->channel = ieee80211_frequency_to_channel(chan->center_freq);
1037 ** Join with specific BSSID and cached SSID
1038 ** If SSID is zero join based on BSSID only
1040 memset(&join_params, 0, sizeof(join_params));
1041 memcpy((void *)join_params.ssid.SSID, (void *)params->ssid,
1043 join_params.ssid.SSID_len = cpu_to_le32(params->ssid_len);
1045 memcpy(&join_params.params.bssid, params->bssid,
1048 memset(&join_params.params.bssid, 0, ETH_ALEN);
1050 err = wl_dev_ioctl(dev, WLC_SET_SSID, &join_params,
1051 sizeof(join_params));
1052 if (unlikely(err)) {
1053 WL_ERR("Error (%d)\n", err);
1059 static s32 wl_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1061 struct wl_priv *wl = wiphy_to_wl(wiphy);
1071 wl_set_wpa_version(struct net_device *dev, struct cfg80211_connect_params *sme)
1073 struct wl_priv *wl = ndev_to_wl(dev);
1074 struct wl_security *sec;
1078 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1079 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1080 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1081 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1083 val = WPA_AUTH_DISABLED;
1084 WL_DBG("setting wpa_auth to 0x%0x\n", val);
1085 err = wl_dev_intvar_set(dev, "wpa_auth", val);
1086 if (unlikely(err)) {
1087 WL_ERR("set wpa_auth failed (%d)\n", err);
1090 sec = wl_read_prof(wl, WL_PROF_SEC);
1091 sec->wpa_versions = sme->crypto.wpa_versions;
1096 wl_set_auth_type(struct net_device *dev, struct cfg80211_connect_params *sme)
1098 struct wl_priv *wl = ndev_to_wl(dev);
1099 struct wl_security *sec;
1103 switch (sme->auth_type) {
1104 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1106 WL_DBG("open system\n");
1108 case NL80211_AUTHTYPE_SHARED_KEY:
1110 WL_DBG("shared key\n");
1112 case NL80211_AUTHTYPE_AUTOMATIC:
1114 WL_DBG("automatic\n");
1116 case NL80211_AUTHTYPE_NETWORK_EAP:
1117 WL_DBG("network eap\n");
1120 WL_ERR("invalid auth type (%d)\n", sme->auth_type);
1124 err = wl_dev_intvar_set(dev, "auth", val);
1125 if (unlikely(err)) {
1126 WL_ERR("set auth failed (%d)\n", err);
1129 sec = wl_read_prof(wl, WL_PROF_SEC);
1130 sec->auth_type = sme->auth_type;
1135 wl_set_set_cipher(struct net_device *dev, struct cfg80211_connect_params *sme)
1137 struct wl_priv *wl = ndev_to_wl(dev);
1138 struct wl_security *sec;
1143 if (sme->crypto.n_ciphers_pairwise) {
1144 switch (sme->crypto.ciphers_pairwise[0]) {
1145 case WLAN_CIPHER_SUITE_WEP40:
1146 case WLAN_CIPHER_SUITE_WEP104:
1149 case WLAN_CIPHER_SUITE_TKIP:
1150 pval = TKIP_ENABLED;
1152 case WLAN_CIPHER_SUITE_CCMP:
1155 case WLAN_CIPHER_SUITE_AES_CMAC:
1159 WL_ERR("invalid cipher pairwise (%d)\n",
1160 sme->crypto.ciphers_pairwise[0]);
1164 if (sme->crypto.cipher_group) {
1165 switch (sme->crypto.cipher_group) {
1166 case WLAN_CIPHER_SUITE_WEP40:
1167 case WLAN_CIPHER_SUITE_WEP104:
1170 case WLAN_CIPHER_SUITE_TKIP:
1171 gval = TKIP_ENABLED;
1173 case WLAN_CIPHER_SUITE_CCMP:
1176 case WLAN_CIPHER_SUITE_AES_CMAC:
1180 WL_ERR("invalid cipher group (%d)\n",
1181 sme->crypto.cipher_group);
1186 WL_DBG("pval (%d) gval (%d)\n", pval, gval);
1187 err = wl_dev_intvar_set(dev, "wsec", pval | gval);
1188 if (unlikely(err)) {
1189 WL_ERR("error (%d)\n", err);
1193 sec = wl_read_prof(wl, WL_PROF_SEC);
1194 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1195 sec->cipher_group = sme->crypto.cipher_group;
1201 wl_set_key_mgmt(struct net_device *dev, struct cfg80211_connect_params *sme)
1203 struct wl_priv *wl = ndev_to_wl(dev);
1204 struct wl_security *sec;
1208 if (sme->crypto.n_akm_suites) {
1209 err = wl_dev_intvar_get(dev, "wpa_auth", &val);
1210 if (unlikely(err)) {
1211 WL_ERR("could not get wpa_auth (%d)\n", err);
1214 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1215 switch (sme->crypto.akm_suites[0]) {
1216 case WLAN_AKM_SUITE_8021X:
1217 val = WPA_AUTH_UNSPECIFIED;
1219 case WLAN_AKM_SUITE_PSK:
1223 WL_ERR("invalid cipher group (%d)\n",
1224 sme->crypto.cipher_group);
1227 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1228 switch (sme->crypto.akm_suites[0]) {
1229 case WLAN_AKM_SUITE_8021X:
1230 val = WPA2_AUTH_UNSPECIFIED;
1232 case WLAN_AKM_SUITE_PSK:
1233 val = WPA2_AUTH_PSK;
1236 WL_ERR("invalid cipher group (%d)\n",
1237 sme->crypto.cipher_group);
1242 WL_DBG("setting wpa_auth to %d\n", val);
1243 err = wl_dev_intvar_set(dev, "wpa_auth", val);
1244 if (unlikely(err)) {
1245 WL_ERR("could not set wpa_auth (%d)\n", err);
1249 sec = wl_read_prof(wl, WL_PROF_SEC);
1250 sec->wpa_auth = sme->crypto.akm_suites[0];
1256 wl_set_set_sharedkey(struct net_device *dev,
1257 struct cfg80211_connect_params *sme)
1259 struct wl_priv *wl = ndev_to_wl(dev);
1260 struct wl_security *sec;
1261 struct wl_wsec_key key;
1265 WL_DBG("key len (%d)\n", sme->key_len);
1267 sec = wl_read_prof(wl, WL_PROF_SEC);
1268 WL_DBG("wpa_versions 0x%x cipher_pairwise 0x%x\n",
1269 sec->wpa_versions, sec->cipher_pairwise);
1271 (sec->wpa_versions & (NL80211_WPA_VERSION_1 |
1272 NL80211_WPA_VERSION_2))
1273 && (sec->cipher_pairwise & (WLAN_CIPHER_SUITE_WEP40 |
1274 WLAN_CIPHER_SUITE_WEP104))) {
1275 memset(&key, 0, sizeof(key));
1276 key.len = (u32) sme->key_len;
1277 key.index = (u32) sme->key_idx;
1278 if (unlikely(key.len > sizeof(key.data))) {
1279 WL_ERR("Too long key length (%u)\n", key.len);
1282 memcpy(key.data, sme->key, key.len);
1283 key.flags = WL_PRIMARY_KEY;
1284 switch (sec->cipher_pairwise) {
1285 case WLAN_CIPHER_SUITE_WEP40:
1286 key.algo = CRYPTO_ALGO_WEP1;
1288 case WLAN_CIPHER_SUITE_WEP104:
1289 key.algo = CRYPTO_ALGO_WEP128;
1292 WL_ERR("Invalid algorithm (%d)\n",
1293 sme->crypto.ciphers_pairwise[0]);
1296 /* Set the new key/index */
1297 WL_DBG("key length (%d) key index (%d) algo (%d)\n",
1298 key.len, key.index, key.algo);
1299 WL_DBG("key \"%s\"\n", key.data);
1300 swap_key_from_BE(&key);
1301 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key,
1303 if (unlikely(err)) {
1304 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1307 if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
1308 WL_DBG("set auth_type to shared key\n");
1309 val = 1; /* shared key */
1310 err = wl_dev_intvar_set(dev, "auth", val);
1311 if (unlikely(err)) {
1312 WL_ERR("set auth failed (%d)\n", err);
1322 wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
1323 struct cfg80211_connect_params *sme)
1325 struct wl_priv *wl = wiphy_to_wl(wiphy);
1326 struct ieee80211_channel *chan = sme->channel;
1327 struct wl_join_params join_params;
1328 size_t join_params_size;
1333 if (unlikely(!sme->ssid)) {
1334 WL_ERR("Invalid ssid\n");
1338 wl->channel = ieee80211_frequency_to_channel(chan->center_freq);
1339 WL_DBG("channel (%d), center_req (%d)\n",
1340 wl->channel, chan->center_freq);
1342 WL_DBG("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1343 err = wl_set_wpa_version(dev, sme);
1347 err = wl_set_auth_type(dev, sme);
1351 err = wl_set_set_cipher(dev, sme);
1355 err = wl_set_key_mgmt(dev, sme);
1359 err = wl_set_set_sharedkey(dev, sme);
1363 wl_update_prof(wl, NULL, sme->bssid, WL_PROF_BSSID);
1365 ** Join with specific BSSID and cached SSID
1366 ** If SSID is zero join based on BSSID only
1368 memset(&join_params, 0, sizeof(join_params));
1369 join_params_size = sizeof(join_params.ssid);
1371 join_params.ssid.SSID_len = min(sizeof(join_params.ssid.SSID), sme->ssid_len);
1372 memcpy(&join_params.ssid.SSID, sme->ssid, join_params.ssid.SSID_len);
1373 join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1374 wl_update_prof(wl, NULL, &join_params.ssid, WL_PROF_SSID);
1375 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1377 wl_ch_to_chanspec(wl->channel, &join_params, &join_params_size);
1378 WL_DBG("join_param_size %zu\n", join_params_size);
1380 if (join_params.ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
1381 WL_DBG("ssid \"%s\", len (%d)\n",
1382 join_params.ssid.SSID, join_params.ssid.SSID_len);
1384 err = wl_dev_ioctl(dev, WLC_SET_SSID, &join_params, join_params_size);
1385 if (unlikely(err)) {
1386 WL_ERR("error (%d)\n", err);
1389 set_bit(WL_STATUS_CONNECTING, &wl->status);
1395 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1398 struct wl_priv *wl = wiphy_to_wl(wiphy);
1403 WL_DBG("Reason %d\n", reason_code);
1405 act = *(bool *) wl_read_prof(wl, WL_PROF_ACT);
1407 scbval.val = reason_code;
1408 memcpy(&scbval.ea, &wl->bssid, ETH_ALEN);
1409 scbval.val = cpu_to_le32(scbval.val);
1410 err = wl_dev_ioctl(dev, WLC_DISASSOC, &scbval,
1412 if (unlikely(err)) {
1413 WL_ERR("error (%d)\n", err);
1422 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
1423 enum nl80211_tx_power_setting type, s32 dbm)
1426 struct wl_priv *wl = wiphy_to_wl(wiphy);
1427 struct net_device *ndev = wl_to_ndev(wl);
1434 case NL80211_TX_POWER_AUTOMATIC:
1436 case NL80211_TX_POWER_LIMITED:
1438 WL_ERR("TX_POWER_LIMITED - dbm is negative\n");
1442 case NL80211_TX_POWER_FIXED:
1444 WL_ERR("TX_POWER_FIXED - dbm is negative\n");
1449 /* Make sure radio is off or on as far as software is concerned */
1450 disable = WL_RADIO_SW_DISABLE << 16;
1451 disable = cpu_to_le32(disable);
1452 err = wl_dev_ioctl(ndev, WLC_SET_RADIO, &disable, sizeof(disable));
1453 if (unlikely(err)) {
1454 WL_ERR("WLC_SET_RADIO error (%d)\n", err);
1461 txpwrmw = (u16) dbm;
1462 err = wl_dev_intvar_set(ndev, "qtxpower",
1463 (s32) (bcm_mw_to_qdbm(txpwrmw)));
1464 if (unlikely(err)) {
1465 WL_ERR("qtxpower error (%d)\n", err);
1468 wl->conf->tx_power = dbm;
1473 static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1475 struct wl_priv *wl = wiphy_to_wl(wiphy);
1476 struct net_device *ndev = wl_to_ndev(wl);
1482 err = wl_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1483 if (unlikely(err)) {
1484 WL_ERR("error (%d)\n", err);
1487 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1488 *dbm = (s32) bcm_qdbm_to_mw(result);
1494 wl_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
1495 u8 key_idx, bool unicast, bool multicast)
1501 WL_DBG("key index (%d)\n", key_idx);
1504 err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
1505 if (unlikely(err)) {
1506 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1509 wsec = le32_to_cpu(wsec);
1510 if (wsec & WEP_ENABLED) {
1511 /* Just select a new current key */
1512 index = (u32) key_idx;
1513 index = cpu_to_le32(index);
1514 err = wl_dev_ioctl(dev, WLC_SET_KEY_PRIMARY, &index,
1516 if (unlikely(err)) {
1517 WL_ERR("error (%d)\n", err);
1524 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
1525 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1527 struct wl_wsec_key key;
1530 memset(&key, 0, sizeof(key));
1531 key.index = (u32) key_idx;
1532 /* Instead of bcast for ea address for default wep keys,
1533 driver needs it to be Null */
1534 if (!is_multicast_ether_addr(mac_addr))
1535 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1536 key.len = (u32) params->key_len;
1537 /* check for key index change */
1540 swap_key_from_BE(&key);
1541 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1542 if (unlikely(err)) {
1543 WL_ERR("key delete error (%d)\n", err);
1547 if (key.len > sizeof(key.data)) {
1548 WL_ERR("Invalid key length (%d)\n", key.len);
1552 WL_DBG("Setting the key index %d\n", key.index);
1553 memcpy(key.data, params->key, key.len);
1555 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1557 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1558 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1559 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1562 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1563 if (params->seq && params->seq_len == 6) {
1566 ivptr = (u8 *) params->seq;
1567 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1568 (ivptr[3] << 8) | ivptr[2];
1569 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1570 key.iv_initialized = true;
1573 switch (params->cipher) {
1574 case WLAN_CIPHER_SUITE_WEP40:
1575 key.algo = CRYPTO_ALGO_WEP1;
1576 WL_DBG("WLAN_CIPHER_SUITE_WEP40\n");
1578 case WLAN_CIPHER_SUITE_WEP104:
1579 key.algo = CRYPTO_ALGO_WEP128;
1580 WL_DBG("WLAN_CIPHER_SUITE_WEP104\n");
1582 case WLAN_CIPHER_SUITE_TKIP:
1583 key.algo = CRYPTO_ALGO_TKIP;
1584 WL_DBG("WLAN_CIPHER_SUITE_TKIP\n");
1586 case WLAN_CIPHER_SUITE_AES_CMAC:
1587 key.algo = CRYPTO_ALGO_AES_CCM;
1588 WL_DBG("WLAN_CIPHER_SUITE_AES_CMAC\n");
1590 case WLAN_CIPHER_SUITE_CCMP:
1591 key.algo = CRYPTO_ALGO_AES_CCM;
1592 WL_DBG("WLAN_CIPHER_SUITE_CCMP\n");
1595 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1598 swap_key_from_BE(&key);
1600 dhd_wait_pend8021x(dev);
1601 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1602 if (unlikely(err)) {
1603 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1611 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
1612 u8 key_idx, bool pairwise, const u8 *mac_addr,
1613 struct key_params *params)
1615 struct wl_wsec_key key;
1620 WL_DBG("key index (%d)\n", key_idx);
1624 return wl_add_keyext(wiphy, dev, key_idx, mac_addr, params);
1625 memset(&key, 0, sizeof(key));
1627 key.len = (u32) params->key_len;
1628 key.index = (u32) key_idx;
1630 if (unlikely(key.len > sizeof(key.data))) {
1631 WL_ERR("Too long key length (%u)\n", key.len);
1634 memcpy(key.data, params->key, key.len);
1636 key.flags = WL_PRIMARY_KEY;
1637 switch (params->cipher) {
1638 case WLAN_CIPHER_SUITE_WEP40:
1639 key.algo = CRYPTO_ALGO_WEP1;
1640 WL_DBG("WLAN_CIPHER_SUITE_WEP40\n");
1642 case WLAN_CIPHER_SUITE_WEP104:
1643 key.algo = CRYPTO_ALGO_WEP128;
1644 WL_DBG("WLAN_CIPHER_SUITE_WEP104\n");
1646 case WLAN_CIPHER_SUITE_TKIP:
1647 key.algo = CRYPTO_ALGO_TKIP;
1648 WL_DBG("WLAN_CIPHER_SUITE_TKIP\n");
1650 case WLAN_CIPHER_SUITE_AES_CMAC:
1651 key.algo = CRYPTO_ALGO_AES_CCM;
1652 WL_DBG("WLAN_CIPHER_SUITE_AES_CMAC\n");
1654 case WLAN_CIPHER_SUITE_CCMP:
1655 key.algo = CRYPTO_ALGO_AES_CCM;
1656 WL_DBG("WLAN_CIPHER_SUITE_CCMP\n");
1659 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1663 /* Set the new key/index */
1664 swap_key_from_BE(&key);
1665 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1666 if (unlikely(err)) {
1667 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1672 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1673 if (unlikely(err)) {
1674 WL_ERR("get wsec error (%d)\n", err);
1677 wsec &= ~(WEP_ENABLED);
1679 err = wl_dev_intvar_set(dev, "wsec", wsec);
1680 if (unlikely(err)) {
1681 WL_ERR("set wsec error (%d)\n", err);
1685 val = 1; /* assume shared key. otherwise 0 */
1686 val = cpu_to_le32(val);
1687 err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
1688 if (unlikely(err)) {
1689 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1696 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
1697 u8 key_idx, bool pairwise, const u8 *mac_addr)
1699 struct wl_wsec_key key;
1705 memset(&key, 0, sizeof(key));
1707 key.index = (u32) key_idx;
1708 key.flags = WL_PRIMARY_KEY;
1709 key.algo = CRYPTO_ALGO_OFF;
1711 WL_DBG("key index (%d)\n", key_idx);
1712 /* Set the new key/index */
1713 swap_key_from_BE(&key);
1714 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1715 if (unlikely(err)) {
1716 if (err == -EINVAL) {
1717 if (key.index >= DOT11_MAX_DEFAULT_KEYS) {
1718 /* we ignore this key index in this case */
1719 WL_DBG("invalid key index (%d)\n", key_idx);
1722 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1728 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1729 if (unlikely(err)) {
1730 WL_ERR("get wsec error (%d)\n", err);
1733 wsec &= ~(WEP_ENABLED);
1735 err = wl_dev_intvar_set(dev, "wsec", wsec);
1736 if (unlikely(err)) {
1737 WL_ERR("set wsec error (%d)\n", err);
1741 val = 0; /* assume open key. otherwise 1 */
1742 val = cpu_to_le32(val);
1743 err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
1744 if (unlikely(err)) {
1745 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1752 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
1753 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
1754 void (*callback) (void *cookie, struct key_params * params))
1756 struct key_params params;
1757 struct wl_wsec_key key;
1758 struct wl_priv *wl = wiphy_to_wl(wiphy);
1759 struct wl_security *sec;
1763 WL_DBG("key index (%d)\n", key_idx);
1766 memset(&key, 0, sizeof(key));
1767 key.index = key_idx;
1768 swap_key_to_BE(&key);
1769 memset(¶ms, 0, sizeof(params));
1770 params.key_len = (u8) min_t(u8, WLAN_MAX_KEY_LEN, key.len);
1771 memcpy(params.key, key.data, params.key_len);
1773 err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
1774 if (unlikely(err)) {
1775 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1778 wsec = le32_to_cpu(wsec);
1781 sec = wl_read_prof(wl, WL_PROF_SEC);
1782 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1783 params.cipher = WLAN_CIPHER_SUITE_WEP40;
1784 WL_DBG("WLAN_CIPHER_SUITE_WEP40\n");
1785 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1786 params.cipher = WLAN_CIPHER_SUITE_WEP104;
1787 WL_DBG("WLAN_CIPHER_SUITE_WEP104\n");
1791 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1792 WL_DBG("WLAN_CIPHER_SUITE_TKIP\n");
1795 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1796 WL_DBG("WLAN_CIPHER_SUITE_AES_CMAC\n");
1799 WL_ERR("Invalid algo (0x%x)\n", wsec);
1803 callback(cookie, ¶ms);
1808 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1809 struct net_device *dev, u8 key_idx)
1811 WL_INFO("Not supported\n");
1817 wl_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
1818 u8 *mac, struct station_info *sinfo)
1820 struct wl_priv *wl = wiphy_to_wl(wiphy);
1828 (memcmp(mac, wl_read_prof(wl, WL_PROF_BSSID), ETH_ALEN))) {
1829 WL_ERR("Wrong Mac address\n");
1833 /* Report the current tx rate */
1834 err = wl_dev_ioctl(dev, WLC_GET_RATE, &rate, sizeof(rate));
1836 WL_ERR("Could not get rate (%d)\n", err);
1838 rate = le32_to_cpu(rate);
1839 sinfo->filled |= STATION_INFO_TX_BITRATE;
1840 sinfo->txrate.legacy = rate * 5;
1841 WL_DBG("Rate %d Mbps\n", rate / 2);
1844 if (test_bit(WL_STATUS_CONNECTED, &wl->status)) {
1846 err = wl_dev_ioctl(dev, WLC_GET_RSSI, &scb_val,
1848 if (unlikely(err)) {
1849 WL_ERR("Could not get rssi (%d)\n", err);
1852 rssi = le32_to_cpu(scb_val.val);
1853 sinfo->filled |= STATION_INFO_SIGNAL;
1854 sinfo->signal = rssi;
1855 WL_DBG("RSSI %d dBm\n", rssi);
1862 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1863 bool enabled, s32 timeout)
1869 pm = enabled ? PM_FAST : PM_OFF;
1870 pm = cpu_to_le32(pm);
1871 WL_DBG("power save %s\n", (pm ? "enabled" : "disabled"));
1872 err = wl_dev_ioctl(dev, WLC_SET_PM, &pm, sizeof(pm));
1873 if (unlikely(err)) {
1875 WL_DBG("net_device is not ready yet\n");
1877 WL_ERR("error (%d)\n", err);
1883 static __used u32 wl_find_msb(u16 bit16)
1887 if (bit16 & 0xff00) {
1911 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
1913 const struct cfg80211_bitrate_mask *mask)
1915 struct wl_rateset rateset;
1924 /* addr param is always NULL. ignore it */
1925 /* Get current rateset */
1926 err = wl_dev_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
1928 if (unlikely(err)) {
1929 WL_ERR("could not get current rateset (%d)\n", err);
1933 rateset.count = le32_to_cpu(rateset.count);
1935 legacy = wl_find_msb(mask->control[IEEE80211_BAND_2GHZ].legacy);
1937 legacy = wl_find_msb(mask->control[IEEE80211_BAND_5GHZ].legacy);
1939 val = wl_g_rates[legacy - 1].bitrate * 100000;
1941 if (val < rateset.count) {
1942 /* Select rate by rateset index */
1943 rate = rateset.rates[val] & 0x7f;
1945 /* Specified rate in bps */
1946 rate = val / 500000;
1949 WL_DBG("rate %d mbps\n", rate / 2);
1953 * Set rate override,
1954 * Since the is a/b/g-blind, both a/bg_rate are enforced.
1956 err_bg = wl_dev_intvar_set(dev, "bg_rate", rate);
1957 err_a = wl_dev_intvar_set(dev, "a_rate", rate);
1958 if (unlikely(err_bg && err_a)) {
1959 WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
1960 return err_bg | err_a;
1966 static s32 wl_cfg80211_resume(struct wiphy *wiphy)
1971 wl_invoke_iscan(wiphy_to_wl(wiphy));
1976 static s32 wl_cfg80211_suspend(struct wiphy *wiphy)
1978 struct wl_priv *wl = wiphy_to_wl(wiphy);
1979 struct net_device *ndev = wl_to_ndev(wl);
1982 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
1984 if (wl->scan_request) {
1985 cfg80211_scan_done(wl->scan_request, true); /* true means
1987 wl_set_mpc(ndev, 1);
1988 wl->scan_request = NULL;
1990 clear_bit(WL_STATUS_SCANNING, &wl->status);
1991 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
1993 sdioh_sdio_set_host_pm_flags(MMC_PM_KEEP_POWER);
1999 wl_update_pmklist(struct net_device *dev, struct wl_pmk_list *pmk_list,
2004 WL_DBG("No of elements %d\n", pmk_list->pmkids.npmkid);
2005 for (i = 0; i < pmk_list->pmkids.npmkid; i++) {
2006 WL_DBG("PMKID[%d]: %pM =\n", i,
2007 &pmk_list->pmkids.pmkid[i].BSSID);
2008 for (j = 0; j < WLAN_PMKID_LEN; j++) {
2009 WL_DBG("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
2013 err = wl_dev_bufvar_set(dev, "pmkid_info", (char *)pmk_list,
2021 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
2022 struct cfg80211_pmksa *pmksa)
2024 struct wl_priv *wl = wiphy_to_wl(wiphy);
2029 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2030 if (!memcmp(pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2033 if (i < WL_NUM_PMKIDS_MAX) {
2034 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID, pmksa->bssid,
2036 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID, pmksa->pmkid,
2038 if (i == wl->pmk_list->pmkids.npmkid)
2039 wl->pmk_list->pmkids.npmkid++;
2043 WL_DBG("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
2044 &wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].BSSID);
2045 for (i = 0; i < WLAN_PMKID_LEN; i++) {
2047 wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].
2051 err = wl_update_pmklist(dev, wl->pmk_list, err);
2057 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
2058 struct cfg80211_pmksa *pmksa)
2060 struct wl_priv *wl = wiphy_to_wl(wiphy);
2061 struct _pmkid_list pmkid;
2066 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2067 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2069 WL_DBG("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2070 &pmkid.pmkid[0].BSSID);
2071 for (i = 0; i < WLAN_PMKID_LEN; i++) {
2072 WL_DBG("%02x\n", pmkid.pmkid[0].PMKID[i]);
2075 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2077 (pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2081 if ((wl->pmk_list->pmkids.npmkid > 0)
2082 && (i < wl->pmk_list->pmkids.npmkid)) {
2083 memset(&wl->pmk_list->pmkids.pmkid[i], 0, sizeof(pmkid_t));
2084 for (; i < (wl->pmk_list->pmkids.npmkid - 1); i++) {
2085 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID,
2086 &wl->pmk_list->pmkids.pmkid[i + 1].BSSID,
2088 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID,
2089 &wl->pmk_list->pmkids.pmkid[i + 1].PMKID,
2092 wl->pmk_list->pmkids.npmkid--;
2097 err = wl_update_pmklist(dev, wl->pmk_list, err);
2104 wl_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *dev)
2106 struct wl_priv *wl = wiphy_to_wl(wiphy);
2110 memset(wl->pmk_list, 0, sizeof(*wl->pmk_list));
2111 err = wl_update_pmklist(dev, wl->pmk_list, err);
2116 static struct cfg80211_ops wl_cfg80211_ops = {
2117 .change_virtual_intf = wl_cfg80211_change_iface,
2118 .scan = wl_cfg80211_scan,
2119 .set_wiphy_params = wl_cfg80211_set_wiphy_params,
2120 .join_ibss = wl_cfg80211_join_ibss,
2121 .leave_ibss = wl_cfg80211_leave_ibss,
2122 .get_station = wl_cfg80211_get_station,
2123 .set_tx_power = wl_cfg80211_set_tx_power,
2124 .get_tx_power = wl_cfg80211_get_tx_power,
2125 .add_key = wl_cfg80211_add_key,
2126 .del_key = wl_cfg80211_del_key,
2127 .get_key = wl_cfg80211_get_key,
2128 .set_default_key = wl_cfg80211_config_default_key,
2129 .set_default_mgmt_key = wl_cfg80211_config_default_mgmt_key,
2130 .set_power_mgmt = wl_cfg80211_set_power_mgmt,
2131 .set_bitrate_mask = wl_cfg80211_set_bitrate_mask,
2132 .connect = wl_cfg80211_connect,
2133 .disconnect = wl_cfg80211_disconnect,
2134 .suspend = wl_cfg80211_suspend,
2135 .resume = wl_cfg80211_resume,
2136 .set_pmksa = wl_cfg80211_set_pmksa,
2137 .del_pmksa = wl_cfg80211_del_pmksa,
2138 .flush_pmksa = wl_cfg80211_flush_pmksa
2141 static s32 wl_mode_to_nl80211_iftype(s32 mode)
2147 return NL80211_IFTYPE_STATION;
2149 return NL80211_IFTYPE_ADHOC;
2151 return NL80211_IFTYPE_UNSPECIFIED;
2157 static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
2160 struct wireless_dev *wdev;
2163 wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2164 if (unlikely(!wdev)) {
2165 WL_ERR("Could not allocate wireless device\n");
2166 return ERR_PTR(-ENOMEM);
2169 wiphy_new(&wl_cfg80211_ops, sizeof(struct wl_priv) + sizeof_iface);
2170 if (unlikely(!wdev->wiphy)) {
2171 WL_ERR("Couldn not allocate wiphy device\n");
2175 set_wiphy_dev(wdev->wiphy, dev);
2176 wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2177 wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2178 wdev->wiphy->interface_modes =
2179 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2180 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2181 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a; /* Set
2182 * it as 11a by default.
2183 * This will be updated with
2186 * if phy has 11n capability
2188 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2189 wdev->wiphy->cipher_suites = __wl_cipher_suites;
2190 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2191 #ifndef WL_POWERSAVE_DISABLED
2192 wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; /* enable power
2197 wdev->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
2198 #endif /* !WL_POWERSAVE_DISABLED */
2199 err = wiphy_register(wdev->wiphy);
2200 if (unlikely(err < 0)) {
2201 WL_ERR("Couldn not register wiphy device (%d)\n", err);
2202 goto wiphy_register_out;
2207 wiphy_free(wdev->wiphy);
2212 return ERR_PTR(err);
2215 static void wl_free_wdev(struct wl_priv *wl)
2217 struct wireless_dev *wdev = wl_to_wdev(wl);
2219 if (unlikely(!wdev)) {
2220 WL_ERR("wdev is invalid\n");
2223 wiphy_unregister(wdev->wiphy);
2224 wiphy_free(wdev->wiphy);
2226 wl_to_wdev(wl) = NULL;
2229 static s32 wl_inform_bss(struct wl_priv *wl)
2231 struct wl_scan_results *bss_list;
2232 struct wl_bss_info *bi = NULL; /* must be initialized */
2236 bss_list = wl->bss_list;
2237 if (unlikely(bss_list->version != WL_BSS_INFO_VERSION)) {
2238 WL_ERR("Version %d != WL_BSS_INFO_VERSION\n",
2242 WL_DBG("scanned AP count (%d)\n", bss_list->count);
2243 bi = next_bss(bss_list, bi);
2244 for_each_bss(bss_list, bi, i) {
2245 err = wl_inform_single_bss(wl, bi);
2252 static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
2254 struct wiphy *wiphy = wl_to_wiphy(wl);
2255 struct ieee80211_mgmt *mgmt;
2256 struct ieee80211_channel *channel;
2257 struct ieee80211_supported_band *band;
2258 struct wl_cfg80211_bss_info *notif_bss_info;
2259 struct wl_scan_req *sr = wl_to_sr(wl);
2260 struct beacon_proberesp *beacon_proberesp;
2266 if (unlikely(le32_to_cpu(bi->length) > WL_BSS_INFO_MAX)) {
2267 WL_DBG("Beacon is larger than buffer. Discarding\n");
2271 kzalloc(sizeof(*notif_bss_info) + sizeof(*mgmt) - sizeof(u8) +
2272 WL_BSS_INFO_MAX, GFP_KERNEL);
2273 if (unlikely(!notif_bss_info)) {
2274 WL_ERR("notif_bss_info alloc failed\n");
2277 mgmt = (struct ieee80211_mgmt *)notif_bss_info->frame_buf;
2278 notif_bss_info->channel =
2279 bi->ctl_ch ? bi->ctl_ch : CHSPEC_CHANNEL(bi->chanspec);
2281 if (notif_bss_info->channel <= CH_MAX_2G_CHANNEL)
2282 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2284 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2285 notif_bss_info->rssi = bi->RSSI;
2286 memcpy(mgmt->bssid, &bi->BSSID, ETH_ALEN);
2287 mgmt_type = wl->active_scan ?
2288 IEEE80211_STYPE_PROBE_RESP : IEEE80211_STYPE_BEACON;
2289 if (!memcmp(bi->SSID, sr->ssid.SSID, bi->SSID_len)) {
2290 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2293 beacon_proberesp = wl->active_scan ?
2294 (struct beacon_proberesp *)&mgmt->u.probe_resp :
2295 (struct beacon_proberesp *)&mgmt->u.beacon;
2296 beacon_proberesp->timestamp = 0;
2297 beacon_proberesp->beacon_int = cpu_to_le16(bi->beacon_period);
2298 beacon_proberesp->capab_info = cpu_to_le16(bi->capability);
2301 * wl_add_ie is not necessary because it can only add duplicated
2302 * SSID, rate information to frame_buf
2305 * wl_add_ie(wl, WLAN_EID_SSID, bi->SSID_len, bi->SSID);
2306 * wl_add_ie(wl, WLAN_EID_SUPP_RATES, bi->rateset.count,
2307 * bi->rateset.rates);
2309 wl_mrg_ie(wl, ((u8 *) bi) + bi->ie_offset, bi->ie_length);
2310 wl_cp_ie(wl, beacon_proberesp->variable, WL_BSS_INFO_MAX -
2311 offsetof(struct wl_cfg80211_bss_info, frame_buf));
2312 notif_bss_info->frame_len =
2313 offsetof(struct ieee80211_mgmt,
2314 u.beacon.variable) + wl_get_ielen(wl);
2315 freq = ieee80211_channel_to_frequency(notif_bss_info->channel,
2318 channel = ieee80211_get_channel(wiphy, freq);
2320 WL_DBG("SSID : \"%s\", rssi %d, channel %d, capability : 0x04%x, bssid %pM\n",
2322 notif_bss_info->rssi, notif_bss_info->channel,
2323 mgmt->u.beacon.capab_info, &bi->BSSID);
2325 signal = notif_bss_info->rssi * 100;
2326 if (unlikely(!cfg80211_inform_bss_frame(wiphy, channel, mgmt,
2328 (notif_bss_info->frame_len),
2329 signal, GFP_KERNEL))) {
2330 WL_ERR("cfg80211_inform_bss_frame error\n");
2331 kfree(notif_bss_info);
2334 kfree(notif_bss_info);
2339 static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e)
2341 u32 event = be32_to_cpu(e->event_type);
2342 u16 flags = be16_to_cpu(e->flags);
2344 if (event == WLC_E_LINK) {
2345 if (flags & WLC_EVENT_MSG_LINK) {
2346 if (wl_is_ibssmode(wl)) {
2347 if (wl_is_ibssstarter(wl)) {
2358 static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e)
2360 u32 event = be32_to_cpu(e->event_type);
2361 u16 flags = be16_to_cpu(e->flags);
2363 if (event == WLC_E_DEAUTH_IND || event == WLC_E_DISASSOC_IND) {
2365 } else if (event == WLC_E_LINK) {
2366 if (!(flags & WLC_EVENT_MSG_LINK))
2373 static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e)
2375 u32 event = be32_to_cpu(e->event_type);
2376 u32 status = be32_to_cpu(e->status);
2378 if (event == WLC_E_SET_SSID || event == WLC_E_LINK) {
2379 if (status == WLC_E_STATUS_NO_NETWORKS)
2387 wl_notify_connect_status(struct wl_priv *wl, struct net_device *ndev,
2388 const wl_event_msg_t *e, void *data)
2393 if (wl_is_linkup(wl, e)) {
2395 if (wl_is_ibssmode(wl)) {
2396 cfg80211_ibss_joined(ndev, (s8 *)&e->addr,
2398 WL_DBG("joined in IBSS network\n");
2400 wl_bss_connect_done(wl, ndev, e, data, true);
2401 WL_DBG("joined in BSS network \"%s\"\n",
2402 ((struct wlc_ssid *)
2403 wl_read_prof(wl, WL_PROF_SSID))->SSID);
2406 wl_update_prof(wl, e, &act, WL_PROF_ACT);
2407 } else if (wl_is_linkdown(wl, e)) {
2408 cfg80211_disconnected(ndev, 0, NULL, 0, GFP_KERNEL);
2409 clear_bit(WL_STATUS_CONNECTED, &wl->status);
2411 wl_init_prof(wl->profile);
2412 } else if (wl_is_nonetwork(wl, e)) {
2413 wl_bss_connect_done(wl, ndev, e, data, false);
2420 wl_notify_roaming_status(struct wl_priv *wl, struct net_device *ndev,
2421 const wl_event_msg_t *e, void *data)
2426 wl_bss_roaming_done(wl, ndev, e, data);
2428 wl_update_prof(wl, e, &act, WL_PROF_ACT);
2434 wl_dev_bufvar_set(struct net_device *dev, s8 *name, s8 *buf, s32 len)
2436 struct wl_priv *wl = ndev_to_wl(dev);
2439 buflen = bcm_mkiovar(name, buf, len, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2442 return wl_dev_ioctl(dev, WLC_SET_VAR, wl->ioctl_buf, buflen);
2446 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
2449 struct wl_priv *wl = ndev_to_wl(dev);
2453 len = bcm_mkiovar(name, NULL, 0, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2455 err = wl_dev_ioctl(dev, WLC_GET_VAR, (void *)wl->ioctl_buf,
2457 if (unlikely(err)) {
2458 WL_ERR("error (%d)\n", err);
2461 memcpy(buf, wl->ioctl_buf, buf_len);
2466 static s32 wl_get_assoc_ies(struct wl_priv *wl)
2468 struct net_device *ndev = wl_to_ndev(wl);
2469 struct wl_assoc_ielen *assoc_info;
2470 struct wl_connect_info *conn_info = wl_to_conn(wl);
2475 err = wl_dev_bufvar_get(ndev, "assoc_info", wl->extra_buf,
2477 if (unlikely(err)) {
2478 WL_ERR("could not get assoc info (%d)\n", err);
2481 assoc_info = (struct wl_assoc_ielen *)wl->extra_buf;
2482 req_len = assoc_info->req_len;
2483 resp_len = assoc_info->resp_len;
2485 err = wl_dev_bufvar_get(ndev, "assoc_req_ies", wl->extra_buf,
2487 if (unlikely(err)) {
2488 WL_ERR("could not get assoc req (%d)\n", err);
2491 conn_info->req_ie_len = req_len;
2493 kmemdup(wl->extra_buf, conn_info->req_ie_len, GFP_KERNEL);
2495 conn_info->req_ie_len = 0;
2496 conn_info->req_ie = NULL;
2499 err = wl_dev_bufvar_get(ndev, "assoc_resp_ies", wl->extra_buf,
2501 if (unlikely(err)) {
2502 WL_ERR("could not get assoc resp (%d)\n", err);
2505 conn_info->resp_ie_len = resp_len;
2506 conn_info->resp_ie =
2507 kmemdup(wl->extra_buf, conn_info->resp_ie_len, GFP_KERNEL);
2509 conn_info->resp_ie_len = 0;
2510 conn_info->resp_ie = NULL;
2512 WL_DBG("req len (%d) resp len (%d)\n",
2513 conn_info->req_ie_len, conn_info->resp_ie_len);
2518 static void wl_ch_to_chanspec(int ch, struct wl_join_params *join_params,
2519 size_t *join_params_size)
2521 chanspec_t chanspec = 0;
2524 join_params->params.chanspec_num = 1;
2525 join_params->params.chanspec_list[0] = ch;
2527 if (join_params->params.chanspec_list[0])
2528 chanspec |= WL_CHANSPEC_BAND_2G;
2530 chanspec |= WL_CHANSPEC_BAND_5G;
2532 chanspec |= WL_CHANSPEC_BW_20;
2533 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
2535 *join_params_size += WL_ASSOC_PARAMS_FIXED_SIZE +
2536 join_params->params.chanspec_num * sizeof(chanspec_t);
2538 join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
2539 join_params->params.chanspec_list[0] |= chanspec;
2540 join_params->params.chanspec_list[0] =
2541 cpu_to_le16(join_params->params.chanspec_list[0]);
2543 join_params->params.chanspec_num =
2544 cpu_to_le32(join_params->params.chanspec_num);
2546 WL_DBG("join_params->params.chanspec_list[0]= %#X, channel %d, chanspec %#X\n",
2547 join_params->params.chanspec_list[0], ch, chanspec);
2551 static s32 wl_update_bss_info(struct wl_priv *wl)
2553 struct cfg80211_bss *bss;
2554 struct wl_bss_info *bi;
2555 struct wlc_ssid *ssid;
2556 struct bcm_tlv *tim;
2557 u16 beacon_interval;
2563 if (wl_is_ibssmode(wl))
2566 ssid = (struct wlc_ssid *)wl_read_prof(wl, WL_PROF_SSID);
2568 cfg80211_get_bss(wl_to_wiphy(wl), NULL, (s8 *)&wl->bssid,
2569 ssid->SSID, ssid->SSID_len, WLAN_CAPABILITY_ESS,
2570 WLAN_CAPABILITY_ESS);
2573 if (unlikely(!bss)) {
2574 WL_DBG("Could not find the AP\n");
2575 *(u32 *) wl->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2576 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_BSS_INFO,
2577 wl->extra_buf, WL_EXTRA_BUF_MAX);
2578 if (unlikely(err)) {
2579 WL_ERR("Could not get bss info %d\n", err);
2580 goto update_bss_info_out;
2582 bi = (struct wl_bss_info *)(wl->extra_buf + 4);
2583 if (unlikely(memcmp(&bi->BSSID, &wl->bssid, ETH_ALEN))) {
2585 goto update_bss_info_out;
2587 err = wl_inform_single_bss(wl, bi);
2589 goto update_bss_info_out;
2591 ie = ((u8 *)bi) + bi->ie_offset;
2592 ie_len = bi->ie_length;
2593 beacon_interval = cpu_to_le16(bi->beacon_period);
2595 WL_DBG("Found the AP in the list - BSSID %pM\n", bss->bssid);
2596 ie = bss->information_elements;
2597 ie_len = bss->len_information_elements;
2598 beacon_interval = bss->beacon_interval;
2599 cfg80211_put_bss(bss);
2602 tim = bcm_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2604 dtim_period = tim->data[1];
2607 * active scan was done so we could not get dtim
2608 * information out of probe response.
2609 * so we speficially query dtim information to dongle.
2611 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_DTIMPRD,
2612 &dtim_period, sizeof(dtim_period));
2613 if (unlikely(err)) {
2614 WL_ERR("WLC_GET_DTIMPRD error (%d)\n", err);
2615 goto update_bss_info_out;
2619 wl_update_prof(wl, NULL, &beacon_interval, WL_PROF_BEACONINT);
2620 wl_update_prof(wl, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
2622 update_bss_info_out:
2628 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
2629 const wl_event_msg_t *e, void *data)
2631 struct wl_connect_info *conn_info = wl_to_conn(wl);
2634 wl_get_assoc_ies(wl);
2635 memcpy(&wl->bssid, &e->addr, ETH_ALEN);
2636 wl_update_bss_info(wl);
2637 cfg80211_roamed(ndev,
2639 conn_info->req_ie, conn_info->req_ie_len,
2640 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
2641 WL_DBG("Report roaming result\n");
2643 set_bit(WL_STATUS_CONNECTED, &wl->status);
2649 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
2650 const wl_event_msg_t *e, void *data, bool completed)
2652 struct wl_connect_info *conn_info = wl_to_conn(wl);
2655 wl_get_assoc_ies(wl);
2656 memcpy(&wl->bssid, &e->addr, ETH_ALEN);
2657 wl_update_bss_info(wl);
2658 if (test_and_clear_bit(WL_STATUS_CONNECTING, &wl->status)) {
2659 cfg80211_connect_result(ndev,
2662 conn_info->req_ie_len,
2664 conn_info->resp_ie_len,
2665 completed ? WLAN_STATUS_SUCCESS : WLAN_STATUS_AUTH_TIMEOUT,
2667 WL_DBG("Report connect result - connection %s\n",
2668 completed ? "succeeded" : "failed");
2670 cfg80211_roamed(ndev,
2672 conn_info->req_ie, conn_info->req_ie_len,
2673 conn_info->resp_ie, conn_info->resp_ie_len,
2675 WL_DBG("Report roaming result\n");
2677 set_bit(WL_STATUS_CONNECTED, &wl->status);
2683 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
2684 const wl_event_msg_t *e, void *data)
2686 u16 flags = be16_to_cpu(e->flags);
2687 enum nl80211_key_type key_type;
2690 if (flags & WLC_EVENT_MSG_GROUP)
2691 key_type = NL80211_KEYTYPE_GROUP;
2693 key_type = NL80211_KEYTYPE_PAIRWISE;
2695 cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
2703 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
2704 const wl_event_msg_t *e, void *data)
2706 struct channel_info channel_inform;
2707 struct wl_scan_results *bss_list;
2708 u32 len = WL_SCAN_BUF_MAX;
2711 if (wl->iscan_on && wl->iscan_kickstart)
2712 return wl_wakeup_iscan(wl_to_iscan(wl));
2714 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
2715 WL_ERR("Scan complete while device not scanning\n");
2718 if (unlikely(!wl->scan_request)) {
2721 err = wl_dev_ioctl(ndev, WLC_GET_CHANNEL, &channel_inform,
2722 sizeof(channel_inform));
2723 if (unlikely(err)) {
2724 WL_ERR("scan busy (%d)\n", err);
2727 channel_inform.scan_channel = le32_to_cpu(channel_inform.scan_channel);
2728 if (unlikely(channel_inform.scan_channel)) {
2730 WL_DBG("channel_inform.scan_channel (%d)\n",
2731 channel_inform.scan_channel);
2733 wl->bss_list = wl->scan_results;
2734 bss_list = wl->bss_list;
2735 memset(bss_list, 0, len);
2736 bss_list->buflen = cpu_to_le32(len);
2737 err = wl_dev_ioctl(ndev, WLC_SCAN_RESULTS, bss_list, len);
2738 if (unlikely(err)) {
2739 WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
2743 bss_list->buflen = le32_to_cpu(bss_list->buflen);
2744 bss_list->version = le32_to_cpu(bss_list->version);
2745 bss_list->count = le32_to_cpu(bss_list->count);
2747 err = wl_inform_bss(wl);
2752 if (wl->scan_request) {
2753 cfg80211_scan_done(wl->scan_request, false);
2754 wl_set_mpc(ndev, 1);
2755 wl->scan_request = NULL;
2761 static void wl_init_conf(struct wl_conf *conf)
2763 conf->mode = (u32)-1;
2764 conf->frag_threshold = (u32)-1;
2765 conf->rts_threshold = (u32)-1;
2766 conf->retry_short = (u32)-1;
2767 conf->retry_long = (u32)-1;
2768 conf->tx_power = -1;
2771 static void wl_init_prof(struct wl_profile *prof)
2773 memset(prof, 0, sizeof(*prof));
2776 static void wl_init_eloop_handler(struct wl_event_loop *el)
2778 memset(el, 0, sizeof(*el));
2779 el->handler[WLC_E_SCAN_COMPLETE] = wl_notify_scan_status;
2780 el->handler[WLC_E_JOIN] = wl_notify_connect_status;
2781 el->handler[WLC_E_LINK] = wl_notify_connect_status;
2782 el->handler[WLC_E_DEAUTH_IND] = wl_notify_connect_status;
2783 el->handler[WLC_E_DISASSOC_IND] = wl_notify_connect_status;
2784 el->handler[WLC_E_ASSOC_IND] = wl_notify_connect_status;
2785 el->handler[WLC_E_REASSOC_IND] = wl_notify_connect_status;
2786 el->handler[WLC_E_ROAM] = wl_notify_roaming_status;
2787 el->handler[WLC_E_MIC_ERROR] = wl_notify_mic_status;
2788 el->handler[WLC_E_SET_SSID] = wl_notify_connect_status;
2791 static s32 wl_init_priv_mem(struct wl_priv *wl)
2793 wl->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
2794 if (unlikely(!wl->scan_results)) {
2795 WL_ERR("Scan results alloc failed\n");
2796 goto init_priv_mem_out;
2798 wl->conf = kzalloc(sizeof(*wl->conf), GFP_KERNEL);
2799 if (unlikely(!wl->conf)) {
2800 WL_ERR("wl_conf alloc failed\n");
2801 goto init_priv_mem_out;
2803 wl->profile = kzalloc(sizeof(*wl->profile), GFP_KERNEL);
2804 if (unlikely(!wl->profile)) {
2805 WL_ERR("wl_profile alloc failed\n");
2806 goto init_priv_mem_out;
2808 wl->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2809 if (unlikely(!wl->bss_info)) {
2810 WL_ERR("Bss information alloc failed\n");
2811 goto init_priv_mem_out;
2813 wl->scan_req_int = kzalloc(sizeof(*wl->scan_req_int), GFP_KERNEL);
2814 if (unlikely(!wl->scan_req_int)) {
2815 WL_ERR("Scan req alloc failed\n");
2816 goto init_priv_mem_out;
2818 wl->ioctl_buf = kzalloc(WL_IOCTL_LEN_MAX, GFP_KERNEL);
2819 if (unlikely(!wl->ioctl_buf)) {
2820 WL_ERR("Ioctl buf alloc failed\n");
2821 goto init_priv_mem_out;
2823 wl->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
2824 if (unlikely(!wl->extra_buf)) {
2825 WL_ERR("Extra buf alloc failed\n");
2826 goto init_priv_mem_out;
2828 wl->iscan = kzalloc(sizeof(*wl->iscan), GFP_KERNEL);
2829 if (unlikely(!wl->iscan)) {
2830 WL_ERR("Iscan buf alloc failed\n");
2831 goto init_priv_mem_out;
2833 wl->fw = kzalloc(sizeof(*wl->fw), GFP_KERNEL);
2834 if (unlikely(!wl->fw)) {
2835 WL_ERR("fw object alloc failed\n");
2836 goto init_priv_mem_out;
2838 wl->pmk_list = kzalloc(sizeof(*wl->pmk_list), GFP_KERNEL);
2839 if (unlikely(!wl->pmk_list)) {
2840 WL_ERR("pmk list alloc failed\n");
2841 goto init_priv_mem_out;
2847 wl_deinit_priv_mem(wl);
2852 static void wl_deinit_priv_mem(struct wl_priv *wl)
2854 kfree(wl->scan_results);
2855 wl->scan_results = NULL;
2856 kfree(wl->bss_info);
2857 wl->bss_info = NULL;
2862 kfree(wl->scan_req_int);
2863 wl->scan_req_int = NULL;
2864 kfree(wl->ioctl_buf);
2865 wl->ioctl_buf = NULL;
2866 kfree(wl->extra_buf);
2867 wl->extra_buf = NULL;
2872 kfree(wl->pmk_list);
2873 wl->pmk_list = NULL;
2876 static s32 wl_create_event_handler(struct wl_priv *wl)
2878 sema_init(&wl->event_sync, 0);
2879 wl->event_tsk = kthread_run(wl_event_handler, wl, "wl_event_handler");
2880 if (IS_ERR(wl->event_tsk)) {
2881 wl->event_tsk = NULL;
2882 WL_ERR("failed to create event thread\n");
2888 static void wl_destroy_event_handler(struct wl_priv *wl)
2890 if (wl->event_tsk) {
2891 send_sig(SIGTERM, wl->event_tsk, 1);
2892 kthread_stop(wl->event_tsk);
2893 wl->event_tsk = NULL;
2897 static void wl_term_iscan(struct wl_priv *wl)
2899 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
2901 if (wl->iscan_on && iscan->tsk) {
2902 iscan->state = WL_ISCAN_STATE_IDLE;
2903 send_sig(SIGTERM, iscan->tsk, 1);
2904 kthread_stop(iscan->tsk);
2909 static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted)
2911 struct wl_priv *wl = iscan_to_wl(iscan);
2912 struct net_device *ndev = wl_to_ndev(wl);
2914 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
2915 WL_ERR("Scan complete while device not scanning\n");
2918 if (likely(wl->scan_request)) {
2919 cfg80211_scan_done(wl->scan_request, aborted);
2920 wl_set_mpc(ndev, 1);
2921 wl->scan_request = NULL;
2923 wl->iscan_kickstart = false;
2926 static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan)
2928 if (likely(iscan->state != WL_ISCAN_STATE_IDLE)) {
2929 WL_DBG("wake up iscan\n");
2938 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
2939 struct wl_scan_results **bss_list)
2941 struct wl_iscan_results list;
2942 struct wl_scan_results *results;
2943 struct wl_iscan_results *list_buf;
2946 memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
2947 list_buf = (struct wl_iscan_results *)iscan->scan_buf;
2948 results = &list_buf->results;
2949 results->buflen = WL_ISCAN_RESULTS_FIXED_SIZE;
2950 results->version = 0;
2953 memset(&list, 0, sizeof(list));
2954 list.results.buflen = cpu_to_le32(WL_ISCAN_BUF_MAX);
2955 err = wl_dev_iovar_getbuf(iscan->dev, "iscanresults", &list,
2956 WL_ISCAN_RESULTS_FIXED_SIZE, iscan->scan_buf,
2958 if (unlikely(err)) {
2959 WL_ERR("error (%d)\n", err);
2962 results->buflen = le32_to_cpu(results->buflen);
2963 results->version = le32_to_cpu(results->version);
2964 results->count = le32_to_cpu(results->count);
2965 WL_DBG("results->count = %d\n", results->count);
2966 WL_DBG("results->buflen = %d\n", results->buflen);
2967 *status = le32_to_cpu(list_buf->status);
2968 *bss_list = results;
2973 static s32 wl_iscan_done(struct wl_priv *wl)
2975 struct wl_iscan_ctrl *iscan = wl->iscan;
2978 iscan->state = WL_ISCAN_STATE_IDLE;
2981 wl_notify_iscan_complete(iscan, false);
2987 static s32 wl_iscan_pending(struct wl_priv *wl)
2989 struct wl_iscan_ctrl *iscan = wl->iscan;
2992 /* Reschedule the timer */
2993 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
2994 iscan->timer_on = 1;
2999 static s32 wl_iscan_inprogress(struct wl_priv *wl)
3001 struct wl_iscan_ctrl *iscan = wl->iscan;
3006 wl_run_iscan(iscan, NULL, WL_SCAN_ACTION_CONTINUE);
3008 /* Reschedule the timer */
3009 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3010 iscan->timer_on = 1;
3015 static s32 wl_iscan_aborted(struct wl_priv *wl)
3017 struct wl_iscan_ctrl *iscan = wl->iscan;
3020 iscan->state = WL_ISCAN_STATE_IDLE;
3022 wl_notify_iscan_complete(iscan, true);
3028 static s32 wl_iscan_thread(void *data)
3030 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3031 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
3032 struct wl_priv *wl = iscan_to_wl(iscan);
3033 struct wl_iscan_eloop *el = &iscan->el;
3037 sched_setscheduler(current, SCHED_FIFO, ¶m);
3038 allow_signal(SIGTERM);
3039 status = WL_SCAN_RESULTS_PARTIAL;
3040 while (likely(!down_interruptible(&iscan->sync))) {
3041 if (kthread_should_stop())
3043 if (iscan->timer_on) {
3044 del_timer_sync(&iscan->timer);
3045 iscan->timer_on = 0;
3048 err = wl_get_iscan_results(iscan, &status, &wl->bss_list);
3049 if (unlikely(err)) {
3050 status = WL_SCAN_RESULTS_ABORTED;
3051 WL_ERR("Abort iscan\n");
3054 el->handler[status] (wl);
3056 if (iscan->timer_on) {
3057 del_timer_sync(&iscan->timer);
3058 iscan->timer_on = 0;
3060 WL_DBG("%s was terminated\n", __func__);
3065 static void wl_iscan_timer(unsigned long data)
3067 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
3070 iscan->timer_on = 0;
3071 WL_DBG("timer expired\n");
3072 wl_wakeup_iscan(iscan);
3076 static s32 wl_invoke_iscan(struct wl_priv *wl)
3078 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3081 if (wl->iscan_on && !iscan->tsk) {
3082 iscan->state = WL_ISCAN_STATE_IDLE;
3083 sema_init(&iscan->sync, 0);
3084 iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
3085 if (IS_ERR(iscan->tsk)) {
3086 WL_ERR("Could not create iscan thread\n");
3095 static void wl_init_iscan_eloop(struct wl_iscan_eloop *el)
3097 memset(el, 0, sizeof(*el));
3098 el->handler[WL_SCAN_RESULTS_SUCCESS] = wl_iscan_done;
3099 el->handler[WL_SCAN_RESULTS_PARTIAL] = wl_iscan_inprogress;
3100 el->handler[WL_SCAN_RESULTS_PENDING] = wl_iscan_pending;
3101 el->handler[WL_SCAN_RESULTS_ABORTED] = wl_iscan_aborted;
3102 el->handler[WL_SCAN_RESULTS_NO_MEM] = wl_iscan_aborted;
3105 static s32 wl_init_iscan(struct wl_priv *wl)
3107 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3111 iscan->dev = wl_to_ndev(wl);
3112 iscan->state = WL_ISCAN_STATE_IDLE;
3113 wl_init_iscan_eloop(&iscan->el);
3114 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
3115 init_timer(&iscan->timer);
3116 iscan->timer.data = (unsigned long) iscan;
3117 iscan->timer.function = wl_iscan_timer;
3118 sema_init(&iscan->sync, 0);
3119 iscan->tsk = kthread_run(wl_iscan_thread, iscan, "wl_iscan");
3120 if (IS_ERR(iscan->tsk)) {
3121 WL_ERR("Could not create iscan thread\n");
3131 static void wl_init_fw(struct wl_fw_ctrl *fw)
3133 fw->status = 0; /* init fw loading status.
3134 0 means nothing was loaded yet */
3137 static s32 wl_init_priv(struct wl_priv *wl)
3139 struct wiphy *wiphy = wl_to_wiphy(wl);
3142 wl->scan_request = NULL;
3143 wl->pwr_save = !!(wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT);
3144 wl->iscan_on = true; /* iscan on & off switch.
3145 we enable iscan per default */
3146 wl->roam_on = false; /* roam on & off switch.
3147 we enable roam per default */
3149 wl->iscan_kickstart = false;
3150 wl->active_scan = true; /* we do active scan for
3151 specific scan per default */
3152 wl->dongle_up = false; /* dongle is not up yet */
3154 err = wl_init_priv_mem(wl);
3157 if (unlikely(wl_create_event_handler(wl)))
3159 wl_init_eloop_handler(&wl->el);
3160 mutex_init(&wl->usr_sync);
3161 err = wl_init_iscan(wl);
3165 wl_init_conf(wl->conf);
3166 wl_init_prof(wl->profile);
3172 static void wl_deinit_priv(struct wl_priv *wl)
3174 wl_destroy_event_handler(wl);
3175 wl->dongle_up = false; /* dongle down */
3179 wl_deinit_priv_mem(wl);
3182 s32 wl_cfg80211_attach(struct net_device *ndev, void *data)
3184 struct wireless_dev *wdev;
3186 struct wl_iface *ci;
3189 if (unlikely(!ndev)) {
3190 WL_ERR("ndev is invalid\n");
3193 wl_cfg80211_dev = kzalloc(sizeof(struct wl_dev), GFP_KERNEL);
3194 if (unlikely(!wl_cfg80211_dev)) {
3195 WL_ERR("wl_cfg80211_dev is invalid\n");
3198 WL_DBG("func %p\n", wl_cfg80211_get_sdio_func());
3199 wdev = wl_alloc_wdev(sizeof(struct wl_iface), &wl_cfg80211_get_sdio_func()->dev);
3203 wdev->iftype = wl_mode_to_nl80211_iftype(WL_MODE_BSS);
3204 wl = wdev_to_wl(wdev);
3207 ci = (struct wl_iface *)wl_to_ci(wl);
3209 ndev->ieee80211_ptr = wdev;
3210 SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
3211 wdev->netdev = ndev;
3212 err = wl_init_priv(wl);
3213 if (unlikely(err)) {
3214 WL_ERR("Failed to init iwm_priv (%d)\n", err);
3215 goto cfg80211_attach_out;
3217 wl_set_drvdata(wl_cfg80211_dev, ci);
3218 set_bit(WL_STATUS_READY, &wl->status);
3222 cfg80211_attach_out:
3227 void wl_cfg80211_detach(void)
3235 wl_set_drvdata(wl_cfg80211_dev, NULL);
3236 kfree(wl_cfg80211_dev);
3237 wl_cfg80211_dev = NULL;
3238 wl_clear_sdio_func();
3241 static void wl_wakeup_event(struct wl_priv *wl)
3243 up(&wl->event_sync);
3246 static s32 wl_event_handler(void *data)
3248 struct wl_priv *wl = (struct wl_priv *)data;
3249 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3250 struct wl_event_q *e;
3252 sched_setscheduler(current, SCHED_FIFO, ¶m);
3253 allow_signal(SIGTERM);
3254 while (likely(!down_interruptible(&wl->event_sync))) {
3255 if (kthread_should_stop())
3257 e = wl_deq_event(wl);
3259 WL_ERR("event queue empty...\n");
3262 WL_DBG("event type (%d)\n", e->etype);
3263 if (wl->el.handler[e->etype]) {
3264 wl->el.handler[e->etype] (wl, wl_to_ndev(wl), &e->emsg,
3267 WL_DBG("Unknown Event (%d): ignoring\n", e->etype);
3271 WL_DBG("%s was terminated\n", __func__);
3276 wl_cfg80211_event(struct net_device *ndev, const wl_event_msg_t * e, void *data)
3278 u32 event_type = be32_to_cpu(e->event_type);
3279 struct wl_priv *wl = ndev_to_wl(ndev);
3280 #if (WL_DBG_LEVEL > 0)
3281 s8 *estr = (event_type <= sizeof(wl_dbg_estr) / WL_DBG_ESTR_MAX - 1) ?
3282 wl_dbg_estr[event_type] : (s8 *) "Unknown";
3283 #endif /* (WL_DBG_LEVEL > 0) */
3284 WL_DBG("event_type (%d):" "WLC_E_" "%s\n", event_type, estr);
3285 if (likely(!wl_enq_event(wl, event_type, e, data)))
3286 wl_wakeup_event(wl);
3289 static void wl_init_eq(struct wl_priv *wl)
3291 wl_init_eq_lock(wl);
3292 INIT_LIST_HEAD(&wl->eq_list);
3295 static void wl_flush_eq(struct wl_priv *wl)
3297 struct wl_event_q *e;
3300 while (!list_empty(&wl->eq_list)) {
3301 e = list_first_entry(&wl->eq_list, struct wl_event_q, eq_list);
3302 list_del(&e->eq_list);
3309 * retrieve first queued event from head
3312 static struct wl_event_q *wl_deq_event(struct wl_priv *wl)
3314 struct wl_event_q *e = NULL;
3317 if (likely(!list_empty(&wl->eq_list))) {
3318 e = list_first_entry(&wl->eq_list, struct wl_event_q, eq_list);
3319 list_del(&e->eq_list);
3327 ** push event to tail of the queue
3331 wl_enq_event(struct wl_priv *wl, u32 event, const wl_event_msg_t *msg,
3334 struct wl_event_q *e;
3337 e = kzalloc(sizeof(struct wl_event_q), GFP_KERNEL);
3339 WL_ERR("event alloc failed\n");
3344 memcpy(&e->emsg, msg, sizeof(wl_event_msg_t));
3348 list_add_tail(&e->eq_list, &wl->eq_list);
3354 static void wl_put_event(struct wl_event_q *e)
3359 void wl_cfg80211_sdio_func(void *func)
3361 cfg80211_sdio_func = (struct sdio_func *)func;
3364 static void wl_clear_sdio_func(void)
3366 cfg80211_sdio_func = NULL;
3369 struct sdio_func *wl_cfg80211_get_sdio_func(void)
3371 return cfg80211_sdio_func;
3374 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype)
3381 case NL80211_IFTYPE_MONITOR:
3382 case NL80211_IFTYPE_WDS:
3383 WL_ERR("type (%d) : currently we do not support this mode\n",
3387 case NL80211_IFTYPE_ADHOC:
3389 case NL80211_IFTYPE_STATION:
3394 WL_ERR("invalid type (%d)\n", iftype);
3397 infra = cpu_to_le32(infra);
3398 ap = cpu_to_le32(ap);
3399 WL_DBG("%s ap (%d), infra (%d)\n", ndev->name, ap, infra);
3400 err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
3401 if (unlikely(err)) {
3402 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
3405 err = wl_dev_ioctl(ndev, WLC_SET_AP, &ap, sizeof(ap));
3406 if (unlikely(err)) {
3407 WL_ERR("WLC_SET_AP error (%d)\n", err);
3411 return -EINPROGRESS;
3414 #ifndef EMBEDDED_PLATFORM
3415 static s32 wl_dongle_country(struct net_device *ndev, u8 ccode)
3423 static s32 wl_dongle_up(struct net_device *ndev, u32 up)
3427 err = wl_dev_ioctl(ndev, WLC_UP, &up, sizeof(up));
3428 if (unlikely(err)) {
3429 WL_ERR("WLC_UP error (%d)\n", err);
3434 static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode)
3438 err = wl_dev_ioctl(ndev, WLC_SET_PM, &power_mode, sizeof(power_mode));
3439 if (unlikely(err)) {
3440 WL_ERR("WLC_SET_PM error (%d)\n", err);
3446 wl_dongle_glom(struct net_device *ndev, u32 glom, u32 dongle_align)
3448 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3452 /* Match Host and Dongle rx alignment */
3453 bcm_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf,
3455 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3456 if (unlikely(err)) {
3457 WL_ERR("txglomalign error (%d)\n", err);
3458 goto dongle_glom_out;
3460 /* disable glom option per default */
3461 bcm_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));
3462 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3463 if (unlikely(err)) {
3464 WL_ERR("txglom error (%d)\n", err);
3465 goto dongle_glom_out;
3472 wl_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
3474 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3478 /* Setup timeout if Beacons are lost and roam is
3479 off to report link down */
3481 bcm_mkiovar("bcn_timeout", (char *)&bcn_timeout, 4, iovbuf,
3483 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3484 if (unlikely(err)) {
3485 WL_ERR("bcn_timeout error (%d)\n", err);
3486 goto dongle_rom_out;
3489 /* Enable/Disable built-in roaming to allow supplicant
3490 to take care of roaming */
3491 bcm_mkiovar("roam_off", (char *)&roamvar, 4, iovbuf, sizeof(iovbuf));
3492 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3493 if (unlikely(err)) {
3494 WL_ERR("roam_off error (%d)\n", err);
3495 goto dongle_rom_out;
3501 static s32 wl_dongle_eventmsg(struct net_device *ndev)
3504 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3506 s8 eventmask[WL_EVENTING_MASK_LEN];
3509 /* Setup event_msgs */
3510 bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
3512 err = wl_dev_ioctl(ndev, WLC_GET_VAR, iovbuf, sizeof(iovbuf));
3513 if (unlikely(err)) {
3514 WL_ERR("Get event_msgs error (%d)\n", err);
3515 goto dongle_eventmsg_out;
3517 memcpy(eventmask, iovbuf, WL_EVENTING_MASK_LEN);
3519 setbit(eventmask, WLC_E_SET_SSID);
3520 setbit(eventmask, WLC_E_PRUNE);
3521 setbit(eventmask, WLC_E_AUTH);
3522 setbit(eventmask, WLC_E_REASSOC);
3523 setbit(eventmask, WLC_E_REASSOC_IND);
3524 setbit(eventmask, WLC_E_DEAUTH_IND);
3525 setbit(eventmask, WLC_E_DISASSOC_IND);
3526 setbit(eventmask, WLC_E_DISASSOC);
3527 setbit(eventmask, WLC_E_JOIN);
3528 setbit(eventmask, WLC_E_ASSOC_IND);
3529 setbit(eventmask, WLC_E_PSK_SUP);
3530 setbit(eventmask, WLC_E_LINK);
3531 setbit(eventmask, WLC_E_NDIS_LINK);
3532 setbit(eventmask, WLC_E_MIC_ERROR);
3533 setbit(eventmask, WLC_E_PMKID_CACHE);
3534 setbit(eventmask, WLC_E_TXFAIL);
3535 setbit(eventmask, WLC_E_JOIN_START);
3536 setbit(eventmask, WLC_E_SCAN_COMPLETE);
3538 bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
3540 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3541 if (unlikely(err)) {
3542 WL_ERR("Set event_msgs error (%d)\n", err);
3543 goto dongle_eventmsg_out;
3546 dongle_eventmsg_out:
3551 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
3552 s32 scan_unassoc_time)
3556 err = wl_dev_ioctl(ndev, WLC_SET_SCAN_CHANNEL_TIME, &scan_assoc_time,
3557 sizeof(scan_assoc_time));
3559 if (err == -EOPNOTSUPP) {
3560 WL_INFO("Scan assoc time is not supported\n");
3562 WL_ERR("Scan assoc time error (%d)\n", err);
3564 goto dongle_scantime_out;
3566 err = wl_dev_ioctl(ndev, WLC_SET_SCAN_UNASSOC_TIME, &scan_unassoc_time,
3567 sizeof(scan_unassoc_time));
3569 if (err == -EOPNOTSUPP) {
3570 WL_INFO("Scan unassoc time is not supported\n");
3572 WL_ERR("Scan unassoc time error (%d)\n", err);
3574 goto dongle_scantime_out;
3577 dongle_scantime_out:
3582 wl_dongle_offload(struct net_device *ndev, s32 arpoe, s32 arp_ol)
3584 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3588 /* Set ARP offload */
3589 bcm_mkiovar("arpoe", (char *)&arpoe, 4, iovbuf, sizeof(iovbuf));
3590 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3592 if (err == -EOPNOTSUPP)
3593 WL_INFO("arpoe is not supported\n");
3595 WL_ERR("arpoe error (%d)\n", err);
3597 goto dongle_offload_out;
3599 bcm_mkiovar("arp_ol", (char *)&arp_ol, 4, iovbuf, sizeof(iovbuf));
3600 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3602 if (err == -EOPNOTSUPP)
3603 WL_INFO("arp_ol is not supported\n");
3605 WL_ERR("arp_ol error (%d)\n", err);
3607 goto dongle_offload_out;
3614 static s32 wl_pattern_atoh(s8 *src, s8 *dst)
3617 if (strncmp(src, "0x", 2) != 0 && strncmp(src, "0X", 2) != 0) {
3618 WL_ERR("Mask invalid format. Needs to start with 0x\n");
3621 src = src + 2; /* Skip past 0x */
3622 if (strlen(src) % 2 != 0) {
3623 WL_ERR("Mask invalid format. Needs to be of even length\n");
3626 for (i = 0; *src != '\0'; i++) {
3628 strncpy(num, src, 2);
3630 dst[i] = (u8) simple_strtoul(num, NULL, 16);
3636 static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode)
3638 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3641 struct wl_pkt_filter pkt_filter;
3642 struct wl_pkt_filter *pkt_filterp;
3650 /* add a default packet filter pattern */
3651 str = "pkt_filter_add";
3652 str_len = strlen(str);
3653 strncpy(buf, str, str_len);
3654 buf[str_len] = '\0';
3655 buf_len = str_len + 1;
3657 pkt_filterp = (struct wl_pkt_filter *)(buf + str_len + 1);
3659 /* Parse packet filter id. */
3660 pkt_filter.id = cpu_to_le32(100);
3662 /* Parse filter polarity. */
3663 pkt_filter.negate_match = cpu_to_le32(0);
3665 /* Parse filter type. */
3666 pkt_filter.type = cpu_to_le32(0);
3668 /* Parse pattern filter offset. */
3669 pkt_filter.u.pattern.offset = cpu_to_le32(0);
3671 /* Parse pattern filter mask. */
3672 mask_size = cpu_to_le32(wl_pattern_atoh("0xff",
3673 (char *)pkt_filterp->u.pattern.
3676 /* Parse pattern filter pattern. */
3677 pattern_size = cpu_to_le32(wl_pattern_atoh("0x00",
3678 (char *)&pkt_filterp->u.
3683 if (mask_size != pattern_size) {
3684 WL_ERR("Mask and pattern not the same size\n");
3686 goto dongle_filter_out;
3689 pkt_filter.u.pattern.size_bytes = mask_size;
3690 buf_len += WL_PKT_FILTER_FIXED_LEN;
3691 buf_len += (WL_PKT_FILTER_PATTERN_FIXED_LEN + 2 * mask_size);
3693 /* Keep-alive attributes are set in local
3694 * variable (keep_alive_pkt), and
3695 * then memcpy'ed into buffer (keep_alive_pktp) since there is no
3696 * guarantee that the buffer is properly aligned.
3698 memcpy((char *)pkt_filterp, &pkt_filter,
3699 WL_PKT_FILTER_FIXED_LEN + WL_PKT_FILTER_PATTERN_FIXED_LEN);
3701 err = wl_dev_ioctl(ndev, WLC_SET_VAR, buf, buf_len);
3703 if (err == -EOPNOTSUPP) {
3704 WL_INFO("filter not supported\n");
3706 WL_ERR("filter (%d)\n", err);
3708 goto dongle_filter_out;
3711 /* set mode to allow pattern */
3712 bcm_mkiovar("pkt_filter_mode", (char *)&filter_mode, 4, iovbuf,
3714 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3716 if (err == -EOPNOTSUPP) {
3717 WL_INFO("filter_mode not supported\n");
3719 WL_ERR("filter_mode (%d)\n", err);
3721 goto dongle_filter_out;
3727 #endif /* !EMBEDDED_PLATFORM */
3729 s32 wl_config_dongle(struct wl_priv *wl, bool need_lock)
3732 #define DHD_SDALIGN 32
3734 struct net_device *ndev;
3735 struct wireless_dev *wdev;
3741 ndev = wl_to_ndev(wl);
3742 wdev = ndev->ieee80211_ptr;
3746 #ifndef EMBEDDED_PLATFORM
3747 err = wl_dongle_up(ndev, 0);
3749 goto default_conf_out;
3750 err = wl_dongle_country(ndev, 0);
3752 goto default_conf_out;
3753 err = wl_dongle_power(ndev, PM_FAST);
3755 goto default_conf_out;
3756 err = wl_dongle_glom(ndev, 0, DHD_SDALIGN);
3758 goto default_conf_out;
3759 err = wl_dongle_roam(ndev, (wl->roam_on ? 0 : 1), 3);
3761 goto default_conf_out;
3762 err = wl_dongle_eventmsg(ndev);
3764 goto default_conf_out;
3766 wl_dongle_scantime(ndev, 40, 80);
3767 wl_dongle_offload(ndev, 1, 0xf);
3768 wl_dongle_filter(ndev, 1);
3769 #endif /* !EMBEDDED_PLATFORM */
3771 err = wl_dongle_mode(ndev, wdev->iftype);
3772 if (unlikely(err && err != -EINPROGRESS))
3773 goto default_conf_out;
3774 err = wl_dongle_probecap(wl);
3776 goto default_conf_out;
3778 /* -EINPROGRESS: Call commit handler */
3784 wl->dongle_up = true;
3790 static s32 wl_update_wiphybands(struct wl_priv *wl)
3792 struct wiphy *wiphy;
3797 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_PHYLIST, &phy_list,
3799 if (unlikely(err)) {
3800 WL_ERR("error (%d)\n", err);
3804 phy = ((char *)&phy_list)[1];
3805 WL_DBG("%c phy\n", phy);
3806 if (phy == 'n' || phy == 'a') {
3807 wiphy = wl_to_wiphy(wl);
3808 wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
3814 static s32 __wl_cfg80211_up(struct wl_priv *wl)
3818 wl_debugfs_add_netdev_params(wl);
3820 err = wl_config_dongle(wl, false);
3824 wl_invoke_iscan(wl);
3825 set_bit(WL_STATUS_READY, &wl->status);
3829 static s32 __wl_cfg80211_down(struct wl_priv *wl)
3833 /* Check if cfg80211 interface is already down */
3834 if (!test_bit(WL_STATUS_READY, &wl->status))
3835 return err; /* it is even not ready */
3837 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
3839 if (wl->scan_request) {
3840 cfg80211_scan_done(wl->scan_request, true); /* true
3842 /* wl_set_mpc(wl_to_ndev(wl), 1); */ /* BUG
3843 * this operation cannot help
3844 * but here because sdio
3845 * is already down through
3847 * Need to figure out how to
3848 * address this issue
3850 wl->scan_request = NULL;
3852 clear_bit(WL_STATUS_READY, &wl->status);
3853 clear_bit(WL_STATUS_SCANNING, &wl->status);
3854 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
3855 clear_bit(WL_STATUS_CONNECTED, &wl->status);
3857 wl_debugfs_remove_netdev(wl);
3862 s32 wl_cfg80211_up(void)
3868 mutex_lock(&wl->usr_sync);
3869 err = __wl_cfg80211_up(wl);
3870 mutex_unlock(&wl->usr_sync);
3875 s32 wl_cfg80211_down(void)
3881 mutex_lock(&wl->usr_sync);
3882 err = __wl_cfg80211_down(wl);
3883 mutex_unlock(&wl->usr_sync);
3888 static s32 wl_dongle_probecap(struct wl_priv *wl)
3892 err = wl_update_wiphybands(wl);
3899 static void *wl_read_prof(struct wl_priv *wl, s32 item)
3903 return &wl->profile->sec;
3905 return &wl->profile->active;
3907 return &wl->profile->bssid;
3909 return &wl->profile->ssid;
3911 WL_ERR("invalid item (%d)\n", item);
3916 wl_update_prof(struct wl_priv *wl, const wl_event_msg_t *e, void *data,
3920 struct wlc_ssid *ssid;
3924 ssid = (wlc_ssid_t *) data;
3925 memset(wl->profile->ssid.SSID, 0,
3926 sizeof(wl->profile->ssid.SSID));
3927 memcpy(wl->profile->ssid.SSID, ssid->SSID, ssid->SSID_len);
3928 wl->profile->ssid.SSID_len = ssid->SSID_len;
3932 memcpy(wl->profile->bssid, data, ETH_ALEN);
3934 memset(wl->profile->bssid, 0, ETH_ALEN);
3937 memcpy(&wl->profile->sec, data, sizeof(wl->profile->sec));
3940 wl->profile->active = *(bool *)data;
3942 case WL_PROF_BEACONINT:
3943 wl->profile->beacon_interval = *(u16 *)data;
3945 case WL_PROF_DTIMPERIOD:
3946 wl->profile->dtim_period = *(u8 *)data;
3949 WL_ERR("unsupported item (%d)\n", item);
3957 void wl_cfg80211_dbg_level(u32 level)
3960 * prohibit to change debug level
3961 * by insmod parameter.
3962 * eventually debug level will be configured
3963 * in compile time by using CONFIG_XXX
3965 /* wl_dbg_level = level; */
3968 static bool wl_is_ibssmode(struct wl_priv *wl)
3970 return wl->conf->mode == WL_MODE_IBSS;
3973 static bool wl_is_ibssstarter(struct wl_priv *wl)
3975 return wl->ibss_starter;
3978 static void wl_rst_ie(struct wl_priv *wl)
3980 struct wl_ie *ie = wl_to_ie(wl);
3985 static __used s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v)
3987 struct wl_ie *ie = wl_to_ie(wl);
3990 if (unlikely(ie->offset + l + 2 > WL_TLV_INFO_MAX)) {
3991 WL_ERR("ei crosses buffer boundary\n");
3994 ie->buf[ie->offset] = t;
3995 ie->buf[ie->offset + 1] = l;
3996 memcpy(&ie->buf[ie->offset + 2], v, l);
3997 ie->offset += l + 2;
4002 static s32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, u16 ie_size)
4004 struct wl_ie *ie = wl_to_ie(wl);
4007 if (unlikely(ie->offset + ie_size > WL_TLV_INFO_MAX)) {
4008 WL_ERR("ei_stream crosses buffer boundary\n");
4011 memcpy(&ie->buf[ie->offset], ie_stream, ie_size);
4012 ie->offset += ie_size;
4017 static s32 wl_cp_ie(struct wl_priv *wl, u8 *dst, u16 dst_size)
4019 struct wl_ie *ie = wl_to_ie(wl);
4022 if (unlikely(ie->offset > dst_size)) {
4023 WL_ERR("dst_size is not enough\n");
4026 memcpy(dst, &ie->buf[0], ie->offset);
4031 static u32 wl_get_ielen(struct wl_priv *wl)
4033 struct wl_ie *ie = wl_to_ie(wl);
4038 static void wl_link_up(struct wl_priv *wl)
4043 static void wl_link_down(struct wl_priv *wl)
4045 struct wl_connect_info *conn_info = wl_to_conn(wl);
4047 wl->link_up = false;
4048 kfree(conn_info->req_ie);
4049 conn_info->req_ie = NULL;
4050 conn_info->req_ie_len = 0;
4051 kfree(conn_info->resp_ie);
4052 conn_info->resp_ie = NULL;
4053 conn_info->resp_ie_len = 0;
4056 static void wl_lock_eq(struct wl_priv *wl)
4058 spin_lock_irq(&wl->eq_lock);
4061 static void wl_unlock_eq(struct wl_priv *wl)
4063 spin_unlock_irq(&wl->eq_lock);
4066 static void wl_init_eq_lock(struct wl_priv *wl)
4068 spin_lock_init(&wl->eq_lock);
4071 static void wl_delay(u32 ms)
4073 if (ms < 1000 / HZ) {
4081 static void wl_set_drvdata(struct wl_dev *dev, void *data)
4083 dev->driver_data = data;
4086 static void *wl_get_drvdata(struct wl_dev *dev)
4088 return dev->driver_data;
4091 s32 wl_cfg80211_read_fw(s8 *buf, u32 size)
4093 const struct firmware *fw_entry;
4098 fw_entry = wl->fw->fw_entry;
4100 if (fw_entry->size < wl->fw->ptr + size)
4101 size = fw_entry->size - wl->fw->ptr;
4103 memcpy(buf, &fw_entry->data[wl->fw->ptr], size);
4104 wl->fw->ptr += size;
4108 void wl_cfg80211_release_fw(void)
4113 release_firmware(wl->fw->fw_entry);
4117 void *wl_cfg80211_request_fw(s8 *file_name)
4120 const struct firmware *fw_entry = NULL;
4123 WL_DBG("file name : \"%s\"\n", file_name);
4126 if (!test_bit(WL_FW_LOADING_DONE, &wl->fw->status)) {
4127 err = request_firmware(&wl->fw->fw_entry, file_name,
4128 &wl_cfg80211_get_sdio_func()->dev);
4129 if (unlikely(err)) {
4130 WL_ERR("Could not download fw (%d)\n", err);
4133 set_bit(WL_FW_LOADING_DONE, &wl->fw->status);
4134 fw_entry = wl->fw->fw_entry;
4136 WL_DBG("fw size (%zd), data (%p)\n",
4137 fw_entry->size, fw_entry->data);
4139 } else if (!test_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status)) {
4140 err = request_firmware(&wl->fw->fw_entry, file_name,
4141 &wl_cfg80211_get_sdio_func()->dev);
4142 if (unlikely(err)) {
4143 WL_ERR("Could not download nvram (%d)\n", err);
4146 set_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status);
4147 fw_entry = wl->fw->fw_entry;
4149 WL_DBG("nvram size (%zd), data (%p)\n",
4150 fw_entry->size, fw_entry->data);
4153 WL_DBG("Downloading already done. Nothing to do more\n");
4158 if (unlikely(err)) {
4162 return (void *)fw_entry->data;
4165 s8 *wl_cfg80211_get_fwname(void)
4170 strcpy(wl->fw->fw_name, WL_4329_FW_FILE);
4171 return wl->fw->fw_name;
4174 s8 *wl_cfg80211_get_nvramname(void)
4179 strcpy(wl->fw->nvram_name, WL_4329_NVRAM_FILE);
4180 return wl->fw->nvram_name;
4183 static void wl_set_mpc(struct net_device *ndev, int mpc)
4187 err = wl_dev_intvar_set(ndev, "mpc", mpc);
4188 if (unlikely(err)) {
4189 WL_ERR("fail to set mpc\n");
4192 WL_DBG("MPC : %d\n", mpc);
4195 static int wl_debugfs_add_netdev_params(struct wl_priv *wl)
4197 char buf[10+IFNAMSIZ];
4201 sprintf(buf, "netdev:%s", wl_to_ndev(wl)->name);
4202 wl->debugfsdir = debugfs_create_dir(buf, wl_to_wiphy(wl)->debugfsdir);
4204 fd = debugfs_create_u16("beacon_int", S_IRUGO, wl->debugfsdir,
4205 (u16 *)&wl->profile->beacon_interval);
4211 fd = debugfs_create_u8("dtim_period", S_IRUGO, wl->debugfsdir,
4212 (u8 *)&wl->profile->dtim_period);
4222 static void wl_debugfs_remove_netdev(struct wl_priv *wl)
4224 debugfs_remove_recursive(wl->debugfsdir);
4225 wl->debugfsdir = NULL;