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.
22 #include <bcmendian.h>
23 #include <proto/ethernet.h>
25 #include <linux/if_arp.h>
26 #include <asm/uaccess.h>
28 #include <dngl_stats.h>
33 #include <proto/ethernet.h>
34 #include <dngl_stats.h>
37 #include <linux/kernel.h>
38 #include <linux/netdevice.h>
39 #include <linux/sched.h>
40 #include <linux/etherdevice.h>
41 #include <linux/wireless.h>
42 #include <linux/ieee80211.h>
43 #include <net/cfg80211.h>
45 #include <net/rtnetlink.h>
46 #include <linux/mmc/sdio_func.h>
47 #include <linux/firmware.h>
48 #include <wl_cfg80211.h>
50 static struct sdio_func *cfg80211_sdio_func;
51 static struct wl_dev *wl_cfg80211_dev;
53 u32 wl_dbg_level = WL_DBG_ERR | WL_DBG_INFO;
55 #define WL_4329_FW_FILE "brcm/bcm4329-fullmac-4-218-248-5.bin"
56 #define WL_4329_NVRAM_FILE "brcm/bcm4329-fullmac-4-218-248-5.txt"
59 ** cfg80211_ops api/callback list
61 static s32 wl_cfg80211_change_iface(struct wiphy *wiphy,
62 struct net_device *ndev,
63 enum nl80211_iftype type, u32 *flags,
64 struct vif_params *params);
65 static s32 __wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
66 struct cfg80211_scan_request *request,
67 struct cfg80211_ssid *this_ssid);
68 static s32 wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
69 struct cfg80211_scan_request *request);
70 static s32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed);
71 static s32 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
72 struct cfg80211_ibss_params *params);
73 static s32 wl_cfg80211_leave_ibss(struct wiphy *wiphy,
74 struct net_device *dev);
75 static s32 wl_cfg80211_get_station(struct wiphy *wiphy,
76 struct net_device *dev, u8 *mac,
77 struct station_info *sinfo);
78 static s32 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy,
79 struct net_device *dev, bool enabled,
81 static s32 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
82 struct net_device *dev,
84 const struct cfg80211_bitrate_mask
86 static int wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
87 struct cfg80211_connect_params *sme);
88 static s32 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
90 static s32 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
91 enum nl80211_tx_power_setting type,
93 static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm);
94 static s32 wl_cfg80211_config_default_key(struct wiphy *wiphy,
95 struct net_device *dev,
97 static s32 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
98 u8 key_idx, const u8 *mac_addr,
99 struct key_params *params);
100 static s32 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
101 u8 key_idx, const u8 *mac_addr);
102 static s32 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
103 u8 key_idx, const u8 *mac_addr,
104 void *cookie, void (*callback) (void *cookie,
108 static s32 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
109 struct net_device *dev,
111 static s32 wl_cfg80211_resume(struct wiphy *wiphy);
112 static s32 wl_cfg80211_suspend(struct wiphy *wiphy);
113 static s32 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
114 struct cfg80211_pmksa *pmksa);
115 static s32 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
116 struct cfg80211_pmksa *pmksa);
117 static s32 wl_cfg80211_flush_pmksa(struct wiphy *wiphy,
118 struct net_device *dev);
120 ** event & event Q handlers for cfg80211 interfaces
122 static s32 wl_create_event_handler(struct wl_priv *wl);
123 static void wl_destroy_event_handler(struct wl_priv *wl);
124 static s32 wl_event_handler(void *data);
125 static void wl_init_eq(struct wl_priv *wl);
126 static void wl_flush_eq(struct wl_priv *wl);
127 static void wl_lock_eq(struct wl_priv *wl);
128 static void wl_unlock_eq(struct wl_priv *wl);
129 static void wl_init_eq_lock(struct wl_priv *wl);
130 static void wl_init_eloop_handler(struct wl_event_loop *el);
131 static struct wl_event_q *wl_deq_event(struct wl_priv *wl);
132 static s32 wl_enq_event(struct wl_priv *wl, u32 type,
133 const wl_event_msg_t *msg, void *data);
134 static void wl_put_event(struct wl_event_q *e);
135 static void wl_wakeup_event(struct wl_priv *wl);
136 static s32 wl_notify_connect_status(struct wl_priv *wl,
137 struct net_device *ndev,
138 const wl_event_msg_t *e, void *data);
139 static s32 wl_notify_roaming_status(struct wl_priv *wl,
140 struct net_device *ndev,
141 const wl_event_msg_t *e, void *data);
142 static s32 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
143 const wl_event_msg_t *e, void *data);
144 static s32 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
145 const wl_event_msg_t *e, void *data,
147 static s32 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
148 const wl_event_msg_t *e, void *data);
149 static s32 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
150 const wl_event_msg_t *e, void *data);
153 ** register/deregister sdio function
155 struct sdio_func *wl_cfg80211_get_sdio_func(void);
156 static void wl_clear_sdio_func(void);
161 static s32 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
163 static __used s32 wl_dev_bufvar_set(struct net_device *dev, s8 *name,
165 static s32 wl_dev_intvar_set(struct net_device *dev, s8 *name, s32 val);
166 static s32 wl_dev_intvar_get(struct net_device *dev, s8 *name,
168 static s32 wl_dev_ioctl(struct net_device *dev, u32 cmd, void *arg,
172 ** cfg80211 set_wiphy_params utilities
174 static s32 wl_set_frag(struct net_device *dev, u32 frag_threshold);
175 static s32 wl_set_rts(struct net_device *dev, u32 frag_threshold);
176 static s32 wl_set_retry(struct net_device *dev, u32 retry, bool l);
179 ** wl profile utilities
181 static s32 wl_update_prof(struct wl_priv *wl, const wl_event_msg_t *e,
182 void *data, s32 item);
183 static void *wl_read_prof(struct wl_priv *wl, s32 item);
184 static void wl_init_prof(struct wl_profile *prof);
187 ** cfg80211 connect utilites
189 static s32 wl_set_wpa_version(struct net_device *dev,
190 struct cfg80211_connect_params *sme);
191 static s32 wl_set_auth_type(struct net_device *dev,
192 struct cfg80211_connect_params *sme);
193 static s32 wl_set_set_cipher(struct net_device *dev,
194 struct cfg80211_connect_params *sme);
195 static s32 wl_set_key_mgmt(struct net_device *dev,
196 struct cfg80211_connect_params *sme);
197 static s32 wl_set_set_sharedkey(struct net_device *dev,
198 struct cfg80211_connect_params *sme);
199 static s32 wl_get_assoc_ies(struct wl_priv *wl);
202 ** information element utilities
204 static void wl_rst_ie(struct wl_priv *wl);
205 static s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v);
206 static s32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, u16 ie_size);
207 static s32 wl_cp_ie(struct wl_priv *wl, u8 *dst, u16 dst_size);
208 static u32 wl_get_ielen(struct wl_priv *wl);
210 static s32 wl_mode_to_nl80211_iftype(s32 mode);
212 static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
214 static void wl_free_wdev(struct wl_priv *wl);
216 static s32 wl_inform_bss(struct wl_priv *wl);
217 static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi);
218 static s32 wl_update_bss_info(struct wl_priv *wl);
220 static s32 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
221 u8 key_idx, const u8 *mac_addr,
222 struct key_params *params);
225 ** key indianess swap utilities
227 static void swap_key_from_BE(struct wl_wsec_key *key);
228 static void swap_key_to_BE(struct wl_wsec_key *key);
231 ** wl_priv memory init/deinit utilities
233 static s32 wl_init_priv_mem(struct wl_priv *wl);
234 static void wl_deinit_priv_mem(struct wl_priv *wl);
236 static void wl_delay(u32 ms);
239 ** store/restore cfg80211 instance data
241 static void wl_set_drvdata(struct wl_dev *dev, void *data);
242 static void *wl_get_drvdata(struct wl_dev *dev);
245 ** ibss mode utilities
247 static bool wl_is_ibssmode(struct wl_priv *wl);
248 static bool wl_is_ibssstarter(struct wl_priv *wl);
251 ** dongle up/down , default configuration utilities
253 static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e);
254 static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e);
255 static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e);
256 static void wl_link_up(struct wl_priv *wl);
257 static void wl_link_down(struct wl_priv *wl);
258 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
259 static s32 __wl_cfg80211_up(struct wl_priv *wl);
260 static s32 __wl_cfg80211_down(struct wl_priv *wl);
261 static s32 wl_dongle_probecap(struct wl_priv *wl);
262 static void wl_init_conf(struct wl_conf *conf);
265 ** dongle configuration utilities
267 #ifndef EMBEDDED_PLATFORM
268 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype);
269 static s32 wl_dongle_country(struct net_device *ndev, u8 ccode);
270 static s32 wl_dongle_up(struct net_device *ndev, u32 up);
271 static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode);
272 static s32 wl_dongle_glom(struct net_device *ndev, u32 glom,
274 static s32 wl_dongle_roam(struct net_device *ndev, u32 roamvar,
276 static s32 wl_dongle_eventmsg(struct net_device *ndev);
277 static s32 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
278 s32 scan_unassoc_time);
279 static s32 wl_dongle_offload(struct net_device *ndev, s32 arpoe,
281 static s32 wl_pattern_atoh(s8 *src, s8 *dst);
282 static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode);
283 static s32 wl_update_wiphybands(struct wl_priv *wl);
284 #endif /* !EMBEDDED_PLATFORM */
285 static s32 wl_config_dongle(struct wl_priv *wl, bool need_lock);
290 static void wl_iscan_timer(unsigned long data);
291 static void wl_term_iscan(struct wl_priv *wl);
292 static s32 wl_init_iscan(struct wl_priv *wl);
293 static s32 wl_iscan_thread(void *data);
294 static s32 wl_dev_iovar_setbuf(struct net_device *dev, s8 *iovar,
295 void *param, s32 paramlen, void *bufptr,
297 static s32 wl_dev_iovar_getbuf(struct net_device *dev, s8 *iovar,
298 void *param, s32 paramlen, void *bufptr,
300 static s32 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid,
302 static s32 wl_do_iscan(struct wl_priv *wl);
303 static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan);
304 static s32 wl_invoke_iscan(struct wl_priv *wl);
305 static s32 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
306 struct wl_scan_results **bss_list);
307 static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted);
308 static void wl_init_iscan_eloop(struct wl_iscan_eloop *el);
309 static s32 wl_iscan_done(struct wl_priv *wl);
310 static s32 wl_iscan_pending(struct wl_priv *wl);
311 static s32 wl_iscan_inprogress(struct wl_priv *wl);
312 static s32 wl_iscan_aborted(struct wl_priv *wl);
315 ** fw/nvram downloading handler
317 static void wl_init_fw(struct wl_fw_ctrl *fw);
320 * find most significant bit set
322 static __used u32 wl_find_msb(u16 bit16);
325 * update pmklist to dongle
327 static __used s32 wl_update_pmklist(struct net_device *dev,
328 struct wl_pmk_list *pmk_list, s32 err);
330 #define WL_PRIV_GET() \
332 struct wl_iface *ci; \
333 if (unlikely(!(wl_cfg80211_dev && \
334 (ci = wl_get_drvdata(wl_cfg80211_dev))))) { \
335 WL_ERR(("wl_cfg80211_dev is unavailable\n")); \
341 #define CHECK_SYS_UP() \
343 struct wl_priv *wl = wiphy_to_wl(wiphy); \
344 if (unlikely(!test_bit(WL_STATUS_READY, &wl->status))) { \
345 WL_INFO(("device is not ready : status (%d)\n", \
351 extern int dhd_wait_pend8021x(struct net_device *dev);
353 #if (WL_DBG_LEVEL > 0)
354 #define WL_DBG_ESTR_MAX 32
355 static s8 wl_dbg_estr[][WL_DBG_ESTR_MAX] = {
356 "SET_SSID", "JOIN", "START", "AUTH", "AUTH_IND",
357 "DEAUTH", "DEAUTH_IND", "ASSOC", "ASSOC_IND", "REASSOC",
358 "REASSOC_IND", "DISASSOC", "DISASSOC_IND", "QUIET_START", "QUIET_END",
359 "BEACON_RX", "LINK", "MIC_ERROR", "NDIS_LINK", "ROAM",
360 "TXFAIL", "PMKID_CACHE", "RETROGRADE_TSF", "PRUNE", "AUTOAUTH",
361 "EAPOL_MSG", "SCAN_COMPLETE", "ADDTS_IND", "DELTS_IND", "BCNSENT_IND",
362 "BCNRX_MSG", "BCNLOST_MSG", "ROAM_PREP", "PFN_NET_FOUND",
364 "RESET_COMPLETE", "JOIN_START", "ROAM_START", "ASSOC_START",
366 "RADIO", "PSM_WATCHDOG",
368 "SCAN_CONFIRM_IND", "PSK_SUP", "COUNTRY_CODE_CHANGED",
369 "EXCEEDED_MEDIUM_TIME", "ICV_ERROR",
370 "UNICAST_DECODE_ERROR", "MULTICAST_DECODE_ERROR", "TRACE",
372 "RSSI", "PFN_SCAN_COMPLETE", "ACTION_FRAME", "ACTION_FRAME_COMPLETE",
374 #endif /* WL_DBG_LEVEL */
376 #define CHAN2G(_channel, _freq, _flags) { \
377 .band = IEEE80211_BAND_2GHZ, \
378 .center_freq = (_freq), \
379 .hw_value = (_channel), \
381 .max_antenna_gain = 0, \
385 #define CHAN5G(_channel, _flags) { \
386 .band = IEEE80211_BAND_5GHZ, \
387 .center_freq = 5000 + (5 * (_channel)), \
388 .hw_value = (_channel), \
390 .max_antenna_gain = 0, \
394 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
395 #define RATETAB_ENT(_rateid, _flags) \
397 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
398 .hw_value = (_rateid), \
402 static struct ieee80211_rate __wl_rates[] = {
403 RATETAB_ENT(WLC_RATE_1M, 0),
404 RATETAB_ENT(WLC_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
405 RATETAB_ENT(WLC_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
406 RATETAB_ENT(WLC_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
407 RATETAB_ENT(WLC_RATE_6M, 0),
408 RATETAB_ENT(WLC_RATE_9M, 0),
409 RATETAB_ENT(WLC_RATE_12M, 0),
410 RATETAB_ENT(WLC_RATE_18M, 0),
411 RATETAB_ENT(WLC_RATE_24M, 0),
412 RATETAB_ENT(WLC_RATE_36M, 0),
413 RATETAB_ENT(WLC_RATE_48M, 0),
414 RATETAB_ENT(WLC_RATE_54M, 0),
417 #define wl_a_rates (__wl_rates + 4)
418 #define wl_a_rates_size 8
419 #define wl_g_rates (__wl_rates + 0)
420 #define wl_g_rates_size 12
422 static struct ieee80211_channel __wl_2ghz_channels[] = {
439 static struct ieee80211_channel __wl_5ghz_a_channels[] = {
440 CHAN5G(34, 0), CHAN5G(36, 0),
441 CHAN5G(38, 0), CHAN5G(40, 0),
442 CHAN5G(42, 0), CHAN5G(44, 0),
443 CHAN5G(46, 0), CHAN5G(48, 0),
444 CHAN5G(52, 0), CHAN5G(56, 0),
445 CHAN5G(60, 0), CHAN5G(64, 0),
446 CHAN5G(100, 0), CHAN5G(104, 0),
447 CHAN5G(108, 0), CHAN5G(112, 0),
448 CHAN5G(116, 0), CHAN5G(120, 0),
449 CHAN5G(124, 0), CHAN5G(128, 0),
450 CHAN5G(132, 0), CHAN5G(136, 0),
451 CHAN5G(140, 0), CHAN5G(149, 0),
452 CHAN5G(153, 0), CHAN5G(157, 0),
453 CHAN5G(161, 0), CHAN5G(165, 0),
454 CHAN5G(184, 0), CHAN5G(188, 0),
455 CHAN5G(192, 0), CHAN5G(196, 0),
456 CHAN5G(200, 0), CHAN5G(204, 0),
457 CHAN5G(208, 0), CHAN5G(212, 0),
461 static struct ieee80211_channel __wl_5ghz_n_channels[] = {
462 CHAN5G(32, 0), CHAN5G(34, 0),
463 CHAN5G(36, 0), CHAN5G(38, 0),
464 CHAN5G(40, 0), CHAN5G(42, 0),
465 CHAN5G(44, 0), CHAN5G(46, 0),
466 CHAN5G(48, 0), CHAN5G(50, 0),
467 CHAN5G(52, 0), CHAN5G(54, 0),
468 CHAN5G(56, 0), CHAN5G(58, 0),
469 CHAN5G(60, 0), CHAN5G(62, 0),
470 CHAN5G(64, 0), CHAN5G(66, 0),
471 CHAN5G(68, 0), CHAN5G(70, 0),
472 CHAN5G(72, 0), CHAN5G(74, 0),
473 CHAN5G(76, 0), CHAN5G(78, 0),
474 CHAN5G(80, 0), CHAN5G(82, 0),
475 CHAN5G(84, 0), CHAN5G(86, 0),
476 CHAN5G(88, 0), CHAN5G(90, 0),
477 CHAN5G(92, 0), CHAN5G(94, 0),
478 CHAN5G(96, 0), CHAN5G(98, 0),
479 CHAN5G(100, 0), CHAN5G(102, 0),
480 CHAN5G(104, 0), CHAN5G(106, 0),
481 CHAN5G(108, 0), CHAN5G(110, 0),
482 CHAN5G(112, 0), CHAN5G(114, 0),
483 CHAN5G(116, 0), CHAN5G(118, 0),
484 CHAN5G(120, 0), CHAN5G(122, 0),
485 CHAN5G(124, 0), CHAN5G(126, 0),
486 CHAN5G(128, 0), CHAN5G(130, 0),
487 CHAN5G(132, 0), CHAN5G(134, 0),
488 CHAN5G(136, 0), CHAN5G(138, 0),
489 CHAN5G(140, 0), CHAN5G(142, 0),
490 CHAN5G(144, 0), CHAN5G(145, 0),
491 CHAN5G(146, 0), CHAN5G(147, 0),
492 CHAN5G(148, 0), CHAN5G(149, 0),
493 CHAN5G(150, 0), CHAN5G(151, 0),
494 CHAN5G(152, 0), CHAN5G(153, 0),
495 CHAN5G(154, 0), CHAN5G(155, 0),
496 CHAN5G(156, 0), CHAN5G(157, 0),
497 CHAN5G(158, 0), CHAN5G(159, 0),
498 CHAN5G(160, 0), CHAN5G(161, 0),
499 CHAN5G(162, 0), CHAN5G(163, 0),
500 CHAN5G(164, 0), CHAN5G(165, 0),
501 CHAN5G(166, 0), CHAN5G(168, 0),
502 CHAN5G(170, 0), CHAN5G(172, 0),
503 CHAN5G(174, 0), CHAN5G(176, 0),
504 CHAN5G(178, 0), CHAN5G(180, 0),
505 CHAN5G(182, 0), CHAN5G(184, 0),
506 CHAN5G(186, 0), CHAN5G(188, 0),
507 CHAN5G(190, 0), CHAN5G(192, 0),
508 CHAN5G(194, 0), CHAN5G(196, 0),
509 CHAN5G(198, 0), CHAN5G(200, 0),
510 CHAN5G(202, 0), CHAN5G(204, 0),
511 CHAN5G(206, 0), CHAN5G(208, 0),
512 CHAN5G(210, 0), CHAN5G(212, 0),
513 CHAN5G(214, 0), CHAN5G(216, 0),
514 CHAN5G(218, 0), CHAN5G(220, 0),
515 CHAN5G(222, 0), CHAN5G(224, 0),
516 CHAN5G(226, 0), CHAN5G(228, 0),
519 static struct ieee80211_supported_band __wl_band_2ghz = {
520 .band = IEEE80211_BAND_2GHZ,
521 .channels = __wl_2ghz_channels,
522 .n_channels = ARRAY_SIZE(__wl_2ghz_channels),
523 .bitrates = wl_g_rates,
524 .n_bitrates = wl_g_rates_size,
527 static struct ieee80211_supported_band __wl_band_5ghz_a = {
528 .band = IEEE80211_BAND_5GHZ,
529 .channels = __wl_5ghz_a_channels,
530 .n_channels = ARRAY_SIZE(__wl_5ghz_a_channels),
531 .bitrates = wl_a_rates,
532 .n_bitrates = wl_a_rates_size,
535 static struct ieee80211_supported_band __wl_band_5ghz_n = {
536 .band = IEEE80211_BAND_5GHZ,
537 .channels = __wl_5ghz_n_channels,
538 .n_channels = ARRAY_SIZE(__wl_5ghz_n_channels),
539 .bitrates = wl_a_rates,
540 .n_bitrates = wl_a_rates_size,
543 static const u32 __wl_cipher_suites[] = {
544 WLAN_CIPHER_SUITE_WEP40,
545 WLAN_CIPHER_SUITE_WEP104,
546 WLAN_CIPHER_SUITE_TKIP,
547 WLAN_CIPHER_SUITE_CCMP,
548 WLAN_CIPHER_SUITE_AES_CMAC,
551 static void swap_key_from_BE(struct wl_wsec_key *key)
553 key->index = htod32(key->index);
554 key->len = htod32(key->len);
555 key->algo = htod32(key->algo);
556 key->flags = htod32(key->flags);
557 key->rxiv.hi = htod32(key->rxiv.hi);
558 key->rxiv.lo = htod16(key->rxiv.lo);
559 key->iv_initialized = htod32(key->iv_initialized);
562 static void swap_key_to_BE(struct wl_wsec_key *key)
564 key->index = dtoh32(key->index);
565 key->len = dtoh32(key->len);
566 key->algo = dtoh32(key->algo);
567 key->flags = dtoh32(key->flags);
568 key->rxiv.hi = dtoh32(key->rxiv.hi);
569 key->rxiv.lo = dtoh16(key->rxiv.lo);
570 key->iv_initialized = dtoh32(key->iv_initialized);
574 wl_dev_ioctl(struct net_device *dev, u32 cmd, void *arg, u32 len)
581 memset(&ioc, 0, sizeof(ioc));
585 strcpy(ifr.ifr_name, dev->name);
586 ifr.ifr_data = (caddr_t)&ioc;
590 err = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
597 wl_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
598 enum nl80211_iftype type, u32 *flags,
599 struct vif_params *params)
601 struct wl_priv *wl = wiphy_to_wl(wiphy);
602 struct wireless_dev *wdev;
609 case NL80211_IFTYPE_MONITOR:
610 case NL80211_IFTYPE_WDS:
611 WL_ERR(("type (%d) : currently we do not support this type\n",
614 case NL80211_IFTYPE_ADHOC:
615 wl->conf->mode = WL_MODE_IBSS;
617 case NL80211_IFTYPE_STATION:
618 wl->conf->mode = WL_MODE_BSS;
624 infra = htod32(infra);
626 wdev = ndev->ieee80211_ptr;
628 WL_DBG(("%s : ap (%d), infra (%d)\n", ndev->name, ap, infra));
629 err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
631 WL_ERR(("WLC_SET_INFRA error (%d)\n", err));
634 err = wl_dev_ioctl(ndev, WLC_SET_AP, &ap, sizeof(ap));
636 WL_ERR(("WLC_SET_AP error (%d)\n", err));
640 /* -EINPROGRESS: Call commit handler */
644 static void wl_iscan_prep(struct wl_scan_params *params, struct wlc_ssid *ssid)
646 memcpy(¶ms->bssid, ðer_bcast, ETHER_ADDR_LEN);
647 params->bss_type = DOT11_BSSTYPE_ANY;
648 params->scan_type = 0;
649 params->nprobes = -1;
650 params->active_time = -1;
651 params->passive_time = -1;
652 params->home_time = -1;
653 params->channel_num = 0;
655 params->nprobes = htod32(params->nprobes);
656 params->active_time = htod32(params->active_time);
657 params->passive_time = htod32(params->passive_time);
658 params->home_time = htod32(params->home_time);
659 if (ssid && ssid->SSID_len)
660 memcpy(¶ms->ssid, ssid, sizeof(wlc_ssid_t));
665 wl_dev_iovar_setbuf(struct net_device *dev, s8 * iovar, void *param,
666 s32 paramlen, void *bufptr, s32 buflen)
670 iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
671 BUG_ON(unlikely(!iolen));
673 return wl_dev_ioctl(dev, WLC_SET_VAR, bufptr, iolen);
677 wl_dev_iovar_getbuf(struct net_device *dev, s8 * iovar, void *param,
678 s32 paramlen, void *bufptr, s32 buflen)
682 iolen = bcm_mkiovar(iovar, param, paramlen, bufptr, buflen);
683 BUG_ON(unlikely(!iolen));
685 return wl_dev_ioctl(dev, WLC_GET_VAR, bufptr, buflen);
689 wl_run_iscan(struct wl_iscan_ctrl *iscan, struct wlc_ssid *ssid, u16 action)
692 (WL_SCAN_PARAMS_FIXED_SIZE + OFFSETOF(wl_iscan_params_t, params));
693 struct wl_iscan_params *params;
696 if (ssid && ssid->SSID_len)
697 params_size += sizeof(struct wlc_ssid);
698 params = (struct wl_iscan_params *)kzalloc(params_size, GFP_KERNEL);
699 if (unlikely(!params))
701 memset(params, 0, params_size);
702 BUG_ON(unlikely(params_size >= WLC_IOCTL_SMLEN));
704 wl_iscan_prep(¶ms->params, ssid);
706 params->version = htod32(ISCAN_REQ_VERSION);
707 params->action = htod16(action);
708 params->scan_duration = htod16(0);
710 /* params_size += OFFSETOF(wl_iscan_params_t, params); */
711 err = wl_dev_iovar_setbuf(iscan->dev, "iscan", params, params_size,
712 iscan->ioctl_buf, WLC_IOCTL_SMLEN);
715 WL_INFO(("system busy : iscan canceled\n"));
717 WL_ERR(("error (%d)\n", err));
724 static s32 wl_do_iscan(struct wl_priv *wl)
726 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
727 struct wlc_ssid ssid;
730 /* Broadcast scan by default */
731 memset(&ssid, 0, sizeof(ssid));
733 iscan->state = WL_ISCAN_STATE_SCANING;
735 if (wl->active_scan) {
736 s32 passive_scan = 0;
737 /* make it active scan */
738 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_SET_PASSIVE_SCAN,
739 &passive_scan, sizeof(passive_scan));
741 WL_DBG(("error (%d)\n", err));
745 wl->iscan_kickstart = TRUE;
746 wl_run_iscan(iscan, &ssid, WL_SCAN_ACTION_START);
747 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
754 __wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
755 struct cfg80211_scan_request *request,
756 struct cfg80211_ssid *this_ssid)
758 struct wl_priv *wl = ndev_to_wl(ndev);
759 struct cfg80211_ssid *ssids;
760 struct wl_scan_req *sr = wl_to_sr(wl);
765 if (unlikely(test_bit(WL_STATUS_SCANNING, &wl->status))) {
766 WL_ERR(("Scanning already : status (%d)\n", (int)wl->status));
769 if (unlikely(test_bit(WL_STATUS_SCAN_ABORTING, &wl->status))) {
770 WL_ERR(("Scanning being aborted : status (%d)\n",
777 if (request) { /* scan bss */
778 ssids = request->ssids;
779 if (wl->iscan_on && (!ssids || !ssids->ssid_len)) { /* for
781 * ssids->ssid_len has
782 * non-zero(ssid string)
784 * Otherwise this is 0.
785 * we do not iscan for
786 * specific scan request
790 } else { /* scan in ibss */
791 /* we don't do iscan in ibss */
794 wl->scan_request = request;
795 set_bit(WL_STATUS_SCANNING, &wl->status);
797 err = wl_do_iscan(wl);
803 WL_DBG(("ssid \"%s\", ssid_len (%d)\n",
804 ssids->ssid, ssids->ssid_len));
805 memset(&sr->ssid, 0, sizeof(sr->ssid));
807 min(sizeof(sr->ssid.SSID), ssids->ssid_len);
808 if (sr->ssid.SSID_len) {
809 memcpy(sr->ssid.SSID, ssids->ssid, sr->ssid.SSID_len);
810 sr->ssid.SSID_len = htod32(sr->ssid.SSID_len);
811 WL_DBG(("Specific scan ssid=\"%s\" len=%d\n",
812 sr->ssid.SSID, sr->ssid.SSID_len));
815 WL_DBG(("Broadcast scan\n"));
817 WL_DBG(("sr->ssid.SSID_len (%d)\n", sr->ssid.SSID_len));
818 if (wl->active_scan) {
820 /* make it active scan */
821 err = wl_dev_ioctl(ndev, WLC_SET_PASSIVE_SCAN,
822 &pssive_scan, sizeof(pssive_scan));
824 WL_ERR(("WLC_SET_PASSIVE_SCAN error (%d)\n",
829 err = wl_dev_ioctl(ndev, WLC_SCAN, &sr->ssid,
833 WL_INFO(("system busy : scan for \"%s\" "
834 "canceled\n", sr->ssid.SSID));
836 WL_ERR(("WLC_SCAN error (%d)\n", err));
845 clear_bit(WL_STATUS_SCANNING, &wl->status);
846 wl->scan_request = NULL;
851 wl_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
852 struct cfg80211_scan_request *request)
857 err = __wl_cfg80211_scan(wiphy, ndev, request, NULL);
859 WL_DBG(("scan error (%d)\n", err));
866 static s32 wl_dev_intvar_set(struct net_device *dev, s8 *name, s32 val)
868 s8 buf[WLC_IOCTL_SMLEN];
873 len = bcm_mkiovar(name, (char *)(&val), sizeof(val), buf, sizeof(buf));
874 BUG_ON(unlikely(!len));
876 err = wl_dev_ioctl(dev, WLC_SET_VAR, buf, len);
878 WL_ERR(("error (%d)\n", err));
885 wl_dev_intvar_get(struct net_device *dev, s8 *name, s32 *retval)
888 s8 buf[WLC_IOCTL_SMLEN];
896 bcm_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
898 BUG_ON(unlikely(!len));
899 err = wl_dev_ioctl(dev, WLC_GET_VAR, &var, len);
901 WL_ERR(("error (%d)\n", err));
903 *retval = dtoh32(var.val);
908 static s32 wl_set_rts(struct net_device *dev, u32 rts_threshold)
912 err = wl_dev_intvar_set(dev, "rtsthresh", rts_threshold);
914 WL_ERR(("Error (%d)\n", err));
920 static s32 wl_set_frag(struct net_device *dev, u32 frag_threshold)
924 err = wl_dev_intvar_set(dev, "fragthresh", frag_threshold);
926 WL_ERR(("Error (%d)\n", err));
932 static s32 wl_set_retry(struct net_device *dev, u32 retry, bool l)
935 u32 cmd = (l ? WLC_SET_LRL : WLC_SET_SRL);
937 retry = htod32(retry);
938 err = wl_dev_ioctl(dev, cmd, &retry, sizeof(retry));
940 WL_ERR(("cmd (%d) , error (%d)\n", cmd, err));
946 static s32 wl_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
948 struct wl_priv *wl = wiphy_to_wl(wiphy);
949 struct net_device *ndev = wl_to_ndev(wl);
953 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
954 (wl->conf->rts_threshold != wiphy->rts_threshold)) {
955 wl->conf->rts_threshold = wiphy->rts_threshold;
956 err = wl_set_rts(ndev, wl->conf->rts_threshold);
960 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
961 (wl->conf->frag_threshold != wiphy->frag_threshold)) {
962 wl->conf->frag_threshold = wiphy->frag_threshold;
963 err = wl_set_frag(ndev, wl->conf->frag_threshold);
967 if (changed & WIPHY_PARAM_RETRY_LONG
968 && (wl->conf->retry_long != wiphy->retry_long)) {
969 wl->conf->retry_long = wiphy->retry_long;
970 err = wl_set_retry(ndev, wl->conf->retry_long, TRUE);
974 if (changed & WIPHY_PARAM_RETRY_SHORT
975 && (wl->conf->retry_short != wiphy->retry_short)) {
976 wl->conf->retry_short = wiphy->retry_short;
977 err = wl_set_retry(ndev, wl->conf->retry_short, FALSE);
987 wl_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
988 struct cfg80211_ibss_params *params)
990 struct wl_priv *wl = wiphy_to_wl(wiphy);
991 struct cfg80211_bss *bss;
992 struct ieee80211_channel *chan;
993 struct wl_join_params join_params;
994 struct cfg80211_ssid ssid;
1000 WL_ERR(("Invalid bssid\n"));
1003 bss = cfg80211_get_ibss(wiphy, NULL, params->ssid, params->ssid_len);
1005 memcpy(ssid.ssid, params->ssid, params->ssid_len);
1006 ssid.ssid_len = params->ssid_len;
1009 (__wl_cfg80211_scan(wiphy, dev, NULL, &ssid) ==
1015 } while (++scan_retry < WL_SCAN_RETRY_MAX);
1016 rtnl_unlock(); /* to allow scan_inform to paropagate
1017 to cfg80211 plane */
1018 schedule_timeout_interruptible(4 * HZ); /* wait 4 secons
1019 till scan done.... */
1021 bss = cfg80211_get_ibss(wiphy, NULL,
1022 params->ssid, params->ssid_len);
1025 wl->ibss_starter = FALSE;
1026 WL_DBG(("Found IBSS\n"));
1028 wl->ibss_starter = TRUE;
1030 chan = params->channel;
1032 wl->channel = ieee80211_frequency_to_channel(chan->center_freq);
1034 ** Join with specific BSSID and cached SSID
1035 ** If SSID is zero join based on BSSID only
1037 memset(&join_params, 0, sizeof(join_params));
1038 memcpy((void *)join_params.ssid.SSID, (void *)params->ssid,
1040 join_params.ssid.SSID_len = htod32(params->ssid_len);
1042 memcpy(&join_params.params.bssid, params->bssid,
1045 memset(&join_params.params.bssid, 0, ETHER_ADDR_LEN);
1047 err = wl_dev_ioctl(dev, WLC_SET_SSID, &join_params,
1048 sizeof(join_params));
1049 if (unlikely(err)) {
1050 WL_ERR(("Error (%d)\n", err));
1056 static s32 wl_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1058 struct wl_priv *wl = wiphy_to_wl(wiphy);
1068 wl_set_wpa_version(struct net_device *dev, struct cfg80211_connect_params *sme)
1070 struct wl_priv *wl = ndev_to_wl(dev);
1071 struct wl_security *sec;
1075 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1076 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1077 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1078 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1080 val = WPA_AUTH_DISABLED;
1081 WL_DBG(("setting wpa_auth to 0x%0x\n", val));
1082 err = wl_dev_intvar_set(dev, "wpa_auth", val);
1083 if (unlikely(err)) {
1084 WL_ERR(("set wpa_auth failed (%d)\n", err));
1087 sec = wl_read_prof(wl, WL_PROF_SEC);
1088 sec->wpa_versions = sme->crypto.wpa_versions;
1093 wl_set_auth_type(struct net_device *dev, struct cfg80211_connect_params *sme)
1095 struct wl_priv *wl = ndev_to_wl(dev);
1096 struct wl_security *sec;
1100 switch (sme->auth_type) {
1101 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1103 WL_DBG(("open system\n"));
1105 case NL80211_AUTHTYPE_SHARED_KEY:
1107 WL_DBG(("shared key\n"));
1109 case NL80211_AUTHTYPE_AUTOMATIC:
1111 WL_DBG(("automatic\n"));
1113 case NL80211_AUTHTYPE_NETWORK_EAP:
1114 WL_DBG(("network eap\n"));
1117 WL_ERR(("invalid auth type (%d)\n", sme->auth_type));
1121 err = wl_dev_intvar_set(dev, "auth", val);
1122 if (unlikely(err)) {
1123 WL_ERR(("set auth failed (%d)\n", err));
1126 sec = wl_read_prof(wl, WL_PROF_SEC);
1127 sec->auth_type = sme->auth_type;
1132 wl_set_set_cipher(struct net_device *dev, struct cfg80211_connect_params *sme)
1134 struct wl_priv *wl = ndev_to_wl(dev);
1135 struct wl_security *sec;
1140 if (sme->crypto.n_ciphers_pairwise) {
1141 switch (sme->crypto.ciphers_pairwise[0]) {
1142 case WLAN_CIPHER_SUITE_WEP40:
1143 case WLAN_CIPHER_SUITE_WEP104:
1146 case WLAN_CIPHER_SUITE_TKIP:
1147 pval = TKIP_ENABLED;
1149 case WLAN_CIPHER_SUITE_CCMP:
1152 case WLAN_CIPHER_SUITE_AES_CMAC:
1156 WL_ERR(("invalid cipher pairwise (%d)\n",
1157 sme->crypto.ciphers_pairwise[0]));
1161 if (sme->crypto.cipher_group) {
1162 switch (sme->crypto.cipher_group) {
1163 case WLAN_CIPHER_SUITE_WEP40:
1164 case WLAN_CIPHER_SUITE_WEP104:
1167 case WLAN_CIPHER_SUITE_TKIP:
1168 gval = TKIP_ENABLED;
1170 case WLAN_CIPHER_SUITE_CCMP:
1173 case WLAN_CIPHER_SUITE_AES_CMAC:
1177 WL_ERR(("invalid cipher group (%d)\n",
1178 sme->crypto.cipher_group));
1183 WL_DBG(("pval (%d) gval (%d)\n", pval, gval));
1184 err = wl_dev_intvar_set(dev, "wsec", pval | gval);
1185 if (unlikely(err)) {
1186 WL_ERR(("error (%d)\n", err));
1190 sec = wl_read_prof(wl, WL_PROF_SEC);
1191 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1192 sec->cipher_group = sme->crypto.cipher_group;
1198 wl_set_key_mgmt(struct net_device *dev, struct cfg80211_connect_params *sme)
1200 struct wl_priv *wl = ndev_to_wl(dev);
1201 struct wl_security *sec;
1205 if (sme->crypto.n_akm_suites) {
1206 err = wl_dev_intvar_get(dev, "wpa_auth", &val);
1207 if (unlikely(err)) {
1208 WL_ERR(("could not get wpa_auth (%d)\n", err));
1211 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1212 switch (sme->crypto.akm_suites[0]) {
1213 case WLAN_AKM_SUITE_8021X:
1214 val = WPA_AUTH_UNSPECIFIED;
1216 case WLAN_AKM_SUITE_PSK:
1220 WL_ERR(("invalid cipher group (%d)\n",
1221 sme->crypto.cipher_group));
1224 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1225 switch (sme->crypto.akm_suites[0]) {
1226 case WLAN_AKM_SUITE_8021X:
1227 val = WPA2_AUTH_UNSPECIFIED;
1229 case WLAN_AKM_SUITE_PSK:
1230 val = WPA2_AUTH_PSK;
1233 WL_ERR(("invalid cipher group (%d)\n",
1234 sme->crypto.cipher_group));
1239 WL_DBG(("setting wpa_auth to %d\n", val));
1240 err = wl_dev_intvar_set(dev, "wpa_auth", val);
1241 if (unlikely(err)) {
1242 WL_ERR(("could not set wpa_auth (%d)\n", err));
1246 sec = wl_read_prof(wl, WL_PROF_SEC);
1247 sec->wpa_auth = sme->crypto.akm_suites[0];
1253 wl_set_set_sharedkey(struct net_device *dev,
1254 struct cfg80211_connect_params *sme)
1256 struct wl_priv *wl = ndev_to_wl(dev);
1257 struct wl_security *sec;
1258 struct wl_wsec_key key;
1262 WL_DBG(("key len (%d)\n", sme->key_len));
1264 sec = wl_read_prof(wl, WL_PROF_SEC);
1265 WL_DBG(("wpa_versions 0x%x cipher_pairwise 0x%x\n",
1266 sec->wpa_versions, sec->cipher_pairwise));
1268 (sec->wpa_versions & (NL80211_WPA_VERSION_1 |
1269 NL80211_WPA_VERSION_2))
1270 && (sec->cipher_pairwise & (WLAN_CIPHER_SUITE_WEP40 |
1271 WLAN_CIPHER_SUITE_WEP104))) {
1272 memset(&key, 0, sizeof(key));
1273 key.len = (u32) sme->key_len;
1274 key.index = (u32) sme->key_idx;
1275 if (unlikely(key.len > sizeof(key.data))) {
1276 WL_ERR(("Too long key length (%u)\n", key.len));
1279 memcpy(key.data, sme->key, key.len);
1280 key.flags = WL_PRIMARY_KEY;
1281 switch (sec->cipher_pairwise) {
1282 case WLAN_CIPHER_SUITE_WEP40:
1283 key.algo = CRYPTO_ALGO_WEP1;
1285 case WLAN_CIPHER_SUITE_WEP104:
1286 key.algo = CRYPTO_ALGO_WEP128;
1289 WL_ERR(("Invalid algorithm (%d)\n",
1290 sme->crypto.ciphers_pairwise[0]));
1293 /* Set the new key/index */
1294 WL_DBG(("key length (%d) key index (%d) algo (%d)\n",
1295 key.len, key.index, key.algo));
1296 WL_DBG(("key \"%s\"\n", key.data));
1297 swap_key_from_BE(&key);
1298 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key,
1300 if (unlikely(err)) {
1301 WL_ERR(("WLC_SET_KEY error (%d)\n", err));
1304 if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
1305 WL_DBG(("set auth_type to shared key\n"));
1306 val = 1; /* shared key */
1307 err = wl_dev_intvar_set(dev, "auth", val);
1308 if (unlikely(err)) {
1309 WL_ERR(("set auth failed (%d)\n", err));
1319 wl_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
1320 struct cfg80211_connect_params *sme)
1322 struct wl_priv *wl = wiphy_to_wl(wiphy);
1323 struct ieee80211_channel *chan = sme->channel;
1324 struct wlc_ssid ssid;
1328 if (unlikely(!sme->ssid)) {
1329 WL_ERR(("Invalid ssid\n"));
1333 wl->channel = ieee80211_frequency_to_channel(chan->center_freq);
1334 WL_DBG(("channel (%d), center_req (%d)\n", wl->channel,
1335 chan->center_freq));
1337 WL_DBG(("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len));
1338 err = wl_set_wpa_version(dev, sme);
1342 err = wl_set_auth_type(dev, sme);
1346 err = wl_set_set_cipher(dev, sme);
1350 err = wl_set_key_mgmt(dev, sme);
1354 err = wl_set_set_sharedkey(dev, sme);
1358 wl_update_prof(wl, NULL, sme->bssid, WL_PROF_BSSID);
1360 ** Join with specific BSSID and cached SSID
1361 ** If SSID is zero join based on BSSID only
1363 memset(&ssid, 0, sizeof(ssid));
1364 ssid.SSID_len = min(sizeof(ssid.SSID), sme->ssid_len);
1365 memcpy(ssid.SSID, sme->ssid, ssid.SSID_len);
1366 ssid.SSID_len = htod32(ssid.SSID_len);
1367 wl_update_prof(wl, NULL, &ssid, WL_PROF_SSID);
1368 if (ssid.SSID_len < IEEE80211_MAX_SSID_LEN) {
1369 WL_DBG(("ssid \"%s\", len (%d)\n", ssid.SSID, ssid.SSID_len));
1371 err = wl_dev_ioctl(dev, WLC_SET_SSID, &ssid, sizeof(ssid));
1372 if (unlikely(err)) {
1373 WL_ERR(("error (%d)\n", err));
1376 set_bit(WL_STATUS_CONNECTING, &wl->status);
1382 wl_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1385 struct wl_priv *wl = wiphy_to_wl(wiphy);
1390 WL_DBG(("Reason %d\n", reason_code));
1392 act = *(bool *) wl_read_prof(wl, WL_PROF_ACT);
1394 scbval.val = reason_code;
1395 memcpy(&scbval.ea, &wl->bssid, ETHER_ADDR_LEN);
1396 scbval.val = htod32(scbval.val);
1397 err = wl_dev_ioctl(dev, WLC_DISASSOC, &scbval,
1399 if (unlikely(err)) {
1400 WL_ERR(("error (%d)\n", err));
1409 wl_cfg80211_set_tx_power(struct wiphy *wiphy,
1410 enum nl80211_tx_power_setting type, s32 dbm)
1413 struct wl_priv *wl = wiphy_to_wl(wiphy);
1414 struct net_device *ndev = wl_to_ndev(wl);
1421 case NL80211_TX_POWER_AUTOMATIC:
1423 case NL80211_TX_POWER_LIMITED:
1425 WL_ERR(("TX_POWER_LIMITTED - dbm is negative\n"));
1429 case NL80211_TX_POWER_FIXED:
1431 WL_ERR(("TX_POWER_FIXED - dbm is negative..\n"));
1436 /* Make sure radio is off or on as far as software is concerned */
1437 disable = WL_RADIO_SW_DISABLE << 16;
1438 disable = htod32(disable);
1439 err = wl_dev_ioctl(ndev, WLC_SET_RADIO, &disable, sizeof(disable));
1440 if (unlikely(err)) {
1441 WL_ERR(("WLC_SET_RADIO error (%d)\n", err));
1448 txpwrmw = (u16) dbm;
1449 err = wl_dev_intvar_set(ndev, "qtxpower",
1450 (s32) (bcm_mw_to_qdbm(txpwrmw)));
1451 if (unlikely(err)) {
1452 WL_ERR(("qtxpower error (%d)\n", err));
1455 wl->conf->tx_power = dbm;
1460 static s32 wl_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1462 struct wl_priv *wl = wiphy_to_wl(wiphy);
1463 struct net_device *ndev = wl_to_ndev(wl);
1469 err = wl_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1470 if (unlikely(err)) {
1471 WL_ERR(("error (%d)\n", err));
1474 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1475 *dbm = (s32) bcm_qdbm_to_mw(result);
1481 wl_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
1488 WL_DBG(("key index (%d)\n", key_idx));
1491 err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
1492 if (unlikely(err)) {
1493 WL_ERR(("WLC_GET_WSEC error (%d)\n", err));
1496 wsec = dtoh32(wsec);
1497 if (wsec & WEP_ENABLED) {
1498 /* Just select a new current key */
1499 index = (u32) key_idx;
1500 index = htod32(index);
1501 err = wl_dev_ioctl(dev, WLC_SET_KEY_PRIMARY, &index,
1503 if (unlikely(err)) {
1504 WL_ERR(("error (%d)\n", err));
1511 wl_add_keyext(struct wiphy *wiphy, struct net_device *dev,
1512 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1514 struct wl_wsec_key key;
1517 memset(&key, 0, sizeof(key));
1518 key.index = (u32) key_idx;
1519 /* Instead of bcast for ea address for default wep keys,
1520 driver needs it to be Null */
1521 if (!ETHER_ISMULTI(mac_addr))
1522 memcpy((char *)&key.ea, (void *)mac_addr, ETHER_ADDR_LEN);
1523 key.len = (u32) params->key_len;
1524 /* check for key index change */
1527 swap_key_from_BE(&key);
1528 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1529 if (unlikely(err)) {
1530 WL_ERR(("key delete error (%d)\n", err));
1534 if (key.len > sizeof(key.data)) {
1535 WL_ERR(("Invalid key length (%d)\n", key.len));
1539 WL_DBG(("Setting the key index %d\n", key.index));
1540 memcpy(key.data, params->key, key.len);
1542 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1544 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1545 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1546 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1549 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1550 if (params->seq && params->seq_len == 6) {
1553 ivptr = (u8 *) params->seq;
1554 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1555 (ivptr[3] << 8) | ivptr[2];
1556 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1557 key.iv_initialized = TRUE;
1560 switch (params->cipher) {
1561 case WLAN_CIPHER_SUITE_WEP40:
1562 key.algo = CRYPTO_ALGO_WEP1;
1563 WL_DBG(("WLAN_CIPHER_SUITE_WEP40\n"));
1565 case WLAN_CIPHER_SUITE_WEP104:
1566 key.algo = CRYPTO_ALGO_WEP128;
1567 WL_DBG(("WLAN_CIPHER_SUITE_WEP104\n"));
1569 case WLAN_CIPHER_SUITE_TKIP:
1570 key.algo = CRYPTO_ALGO_TKIP;
1571 WL_DBG(("WLAN_CIPHER_SUITE_TKIP\n"));
1573 case WLAN_CIPHER_SUITE_AES_CMAC:
1574 key.algo = CRYPTO_ALGO_AES_CCM;
1575 WL_DBG(("WLAN_CIPHER_SUITE_AES_CMAC\n"));
1577 case WLAN_CIPHER_SUITE_CCMP:
1578 key.algo = CRYPTO_ALGO_AES_CCM;
1579 WL_DBG(("WLAN_CIPHER_SUITE_CCMP\n"));
1582 WL_ERR(("Invalid cipher (0x%x)\n", params->cipher));
1585 swap_key_from_BE(&key);
1587 dhd_wait_pend8021x(dev);
1588 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1589 if (unlikely(err)) {
1590 WL_ERR(("WLC_SET_KEY error (%d)\n", err));
1598 wl_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
1599 u8 key_idx, const u8 *mac_addr,
1600 struct key_params *params)
1602 struct wl_wsec_key key;
1607 WL_DBG(("key index (%d)\n", key_idx));
1611 return wl_add_keyext(wiphy, dev, key_idx, mac_addr, params);
1612 memset(&key, 0, sizeof(key));
1614 key.len = (u32) params->key_len;
1615 key.index = (u32) key_idx;
1617 if (unlikely(key.len > sizeof(key.data))) {
1618 WL_ERR(("Too long key length (%u)\n", key.len));
1621 memcpy(key.data, params->key, key.len);
1623 key.flags = WL_PRIMARY_KEY;
1624 switch (params->cipher) {
1625 case WLAN_CIPHER_SUITE_WEP40:
1626 key.algo = CRYPTO_ALGO_WEP1;
1627 WL_DBG(("WLAN_CIPHER_SUITE_WEP40\n"));
1629 case WLAN_CIPHER_SUITE_WEP104:
1630 key.algo = CRYPTO_ALGO_WEP128;
1631 WL_DBG(("WLAN_CIPHER_SUITE_WEP104\n"));
1633 case WLAN_CIPHER_SUITE_TKIP:
1634 key.algo = CRYPTO_ALGO_TKIP;
1635 WL_DBG(("WLAN_CIPHER_SUITE_TKIP\n"));
1637 case WLAN_CIPHER_SUITE_AES_CMAC:
1638 key.algo = CRYPTO_ALGO_AES_CCM;
1639 WL_DBG(("WLAN_CIPHER_SUITE_AES_CMAC\n"));
1641 case WLAN_CIPHER_SUITE_CCMP:
1642 key.algo = CRYPTO_ALGO_AES_CCM;
1643 WL_DBG(("WLAN_CIPHER_SUITE_CCMP\n"));
1646 WL_ERR(("Invalid cipher (0x%x)\n", params->cipher));
1650 /* Set the new key/index */
1651 swap_key_from_BE(&key);
1652 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1653 if (unlikely(err)) {
1654 WL_ERR(("WLC_SET_KEY error (%d)\n", err));
1659 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1660 if (unlikely(err)) {
1661 WL_ERR(("get wsec error (%d)\n", err));
1664 wsec &= ~(WEP_ENABLED);
1666 err = wl_dev_intvar_set(dev, "wsec", wsec);
1667 if (unlikely(err)) {
1668 WL_ERR(("set wsec error (%d)\n", err));
1672 val = 1; /* assume shared key. otherwise 0 */
1674 err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
1675 if (unlikely(err)) {
1676 WL_ERR(("WLC_SET_AUTH error (%d)\n", err));
1683 wl_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
1684 u8 key_idx, const u8 *mac_addr)
1686 struct wl_wsec_key key;
1692 memset(&key, 0, sizeof(key));
1694 key.index = (u32) key_idx;
1695 key.flags = WL_PRIMARY_KEY;
1696 key.algo = CRYPTO_ALGO_OFF;
1698 WL_DBG(("key index (%d)\n", key_idx));
1699 /* Set the new key/index */
1700 swap_key_from_BE(&key);
1701 err = wl_dev_ioctl(dev, WLC_SET_KEY, &key, sizeof(key));
1702 if (unlikely(err)) {
1703 if (err == -EINVAL) {
1704 if (key.index >= DOT11_MAX_DEFAULT_KEYS) {
1705 /* we ignore this key index in this case */
1706 WL_DBG(("invalid key index (%d)\n", key_idx));
1709 WL_ERR(("WLC_SET_KEY error (%d)\n", err));
1715 err = wl_dev_intvar_get(dev, "wsec", &wsec);
1716 if (unlikely(err)) {
1717 WL_ERR(("get wsec error (%d)\n", err));
1720 wsec &= ~(WEP_ENABLED);
1722 err = wl_dev_intvar_set(dev, "wsec", wsec);
1723 if (unlikely(err)) {
1724 WL_ERR(("set wsec error (%d)\n", err));
1728 val = 0; /* assume open key. otherwise 1 */
1730 err = wl_dev_ioctl(dev, WLC_SET_AUTH, &val, sizeof(val));
1731 if (unlikely(err)) {
1732 WL_ERR(("WLC_SET_AUTH error (%d)\n", err));
1739 wl_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
1740 u8 key_idx, const u8 *mac_addr, void *cookie,
1741 void (*callback) (void *cookie, struct key_params * params))
1743 struct key_params params;
1744 struct wl_wsec_key key;
1745 struct wl_priv *wl = wiphy_to_wl(wiphy);
1746 struct wl_security *sec;
1750 WL_DBG(("key index (%d)\n", key_idx));
1753 memset(&key, 0, sizeof(key));
1754 key.index = key_idx;
1755 swap_key_to_BE(&key);
1756 memset(¶ms, 0, sizeof(params));
1757 params.key_len = (u8) min(DOT11_MAX_KEY_SIZE, key.len);
1758 memcpy(params.key, key.data, params.key_len);
1760 err = wl_dev_ioctl(dev, WLC_GET_WSEC, &wsec, sizeof(wsec));
1761 if (unlikely(err)) {
1762 WL_ERR(("WLC_GET_WSEC error (%d)\n", err));
1765 wsec = dtoh32(wsec);
1768 sec = wl_read_prof(wl, WL_PROF_SEC);
1769 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1770 params.cipher = WLAN_CIPHER_SUITE_WEP40;
1771 WL_DBG(("WLAN_CIPHER_SUITE_WEP40\n"));
1772 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1773 params.cipher = WLAN_CIPHER_SUITE_WEP104;
1774 WL_DBG(("WLAN_CIPHER_SUITE_WEP104\n"));
1778 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1779 WL_DBG(("WLAN_CIPHER_SUITE_TKIP\n"));
1782 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1783 WL_DBG(("WLAN_CIPHER_SUITE_AES_CMAC\n"));
1786 WL_ERR(("Invalid algo (0x%x)\n", wsec));
1790 callback(cookie, ¶ms);
1795 wl_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1796 struct net_device *dev, u8 key_idx)
1798 WL_INFO(("Not supported\n"));
1804 wl_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
1805 u8 *mac, struct station_info *sinfo)
1807 struct wl_priv *wl = wiphy_to_wl(wiphy);
1815 (memcmp(mac, wl_read_prof(wl, WL_PROF_BSSID), ETHER_ADDR_LEN))) {
1816 WL_ERR(("Wrong Mac address\n"));
1820 /* Report the current tx rate */
1821 err = wl_dev_ioctl(dev, WLC_GET_RATE, &rate, sizeof(rate));
1823 WL_ERR(("Could not get rate (%d)\n", err));
1825 rate = dtoh32(rate);
1826 sinfo->filled |= STATION_INFO_TX_BITRATE;
1827 sinfo->txrate.legacy = rate * 5;
1828 WL_DBG(("Rate %d Mbps\n", (rate / 2)));
1831 if (test_bit(WL_STATUS_CONNECTED, &wl->status)) {
1833 err = wl_dev_ioctl(dev, WLC_GET_RSSI, &scb_val,
1835 if (unlikely(err)) {
1836 WL_ERR(("Could not get rssi (%d)\n", err));
1839 rssi = dtoh32(scb_val.val);
1840 sinfo->filled |= STATION_INFO_SIGNAL;
1841 sinfo->signal = rssi;
1842 WL_DBG(("RSSI %d dBm\n", rssi));
1849 wl_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1850 bool enabled, s32 timeout)
1856 pm = enabled ? PM_FAST : PM_OFF;
1858 WL_DBG(("power save %s\n", (pm ? "enabled" : "disabled")));
1859 err = wl_dev_ioctl(dev, WLC_SET_PM, &pm, sizeof(pm));
1860 if (unlikely(err)) {
1862 WL_DBG(("net_device is not ready yet\n"));
1864 WL_ERR(("error (%d)\n", err));
1870 static __used u32 wl_find_msb(u16 bit16)
1874 if (bit16 & 0xff00) {
1898 wl_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
1900 const struct cfg80211_bitrate_mask *mask)
1902 struct wl_rateset rateset;
1911 /* addr param is always NULL. ignore it */
1912 /* Get current rateset */
1913 err = wl_dev_ioctl(dev, WLC_GET_CURR_RATESET, &rateset,
1915 if (unlikely(err)) {
1916 WL_ERR(("could not get current rateset (%d)\n", err));
1920 rateset.count = dtoh32(rateset.count);
1922 legacy = wl_find_msb(mask->control[IEEE80211_BAND_2GHZ].legacy);
1924 legacy = wl_find_msb(mask->control[IEEE80211_BAND_5GHZ].legacy);
1926 val = wl_g_rates[legacy - 1].bitrate * 100000;
1928 if (val < rateset.count) {
1929 /* Select rate by rateset index */
1930 rate = rateset.rates[val] & 0x7f;
1932 /* Specified rate in bps */
1933 rate = val / 500000;
1936 WL_DBG(("rate %d mbps\n", (rate / 2)));
1940 * Set rate override,
1941 * Since the is a/b/g-blind, both a/bg_rate are enforced.
1943 err_bg = wl_dev_intvar_set(dev, "bg_rate", rate);
1944 err_a = wl_dev_intvar_set(dev, "a_rate", rate);
1945 if (unlikely(err_bg && err_a)) {
1946 WL_ERR(("could not set fixed rate (%d) (%d)\n", err_bg, err_a));
1947 return err_bg | err_a;
1953 static s32 wl_cfg80211_resume(struct wiphy *wiphy)
1958 wl_invoke_iscan(wiphy_to_wl(wiphy));
1963 static s32 wl_cfg80211_suspend(struct wiphy *wiphy)
1965 struct wl_priv *wl = wiphy_to_wl(wiphy);
1970 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
1972 if (wl->scan_request) {
1973 cfg80211_scan_done(wl->scan_request, TRUE); /* TRUE means
1975 wl->scan_request = NULL;
1977 clear_bit(WL_STATUS_SCANNING, &wl->status);
1978 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
1984 wl_update_pmklist(struct net_device *dev, struct wl_pmk_list *pmk_list,
1987 s8 eabuf[ETHER_ADDR_STR_LEN];
1990 memset(eabuf, 0, ETHER_ADDR_STR_LEN);
1992 WL_DBG(("No of elements %d\n", pmk_list->pmkids.npmkid));
1993 for (i = 0; i < pmk_list->pmkids.npmkid; i++) {
1994 WL_DBG(("PMKID[%d]: %s =\n", i,
1995 bcm_ether_ntoa(&pmk_list->pmkids.pmkid[i].BSSID,
1997 for (j = 0; j < WPA2_PMKID_LEN; j++) {
1998 WL_DBG(("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]));
2002 err = wl_dev_bufvar_set(dev, "pmkid_info", (char *)pmk_list,
2010 wl_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
2011 struct cfg80211_pmksa *pmksa)
2013 struct wl_priv *wl = wiphy_to_wl(wiphy);
2014 s8 eabuf[ETHER_ADDR_STR_LEN];
2019 memset(eabuf, 0, ETHER_ADDR_STR_LEN);
2020 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2021 if (!memcmp(pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2024 if (i < WL_NUM_PMKIDS_MAX) {
2025 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID, pmksa->bssid,
2027 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID, pmksa->pmkid,
2029 if (i == wl->pmk_list->pmkids.npmkid)
2030 wl->pmk_list->pmkids.npmkid++;
2034 WL_DBG(("set_pmksa,IW_PMKSA_ADD - PMKID: %s =\n",
2035 bcm_ether_ntoa(&wl->pmk_list->pmkids.
2036 pmkid[wl->pmk_list->pmkids.npmkid].BSSID,
2038 for (i = 0; i < WPA2_PMKID_LEN; i++) {
2040 wl->pmk_list->pmkids.pmkid[wl->pmk_list->pmkids.npmkid].
2044 err = wl_update_pmklist(dev, wl->pmk_list, err);
2050 wl_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
2051 struct cfg80211_pmksa *pmksa)
2053 struct wl_priv *wl = wiphy_to_wl(wiphy);
2054 s8 eabuf[ETHER_ADDR_STR_LEN];
2055 struct _pmkid_list pmkid;
2060 memset(eabuf, 0, ETHER_ADDR_STR_LEN);
2061 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETHER_ADDR_LEN);
2062 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WPA2_PMKID_LEN);
2064 WL_DBG(("del_pmksa,IW_PMKSA_REMOVE - PMKID: %s =\n",
2065 bcm_ether_ntoa(&pmkid.pmkid[0].BSSID, eabuf)));
2066 for (i = 0; i < WPA2_PMKID_LEN; i++) {
2067 WL_DBG(("%02x\n", pmkid.pmkid[0].PMKID[i]));
2070 for (i = 0; i < wl->pmk_list->pmkids.npmkid; i++)
2072 (pmksa->bssid, &wl->pmk_list->pmkids.pmkid[i].BSSID,
2076 if ((wl->pmk_list->pmkids.npmkid > 0)
2077 && (i < wl->pmk_list->pmkids.npmkid)) {
2078 memset(&wl->pmk_list->pmkids.pmkid[i], 0, sizeof(pmkid_t));
2079 for (; i < (wl->pmk_list->pmkids.npmkid - 1); i++) {
2080 memcpy(&wl->pmk_list->pmkids.pmkid[i].BSSID,
2081 &wl->pmk_list->pmkids.pmkid[i + 1].BSSID,
2083 memcpy(&wl->pmk_list->pmkids.pmkid[i].PMKID,
2084 &wl->pmk_list->pmkids.pmkid[i + 1].PMKID,
2087 wl->pmk_list->pmkids.npmkid--;
2092 err = wl_update_pmklist(dev, wl->pmk_list, err);
2099 wl_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *dev)
2101 struct wl_priv *wl = wiphy_to_wl(wiphy);
2105 memset(wl->pmk_list, 0, sizeof(*wl->pmk_list));
2106 err = wl_update_pmklist(dev, wl->pmk_list, err);
2111 static struct cfg80211_ops wl_cfg80211_ops = {
2112 .change_virtual_intf = wl_cfg80211_change_iface,
2113 .scan = wl_cfg80211_scan,
2114 .set_wiphy_params = wl_cfg80211_set_wiphy_params,
2115 .join_ibss = wl_cfg80211_join_ibss,
2116 .leave_ibss = wl_cfg80211_leave_ibss,
2117 .get_station = wl_cfg80211_get_station,
2118 .set_tx_power = wl_cfg80211_set_tx_power,
2119 .get_tx_power = wl_cfg80211_get_tx_power,
2120 .add_key = wl_cfg80211_add_key,
2121 .del_key = wl_cfg80211_del_key,
2122 .get_key = wl_cfg80211_get_key,
2123 .set_default_key = wl_cfg80211_config_default_key,
2124 .set_default_mgmt_key = wl_cfg80211_config_default_mgmt_key,
2125 .set_power_mgmt = wl_cfg80211_set_power_mgmt,
2126 .set_bitrate_mask = wl_cfg80211_set_bitrate_mask,
2127 .connect = wl_cfg80211_connect,
2128 .disconnect = wl_cfg80211_disconnect,
2129 .suspend = wl_cfg80211_suspend,
2130 .resume = wl_cfg80211_resume,
2131 .set_pmksa = wl_cfg80211_set_pmksa,
2132 .del_pmksa = wl_cfg80211_del_pmksa,
2133 .flush_pmksa = wl_cfg80211_flush_pmksa
2136 static s32 wl_mode_to_nl80211_iftype(s32 mode)
2142 return NL80211_IFTYPE_STATION;
2144 return NL80211_IFTYPE_ADHOC;
2146 return NL80211_IFTYPE_UNSPECIFIED;
2152 static struct wireless_dev *wl_alloc_wdev(s32 sizeof_iface,
2155 struct wireless_dev *wdev;
2158 wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2159 if (unlikely(!wdev)) {
2160 WL_ERR(("Could not allocate wireless device\n"));
2161 return ERR_PTR(-ENOMEM);
2164 wiphy_new(&wl_cfg80211_ops, sizeof(struct wl_priv) + sizeof_iface);
2165 if (unlikely(!wdev->wiphy)) {
2166 WL_ERR(("Couldn not allocate wiphy device\n"));
2170 set_wiphy_dev(wdev->wiphy, dev);
2171 wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2172 wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2173 wdev->wiphy->interface_modes =
2174 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2175 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2176 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a; /* Set
2177 * it as 11a by default.
2178 * This will be updated with
2181 * if phy has 11n capability
2183 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2184 wdev->wiphy->cipher_suites = __wl_cipher_suites;
2185 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2186 #ifndef WL_POWERSAVE_DISABLED
2187 wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; /* enable power
2192 wdev->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
2193 #endif /* !WL_POWERSAVE_DISABLED */
2194 err = wiphy_register(wdev->wiphy);
2195 if (unlikely(err < 0)) {
2196 WL_ERR(("Couldn not register wiphy device (%d)\n", err));
2197 goto wiphy_register_out;
2202 wiphy_free(wdev->wiphy);
2207 return ERR_PTR(err);
2210 static void wl_free_wdev(struct wl_priv *wl)
2212 struct wireless_dev *wdev = wl_to_wdev(wl);
2214 if (unlikely(!wdev)) {
2215 WL_ERR(("wdev is invalid\n"));
2218 wiphy_unregister(wdev->wiphy);
2219 wiphy_free(wdev->wiphy);
2221 wl_to_wdev(wl) = NULL;
2224 static s32 wl_inform_bss(struct wl_priv *wl)
2226 struct wl_scan_results *bss_list;
2227 struct wl_bss_info *bi = NULL; /* must be initialized */
2231 bss_list = wl->bss_list;
2232 if (unlikely(bss_list->version != WL_BSS_INFO_VERSION)) {
2233 WL_ERR(("Version %d != WL_BSS_INFO_VERSION\n",
2234 bss_list->version));
2237 WL_DBG(("scanned AP count (%d)\n", bss_list->count));
2238 bi = next_bss(bss_list, bi);
2239 for_each_bss(bss_list, bi, i) {
2240 err = wl_inform_single_bss(wl, bi);
2247 static s32 wl_inform_single_bss(struct wl_priv *wl, struct wl_bss_info *bi)
2249 struct wiphy *wiphy = wl_to_wiphy(wl);
2250 struct ieee80211_mgmt *mgmt;
2251 struct ieee80211_channel *channel;
2252 struct ieee80211_supported_band *band;
2253 struct wl_cfg80211_bss_info *notif_bss_info;
2254 struct wl_scan_req *sr = wl_to_sr(wl);
2259 if (unlikely(dtoh32(bi->length) > WL_BSS_INFO_MAX)) {
2260 WL_DBG(("Beacon is larger than buffer. Discarding\n"));
2264 kzalloc(sizeof(*notif_bss_info) + sizeof(*mgmt) - sizeof(u8) +
2265 WL_BSS_INFO_MAX, GFP_KERNEL);
2266 if (unlikely(!notif_bss_info)) {
2267 WL_ERR(("notif_bss_info alloc failed\n"));
2270 mgmt = (struct ieee80211_mgmt *)notif_bss_info->frame_buf;
2271 notif_bss_info->channel = CHSPEC_CHANNEL(bi->chanspec);
2272 if (notif_bss_info->channel <= CH_MAX_2G_CHANNEL)
2273 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2275 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2276 notif_bss_info->rssi = bi->RSSI;
2277 memcpy(mgmt->bssid, &bi->BSSID, ETHER_ADDR_LEN);
2278 if (!memcmp(bi->SSID, sr->ssid.SSID, bi->SSID_len)) {
2279 mgmt->frame_control = cpu_to_le16(IEEE80211_FTYPE_MGMT |
2280 IEEE80211_STYPE_PROBE_RESP);
2282 mgmt->u.probe_resp.timestamp = 0;
2283 mgmt->u.probe_resp.beacon_int = cpu_to_le16(bi->beacon_period);
2284 mgmt->u.probe_resp.capab_info = cpu_to_le16(bi->capability);
2286 wl_add_ie(wl, WLAN_EID_SSID, bi->SSID_len, bi->SSID);
2287 wl_add_ie(wl, WLAN_EID_SUPP_RATES, bi->rateset.count,
2289 wl_mrg_ie(wl, ((u8 *) bi) + bi->ie_offset, bi->ie_length);
2290 wl_cp_ie(wl, mgmt->u.probe_resp.variable, WL_BSS_INFO_MAX -
2291 offsetof(struct wl_cfg80211_bss_info, frame_buf));
2292 notif_bss_info->frame_len =
2293 offsetof(struct ieee80211_mgmt,
2294 u.probe_resp.variable) + wl_get_ielen(wl);
2295 freq = ieee80211_channel_to_frequency(notif_bss_info->channel);
2296 channel = ieee80211_get_channel(wiphy, freq);
2298 WL_DBG(("SSID : \"%s\", rssi %d, channel %d, capability : 0x04%x\n",
2300 notif_bss_info->rssi, notif_bss_info->channel,
2301 mgmt->u.probe_resp.capab_info));
2303 signal = notif_bss_info->rssi * 100;
2304 if (unlikely(!cfg80211_inform_bss_frame(wiphy, channel, mgmt,
2306 (notif_bss_info->frame_len),
2307 signal, GFP_KERNEL))) {
2308 WL_ERR(("cfg80211_inform_bss_frame error\n"));
2309 kfree(notif_bss_info);
2312 kfree(notif_bss_info);
2317 static bool wl_is_linkup(struct wl_priv *wl, const wl_event_msg_t *e)
2319 u32 event = ntoh32(e->event_type);
2320 u16 flags = ntoh16(e->flags);
2322 if (event == WLC_E_JOIN || event == WLC_E_ASSOC_IND
2323 || event == WLC_E_REASSOC_IND) {
2325 } else if (event == WLC_E_LINK) {
2326 if (flags & WLC_EVENT_MSG_LINK) {
2327 if (wl_is_ibssmode(wl)) {
2328 if (wl_is_ibssstarter(wl)) {
2339 static bool wl_is_linkdown(struct wl_priv *wl, const wl_event_msg_t *e)
2341 u32 event = ntoh32(e->event_type);
2342 u16 flags = ntoh16(e->flags);
2344 if (event == WLC_E_DEAUTH_IND || event == WLC_E_DISASSOC_IND) {
2346 } else if (event == WLC_E_LINK) {
2347 if (!(flags & WLC_EVENT_MSG_LINK))
2354 static bool wl_is_nonetwork(struct wl_priv *wl, const wl_event_msg_t *e)
2356 u32 event = ntoh32(e->event_type);
2357 u32 status = ntoh32(e->status);
2359 if (event == WLC_E_SET_SSID || event == WLC_E_LINK) {
2360 if (status == WLC_E_STATUS_NO_NETWORKS)
2368 wl_notify_connect_status(struct wl_priv *wl, struct net_device *ndev,
2369 const wl_event_msg_t *e, void *data)
2374 if (wl_is_linkup(wl, e)) {
2376 if (wl_is_ibssmode(wl)) {
2377 cfg80211_ibss_joined(ndev, (s8 *)&e->addr,
2379 WL_DBG(("joined in IBSS network\n"));
2381 wl_bss_connect_done(wl, ndev, e, data, TRUE);
2382 WL_DBG(("joined in BSS network \"%s\"\n",
2383 ((struct wlc_ssid *)
2384 wl_read_prof(wl, WL_PROF_SSID))->SSID));
2387 wl_update_prof(wl, e, &act, WL_PROF_ACT);
2388 } else if (wl_is_linkdown(wl, e)) {
2389 cfg80211_disconnected(ndev, 0, NULL, 0, GFP_KERNEL);
2390 clear_bit(WL_STATUS_CONNECTED, &wl->status);
2392 wl_init_prof(wl->profile);
2393 } else if (wl_is_nonetwork(wl, e)) {
2394 wl_bss_connect_done(wl, ndev, e, data, FALSE);
2401 wl_notify_roaming_status(struct wl_priv *wl, struct net_device *ndev,
2402 const wl_event_msg_t *e, void *data)
2407 wl_bss_roaming_done(wl, ndev, e, data);
2409 wl_update_prof(wl, e, &act, WL_PROF_ACT);
2415 wl_dev_bufvar_set(struct net_device *dev, s8 *name, s8 *buf, s32 len)
2417 struct wl_priv *wl = ndev_to_wl(dev);
2420 buflen = bcm_mkiovar(name, buf, len, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2421 BUG_ON(unlikely(!buflen));
2423 return wl_dev_ioctl(dev, WLC_SET_VAR, wl->ioctl_buf, buflen);
2427 wl_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
2430 struct wl_priv *wl = ndev_to_wl(dev);
2434 len = bcm_mkiovar(name, NULL, 0, wl->ioctl_buf, WL_IOCTL_LEN_MAX);
2435 BUG_ON(unlikely(!len));
2436 err = wl_dev_ioctl(dev, WLC_GET_VAR, (void *)wl->ioctl_buf,
2438 if (unlikely(err)) {
2439 WL_ERR(("error (%d)\n", err));
2442 memcpy(buf, wl->ioctl_buf, buf_len);
2447 static s32 wl_get_assoc_ies(struct wl_priv *wl)
2449 struct net_device *ndev = wl_to_ndev(wl);
2450 struct wl_assoc_ielen *assoc_info;
2451 struct wl_connect_info *conn_info = wl_to_conn(wl);
2456 err = wl_dev_bufvar_get(ndev, "assoc_info", wl->extra_buf,
2458 if (unlikely(err)) {
2459 WL_ERR(("could not get assoc info (%d)\n", err));
2462 assoc_info = (struct wl_assoc_ielen *)wl->extra_buf;
2463 req_len = assoc_info->req_len;
2464 resp_len = assoc_info->resp_len;
2466 err = wl_dev_bufvar_get(ndev, "assoc_req_ies", wl->extra_buf,
2468 if (unlikely(err)) {
2469 WL_ERR(("could not get assoc req (%d)\n", err));
2472 conn_info->req_ie_len = req_len;
2474 kmemdup(wl->extra_buf, conn_info->req_ie_len, GFP_KERNEL);
2476 conn_info->req_ie_len = 0;
2477 conn_info->req_ie = NULL;
2480 err = wl_dev_bufvar_get(ndev, "assoc_resp_ies", wl->extra_buf,
2482 if (unlikely(err)) {
2483 WL_ERR(("could not get assoc resp (%d)\n", err));
2486 conn_info->resp_ie_len = resp_len;
2487 conn_info->resp_ie =
2488 kmemdup(wl->extra_buf, conn_info->resp_ie_len, GFP_KERNEL);
2490 conn_info->resp_ie_len = 0;
2491 conn_info->resp_ie = NULL;
2493 WL_DBG(("req len (%d) resp len (%d)\n", conn_info->req_ie_len,
2494 conn_info->resp_ie_len));
2499 static s32 wl_update_bss_info(struct wl_priv *wl)
2501 struct cfg80211_bss *bss;
2502 struct wl_bss_info *bi;
2503 struct wlc_ssid *ssid;
2506 if (wl_is_ibssmode(wl))
2509 ssid = (struct wlc_ssid *)wl_read_prof(wl, WL_PROF_SSID);
2511 cfg80211_get_bss(wl_to_wiphy(wl), NULL, (s8 *)&wl->bssid,
2512 ssid->SSID, ssid->SSID_len, WLAN_CAPABILITY_ESS,
2513 WLAN_CAPABILITY_ESS);
2516 if (unlikely(!bss)) {
2517 WL_DBG(("Could not find the AP\n"));
2518 *(u32 *) wl->extra_buf = htod32(WL_EXTRA_BUF_MAX);
2519 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_BSS_INFO,
2520 wl->extra_buf, WL_EXTRA_BUF_MAX);
2521 if (unlikely(err)) {
2522 WL_ERR(("Could not get bss info %d\n", err));
2523 goto update_bss_info_out;
2525 bi = (struct wl_bss_info *)(wl->extra_buf + 4);
2526 if (unlikely(memcmp(&bi->BSSID, &wl->bssid, ETHER_ADDR_LEN))) {
2528 goto update_bss_info_out;
2530 err = wl_inform_single_bss(wl, bi);
2532 goto update_bss_info_out;
2534 WL_DBG(("Found the AP in the list - "
2535 "BSSID %02x:%02x:%02x:%02x:%02x:%02x\n",
2536 bss->bssid[0], bss->bssid[1], bss->bssid[2],
2537 bss->bssid[3], bss->bssid[4], bss->bssid[5]));
2538 cfg80211_put_bss(bss);
2541 update_bss_info_out:
2547 wl_bss_roaming_done(struct wl_priv *wl, struct net_device *ndev,
2548 const wl_event_msg_t *e, void *data)
2550 struct wl_connect_info *conn_info = wl_to_conn(wl);
2553 wl_get_assoc_ies(wl);
2554 memcpy(&wl->bssid, &e->addr, ETHER_ADDR_LEN);
2555 wl_update_bss_info(wl);
2556 cfg80211_roamed(ndev,
2558 conn_info->req_ie, conn_info->req_ie_len,
2559 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
2560 WL_DBG(("Report roaming result\n"));
2562 set_bit(WL_STATUS_CONNECTED, &wl->status);
2568 wl_bss_connect_done(struct wl_priv *wl, struct net_device *ndev,
2569 const wl_event_msg_t *e, void *data, bool completed)
2571 struct wl_connect_info *conn_info = wl_to_conn(wl);
2574 wl_get_assoc_ies(wl);
2575 memcpy(&wl->bssid, &e->addr, ETHER_ADDR_LEN);
2576 wl_update_bss_info(wl);
2577 if (test_and_clear_bit(WL_STATUS_CONNECTING, &wl->status)) {
2578 cfg80211_connect_result(ndev,
2581 conn_info->req_ie_len,
2583 conn_info->resp_ie_len,
2584 completed ? WLAN_STATUS_SUCCESS : WLAN_STATUS_AUTH_TIMEOUT,
2586 WL_DBG(("Report connect result - connection %s\n",
2587 completed ? "succeeded" : "failed"));
2589 cfg80211_roamed(ndev,
2591 conn_info->req_ie, conn_info->req_ie_len,
2592 conn_info->resp_ie, conn_info->resp_ie_len,
2594 WL_DBG(("Report roaming result\n"));
2596 set_bit(WL_STATUS_CONNECTED, &wl->status);
2602 wl_notify_mic_status(struct wl_priv *wl, struct net_device *ndev,
2603 const wl_event_msg_t *e, void *data)
2605 u16 flags = ntoh16(e->flags);
2606 enum nl80211_key_type key_type;
2609 if (flags & WLC_EVENT_MSG_GROUP)
2610 key_type = NL80211_KEYTYPE_GROUP;
2612 key_type = NL80211_KEYTYPE_PAIRWISE;
2614 cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
2622 wl_notify_scan_status(struct wl_priv *wl, struct net_device *ndev,
2623 const wl_event_msg_t *e, void *data)
2625 struct channel_info channel_inform;
2626 struct wl_scan_results *bss_list;
2627 u32 len = WL_SCAN_BUF_MAX;
2630 if (wl->iscan_on && wl->iscan_kickstart)
2631 return wl_wakeup_iscan(wl_to_iscan(wl));
2633 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
2634 WL_ERR(("Scan complete while device not scanning\n"));
2637 if (unlikely(!wl->scan_request)) {
2640 err = wl_dev_ioctl(ndev, WLC_GET_CHANNEL, &channel_inform,
2641 sizeof(channel_inform));
2642 if (unlikely(err)) {
2643 WL_ERR(("scan busy (%d)\n", err));
2646 channel_inform.scan_channel = dtoh32(channel_inform.scan_channel);
2647 if (unlikely(channel_inform.scan_channel)) {
2649 WL_DBG(("channel_inform.scan_channel (%d)\n",
2650 channel_inform.scan_channel));
2652 wl->bss_list = wl->scan_results;
2653 bss_list = wl->bss_list;
2654 memset(bss_list, 0, len);
2655 bss_list->buflen = htod32(len);
2656 err = wl_dev_ioctl(ndev, WLC_SCAN_RESULTS, bss_list, len);
2657 if (unlikely(err)) {
2658 WL_ERR(("%s Scan_results error (%d)\n", ndev->name, err));
2662 bss_list->buflen = dtoh32(bss_list->buflen);
2663 bss_list->version = dtoh32(bss_list->version);
2664 bss_list->count = dtoh32(bss_list->count);
2666 err = wl_inform_bss(wl);
2671 if (wl->scan_request) {
2672 cfg80211_scan_done(wl->scan_request, FALSE);
2673 wl->scan_request = NULL;
2679 static void wl_init_conf(struct wl_conf *conf)
2681 conf->mode = (u32)-1;
2682 conf->frag_threshold = (u32)-1;
2683 conf->rts_threshold = (u32)-1;
2684 conf->retry_short = (u32)-1;
2685 conf->retry_long = (u32)-1;
2686 conf->tx_power = -1;
2689 static void wl_init_prof(struct wl_profile *prof)
2691 memset(prof, 0, sizeof(*prof));
2694 static void wl_init_eloop_handler(struct wl_event_loop *el)
2696 memset(el, 0, sizeof(*el));
2697 el->handler[WLC_E_SCAN_COMPLETE] = wl_notify_scan_status;
2698 el->handler[WLC_E_JOIN] = wl_notify_connect_status;
2699 el->handler[WLC_E_LINK] = wl_notify_connect_status;
2700 el->handler[WLC_E_DEAUTH_IND] = wl_notify_connect_status;
2701 el->handler[WLC_E_DISASSOC_IND] = wl_notify_connect_status;
2702 el->handler[WLC_E_ASSOC_IND] = wl_notify_connect_status;
2703 el->handler[WLC_E_REASSOC_IND] = wl_notify_connect_status;
2704 el->handler[WLC_E_ROAM] = wl_notify_roaming_status;
2705 el->handler[WLC_E_MIC_ERROR] = wl_notify_mic_status;
2706 el->handler[WLC_E_SET_SSID] = wl_notify_connect_status;
2709 static s32 wl_init_priv_mem(struct wl_priv *wl)
2711 wl->scan_results = (void *)kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
2712 if (unlikely(!wl->scan_results)) {
2713 WL_ERR(("Scan results alloc failed\n"));
2714 goto init_priv_mem_out;
2716 wl->conf = (void *)kzalloc(sizeof(*wl->conf), GFP_KERNEL);
2717 if (unlikely(!wl->conf)) {
2718 WL_ERR(("wl_conf alloc failed\n"));
2719 goto init_priv_mem_out;
2721 wl->profile = (void *)kzalloc(sizeof(*wl->profile), GFP_KERNEL);
2722 if (unlikely(!wl->profile)) {
2723 WL_ERR(("wl_profile alloc failed\n"));
2724 goto init_priv_mem_out;
2726 wl->bss_info = (void *)kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2727 if (unlikely(!wl->bss_info)) {
2728 WL_ERR(("Bss information alloc failed\n"));
2729 goto init_priv_mem_out;
2732 (void *)kzalloc(sizeof(*wl->scan_req_int), GFP_KERNEL);
2733 if (unlikely(!wl->scan_req_int)) {
2734 WL_ERR(("Scan req alloc failed\n"));
2735 goto init_priv_mem_out;
2737 wl->ioctl_buf = (void *)kzalloc(WL_IOCTL_LEN_MAX, GFP_KERNEL);
2738 if (unlikely(!wl->ioctl_buf)) {
2739 WL_ERR(("Ioctl buf alloc failed\n"));
2740 goto init_priv_mem_out;
2742 wl->extra_buf = (void *)kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
2743 if (unlikely(!wl->extra_buf)) {
2744 WL_ERR(("Extra buf alloc failed\n"));
2745 goto init_priv_mem_out;
2747 wl->iscan = (void *)kzalloc(sizeof(*wl->iscan), GFP_KERNEL);
2748 if (unlikely(!wl->iscan)) {
2749 WL_ERR(("Iscan buf alloc failed\n"));
2750 goto init_priv_mem_out;
2752 wl->fw = (void *)kzalloc(sizeof(*wl->fw), GFP_KERNEL);
2753 if (unlikely(!wl->fw)) {
2754 WL_ERR(("fw object alloc failed\n"));
2755 goto init_priv_mem_out;
2757 wl->pmk_list = (void *)kzalloc(sizeof(*wl->pmk_list), GFP_KERNEL);
2758 if (unlikely(!wl->pmk_list)) {
2759 WL_ERR(("pmk list alloc failed\n"));
2760 goto init_priv_mem_out;
2766 wl_deinit_priv_mem(wl);
2771 static void wl_deinit_priv_mem(struct wl_priv *wl)
2773 kfree(wl->scan_results);
2774 wl->scan_results = NULL;
2775 kfree(wl->bss_info);
2776 wl->bss_info = NULL;
2781 kfree(wl->scan_req_int);
2782 wl->scan_req_int = NULL;
2783 kfree(wl->ioctl_buf);
2784 wl->ioctl_buf = NULL;
2785 kfree(wl->extra_buf);
2786 wl->extra_buf = NULL;
2791 kfree(wl->pmk_list);
2792 wl->pmk_list = NULL;
2795 static s32 wl_create_event_handler(struct wl_priv *wl)
2797 sema_init(&wl->event_sync, 0);
2798 init_completion(&wl->event_exit);
2799 wl->event_pid = kernel_thread(wl_event_handler, wl, 0);
2800 if (unlikely(wl->event_pid < 0)) {
2801 WL_ERR(("failed to create event thread\n"));
2804 WL_DBG(("pid %d\n", wl->event_pid));
2808 static void wl_destroy_event_handler(struct wl_priv *wl)
2810 if (wl->event_pid >= 0) {
2811 KILL_PROC(wl->event_pid, SIGTERM);
2812 wait_for_completion(&wl->event_exit);
2816 static void wl_term_iscan(struct wl_priv *wl)
2818 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
2820 if (wl->iscan_on && iscan->pid >= 0) {
2821 iscan->state = WL_ISCAN_STATE_IDLE;
2822 KILL_PROC(iscan->pid, SIGTERM);
2823 wait_for_completion(&iscan->exited);
2828 static void wl_notify_iscan_complete(struct wl_iscan_ctrl *iscan, bool aborted)
2830 struct wl_priv *wl = iscan_to_wl(iscan);
2832 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING, &wl->status))) {
2833 WL_ERR(("Scan complete while device not scanning\n"));
2836 if (likely(wl->scan_request)) {
2837 cfg80211_scan_done(wl->scan_request, aborted);
2838 wl->scan_request = NULL;
2840 wl->iscan_kickstart = FALSE;
2843 static s32 wl_wakeup_iscan(struct wl_iscan_ctrl *iscan)
2845 if (likely(iscan->state != WL_ISCAN_STATE_IDLE)) {
2846 WL_DBG(("wake up iscan\n"));
2855 wl_get_iscan_results(struct wl_iscan_ctrl *iscan, u32 *status,
2856 struct wl_scan_results **bss_list)
2858 struct wl_iscan_results list;
2859 struct wl_scan_results *results;
2860 struct wl_iscan_results *list_buf;
2863 memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
2864 list_buf = (struct wl_iscan_results *)iscan->scan_buf;
2865 results = &list_buf->results;
2866 results->buflen = WL_ISCAN_RESULTS_FIXED_SIZE;
2867 results->version = 0;
2870 memset(&list, 0, sizeof(list));
2871 list.results.buflen = htod32(WL_ISCAN_BUF_MAX);
2872 err = wl_dev_iovar_getbuf(iscan->dev, "iscanresults", &list,
2873 WL_ISCAN_RESULTS_FIXED_SIZE, iscan->scan_buf,
2875 if (unlikely(err)) {
2876 WL_ERR(("error (%d)\n", err));
2879 results->buflen = dtoh32(results->buflen);
2880 results->version = dtoh32(results->version);
2881 results->count = dtoh32(results->count);
2882 WL_DBG(("results->count = %d\n", results->count));
2883 WL_DBG(("results->buflen = %d\n", results->buflen));
2884 *status = dtoh32(list_buf->status);
2885 *bss_list = results;
2890 static s32 wl_iscan_done(struct wl_priv *wl)
2892 struct wl_iscan_ctrl *iscan = wl->iscan;
2895 iscan->state = WL_ISCAN_STATE_IDLE;
2898 wl_notify_iscan_complete(iscan, FALSE);
2904 static s32 wl_iscan_pending(struct wl_priv *wl)
2906 struct wl_iscan_ctrl *iscan = wl->iscan;
2909 /* Reschedule the timer */
2910 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
2911 iscan->timer_on = 1;
2916 static s32 wl_iscan_inprogress(struct wl_priv *wl)
2918 struct wl_iscan_ctrl *iscan = wl->iscan;
2923 wl_run_iscan(iscan, NULL, WL_SCAN_ACTION_CONTINUE);
2925 /* Reschedule the timer */
2926 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
2927 iscan->timer_on = 1;
2932 static s32 wl_iscan_aborted(struct wl_priv *wl)
2934 struct wl_iscan_ctrl *iscan = wl->iscan;
2937 iscan->state = WL_ISCAN_STATE_IDLE;
2939 wl_notify_iscan_complete(iscan, TRUE);
2945 static s32 wl_iscan_thread(void *data)
2947 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
2948 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
2949 struct wl_priv *wl = iscan_to_wl(iscan);
2950 struct wl_iscan_eloop *el = &iscan->el;
2954 sched_setscheduler(current, SCHED_FIFO, ¶m);
2955 status = WL_SCAN_RESULTS_PARTIAL;
2956 while (likely(!down_interruptible(&iscan->sync))) {
2957 if (iscan->timer_on) {
2958 del_timer_sync(&iscan->timer);
2959 iscan->timer_on = 0;
2962 err = wl_get_iscan_results(iscan, &status, &wl->bss_list);
2963 if (unlikely(err)) {
2964 status = WL_SCAN_RESULTS_ABORTED;
2965 WL_ERR(("Abort iscan\n"));
2968 el->handler[status] (wl);
2970 if (iscan->timer_on) {
2971 del_timer_sync(&iscan->timer);
2972 iscan->timer_on = 0;
2974 complete_and_exit(&iscan->exited, 0);
2979 static void wl_iscan_timer(unsigned long data)
2981 struct wl_iscan_ctrl *iscan = (struct wl_iscan_ctrl *)data;
2984 iscan->timer_on = 0;
2985 WL_DBG(("timer expired\n"));
2986 wl_wakeup_iscan(iscan);
2990 static s32 wl_invoke_iscan(struct wl_priv *wl)
2992 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
2995 if (wl->iscan_on && iscan->pid < 0) {
2996 iscan->state = WL_ISCAN_STATE_IDLE;
2997 sema_init(&iscan->sync, 0);
2998 init_completion(&iscan->exited);
2999 iscan->pid = kernel_thread(wl_iscan_thread, iscan, 0);
3000 if (unlikely(iscan->pid < 0)) {
3001 WL_ERR(("Could not create iscan thread\n"));
3009 static void wl_init_iscan_eloop(struct wl_iscan_eloop *el)
3011 memset(el, 0, sizeof(*el));
3012 el->handler[WL_SCAN_RESULTS_SUCCESS] = wl_iscan_done;
3013 el->handler[WL_SCAN_RESULTS_PARTIAL] = wl_iscan_inprogress;
3014 el->handler[WL_SCAN_RESULTS_PENDING] = wl_iscan_pending;
3015 el->handler[WL_SCAN_RESULTS_ABORTED] = wl_iscan_aborted;
3016 el->handler[WL_SCAN_RESULTS_NO_MEM] = wl_iscan_aborted;
3019 static s32 wl_init_iscan(struct wl_priv *wl)
3021 struct wl_iscan_ctrl *iscan = wl_to_iscan(wl);
3025 iscan->dev = wl_to_ndev(wl);
3026 iscan->state = WL_ISCAN_STATE_IDLE;
3027 wl_init_iscan_eloop(&iscan->el);
3028 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
3029 init_timer(&iscan->timer);
3030 iscan->timer.data = (unsigned long) iscan;
3031 iscan->timer.function = wl_iscan_timer;
3032 sema_init(&iscan->sync, 0);
3033 init_completion(&iscan->exited);
3034 iscan->pid = kernel_thread(wl_iscan_thread, iscan, 0);
3035 if (unlikely(iscan->pid < 0)) {
3036 WL_ERR(("Could not create iscan thread\n"));
3045 static void wl_init_fw(struct wl_fw_ctrl *fw)
3047 fw->status = 0; /* init fw loading status.
3048 0 means nothing was loaded yet */
3051 static s32 wl_init_priv(struct wl_priv *wl)
3053 struct wiphy *wiphy = wl_to_wiphy(wl);
3056 wl->scan_request = NULL;
3057 wl->pwr_save = !!(wiphy->flags & WIPHY_FLAG_PS_ON_BY_DEFAULT);
3058 #ifndef WL_ISCAN_DISABLED
3059 wl->iscan_on = TRUE; /* iscan on & off switch.
3060 we enable iscan per default */
3062 wl->iscan_on = FALSE;
3063 #endif /* WL_ISCAN_DISABLED */
3064 #ifndef WL_ROAM_DISABLED
3065 wl->roam_on = TRUE; /* roam on & off switch.
3066 we enable roam per default */
3068 wl->roam_on = FALSE;
3069 #endif /* WL_ROAM_DISABLED */
3071 wl->iscan_kickstart = FALSE;
3072 wl->active_scan = TRUE; /* we do active scan for
3073 specific scan per default */
3074 wl->dongle_up = FALSE; /* dongle is not up yet */
3076 err = wl_init_priv_mem(wl);
3079 if (unlikely(wl_create_event_handler(wl)))
3081 wl_init_eloop_handler(&wl->el);
3082 mutex_init(&wl->usr_sync);
3083 err = wl_init_iscan(wl);
3087 wl_init_conf(wl->conf);
3088 wl_init_prof(wl->profile);
3094 static void wl_deinit_priv(struct wl_priv *wl)
3096 wl_destroy_event_handler(wl);
3097 wl->dongle_up = FALSE; /* dongle down */
3101 wl_deinit_priv_mem(wl);
3104 s32 wl_cfg80211_attach(struct net_device *ndev, void *data)
3106 struct wireless_dev *wdev;
3108 struct wl_iface *ci;
3111 if (unlikely(!ndev)) {
3112 WL_ERR(("ndev is invaild\n"));
3115 wl_cfg80211_dev = kzalloc(sizeof(struct wl_dev), GFP_KERNEL);
3116 if (unlikely(!wl_cfg80211_dev)) {
3117 WL_ERR(("wl_cfg80211_dev is invalid\n"));
3120 WL_DBG(("func %p\n", wl_cfg80211_get_sdio_func()));
3121 wdev = wl_alloc_wdev(sizeof(struct wl_iface), &wl_cfg80211_get_sdio_func()->dev);
3122 if (unlikely(IS_ERR(wdev)))
3125 wdev->iftype = wl_mode_to_nl80211_iftype(WL_MODE_BSS);
3126 wl = wdev_to_wl(wdev);
3129 ci = (struct wl_iface *)wl_to_ci(wl);
3131 ndev->ieee80211_ptr = wdev;
3132 wdev->netdev = ndev;
3133 err = wl_init_priv(wl);
3134 if (unlikely(err)) {
3135 WL_ERR(("Failed to init iwm_priv (%d)\n", err));
3136 goto cfg80211_attach_out;
3138 wl_set_drvdata(wl_cfg80211_dev, ci);
3139 set_bit(WL_STATUS_READY, &wl->status);
3143 cfg80211_attach_out:
3148 void wl_cfg80211_detach(void)
3156 wl_set_drvdata(wl_cfg80211_dev, NULL);
3157 kfree(wl_cfg80211_dev);
3158 wl_cfg80211_dev = NULL;
3159 wl_clear_sdio_func();
3162 static void wl_wakeup_event(struct wl_priv *wl)
3164 up(&wl->event_sync);
3167 static s32 wl_event_handler(void *data)
3169 struct wl_priv *wl = (struct wl_priv *)data;
3170 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3171 struct wl_event_q *e;
3173 sched_setscheduler(current, SCHED_FIFO, ¶m);
3174 while (likely(!down_interruptible(&wl->event_sync))) {
3175 e = wl_deq_event(wl);
3177 WL_ERR(("eqeue empty..\n"));
3180 WL_DBG(("event type (%d)\n", e->etype));
3181 if (wl->el.handler[e->etype]) {
3182 wl->el.handler[e->etype] (wl, wl_to_ndev(wl), &e->emsg,
3185 WL_DBG(("Unknown Event (%d): ignoring\n", e->etype));
3189 complete_and_exit(&wl->event_exit, 0);
3193 wl_cfg80211_event(struct net_device *ndev, const wl_event_msg_t * e, void *data)
3195 u32 event_type = ntoh32(e->event_type);
3196 struct wl_priv *wl = ndev_to_wl(ndev);
3197 #if (WL_DBG_LEVEL > 0)
3198 s8 *estr = (event_type <= sizeof(wl_dbg_estr) / WL_DBG_ESTR_MAX - 1) ?
3199 wl_dbg_estr[event_type] : (s8 *) "Unknown";
3200 #endif /* (WL_DBG_LEVEL > 0) */
3201 WL_DBG(("event_type (%d):" "WLC_E_" "%s\n", event_type, estr));
3202 if (likely(!wl_enq_event(wl, event_type, e, data)))
3203 wl_wakeup_event(wl);
3206 static void wl_init_eq(struct wl_priv *wl)
3208 wl_init_eq_lock(wl);
3209 INIT_LIST_HEAD(&wl->eq_list);
3212 static void wl_flush_eq(struct wl_priv *wl)
3214 struct wl_event_q *e;
3217 while (!list_empty(&wl->eq_list)) {
3218 e = list_first_entry(&wl->eq_list, struct wl_event_q, eq_list);
3219 list_del(&e->eq_list);
3226 * retrieve first queued event from head
3229 static struct wl_event_q *wl_deq_event(struct wl_priv *wl)
3231 struct wl_event_q *e = NULL;
3234 if (likely(!list_empty(&wl->eq_list))) {
3235 e = list_first_entry(&wl->eq_list, struct wl_event_q, eq_list);
3236 list_del(&e->eq_list);
3244 ** push event to tail of the queue
3248 wl_enq_event(struct wl_priv *wl, u32 event, const wl_event_msg_t *msg,
3251 struct wl_event_q *e;
3254 e = kzalloc(sizeof(struct wl_event_q), GFP_KERNEL);
3256 WL_ERR(("event alloc failed\n"));
3261 memcpy(&e->emsg, msg, sizeof(wl_event_msg_t));
3265 list_add_tail(&e->eq_list, &wl->eq_list);
3271 static void wl_put_event(struct wl_event_q *e)
3276 void wl_cfg80211_sdio_func(void *func)
3278 cfg80211_sdio_func = (struct sdio_func *)func;
3281 static void wl_clear_sdio_func(void)
3283 cfg80211_sdio_func = NULL;
3286 struct sdio_func *wl_cfg80211_get_sdio_func(void)
3288 return cfg80211_sdio_func;
3291 static s32 wl_dongle_mode(struct net_device *ndev, s32 iftype)
3298 case NL80211_IFTYPE_MONITOR:
3299 case NL80211_IFTYPE_WDS:
3300 WL_ERR(("type (%d) : currently we do not support this mode\n",
3304 case NL80211_IFTYPE_ADHOC:
3306 case NL80211_IFTYPE_STATION:
3311 WL_ERR(("invalid type (%d)\n", iftype));
3314 infra = htod32(infra);
3316 WL_DBG(("%s ap (%d), infra (%d)\n", ndev->name, ap, infra));
3317 err = wl_dev_ioctl(ndev, WLC_SET_INFRA, &infra, sizeof(infra));
3318 if (unlikely(err)) {
3319 WL_ERR(("WLC_SET_INFRA error (%d)\n", err));
3322 err = wl_dev_ioctl(ndev, WLC_SET_AP, &ap, sizeof(ap));
3323 if (unlikely(err)) {
3324 WL_ERR(("WLC_SET_AP error (%d)\n", err));
3328 return -EINPROGRESS;
3331 #ifndef EMBEDDED_PLATFORM
3332 static s32 wl_dongle_country(struct net_device *ndev, u8 ccode)
3340 static s32 wl_dongle_up(struct net_device *ndev, u32 up)
3344 err = wl_dev_ioctl(ndev, WLC_UP, &up, sizeof(up));
3345 if (unlikely(err)) {
3346 WL_ERR(("WLC_UP error (%d)\n", err));
3351 static s32 wl_dongle_power(struct net_device *ndev, u32 power_mode)
3355 err = wl_dev_ioctl(ndev, WLC_SET_PM, &power_mode, sizeof(power_mode));
3356 if (unlikely(err)) {
3357 WL_ERR(("WLC_SET_PM error (%d)\n", err));
3363 wl_dongle_glom(struct net_device *ndev, u32 glom, u32 dongle_align)
3365 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3369 /* Match Host and Dongle rx alignment */
3370 bcm_mkiovar("bus:txglomalign", (char *)&dongle_align, 4, iovbuf,
3372 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3373 if (unlikely(err)) {
3374 WL_ERR(("txglomalign error (%d)\n", err));
3375 goto dongle_glom_out;
3377 /* disable glom option per default */
3378 bcm_mkiovar("bus:txglom", (char *)&glom, 4, iovbuf, sizeof(iovbuf));
3379 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3380 if (unlikely(err)) {
3381 WL_ERR(("txglom error (%d)\n", err));
3382 goto dongle_glom_out;
3389 wl_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
3391 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3395 /* Setup timeout if Beacons are lost and roam is
3396 off to report link down */
3398 bcm_mkiovar("bcn_timeout", (char *)&bcn_timeout, 4, iovbuf,
3400 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3401 if (unlikely(err)) {
3402 WL_ERR(("bcn_timeout error (%d)\n", err));
3403 goto dongle_rom_out;
3406 /* Enable/Disable built-in roaming to allow supplicant
3407 to take care of roaming */
3408 bcm_mkiovar("roam_off", (char *)&roamvar, 4, iovbuf, sizeof(iovbuf));
3409 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3410 if (unlikely(err)) {
3411 WL_ERR(("roam_off error (%d)\n", err));
3412 goto dongle_rom_out;
3418 static s32 wl_dongle_eventmsg(struct net_device *ndev)
3421 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3423 s8 eventmask[WL_EVENTING_MASK_LEN];
3426 /* Setup event_msgs */
3427 bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
3429 err = wl_dev_ioctl(ndev, WLC_GET_VAR, iovbuf, sizeof(iovbuf));
3430 if (unlikely(err)) {
3431 WL_ERR(("Get event_msgs error (%d)\n", err));
3432 goto dongle_eventmsg_out;
3434 memcpy(eventmask, iovbuf, WL_EVENTING_MASK_LEN);
3436 setbit(eventmask, WLC_E_SET_SSID);
3437 setbit(eventmask, WLC_E_PRUNE);
3438 setbit(eventmask, WLC_E_AUTH);
3439 setbit(eventmask, WLC_E_REASSOC);
3440 setbit(eventmask, WLC_E_REASSOC_IND);
3441 setbit(eventmask, WLC_E_DEAUTH_IND);
3442 setbit(eventmask, WLC_E_DISASSOC_IND);
3443 setbit(eventmask, WLC_E_DISASSOC);
3444 setbit(eventmask, WLC_E_JOIN);
3445 setbit(eventmask, WLC_E_ASSOC_IND);
3446 setbit(eventmask, WLC_E_PSK_SUP);
3447 setbit(eventmask, WLC_E_LINK);
3448 setbit(eventmask, WLC_E_NDIS_LINK);
3449 setbit(eventmask, WLC_E_MIC_ERROR);
3450 setbit(eventmask, WLC_E_PMKID_CACHE);
3451 setbit(eventmask, WLC_E_TXFAIL);
3452 setbit(eventmask, WLC_E_JOIN_START);
3453 setbit(eventmask, WLC_E_SCAN_COMPLETE);
3455 bcm_mkiovar("event_msgs", eventmask, WL_EVENTING_MASK_LEN, iovbuf,
3457 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3458 if (unlikely(err)) {
3459 WL_ERR(("Set event_msgs error (%d)\n", err));
3460 goto dongle_eventmsg_out;
3463 dongle_eventmsg_out:
3468 wl_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
3469 s32 scan_unassoc_time)
3473 err = wl_dev_ioctl(ndev, WLC_SET_SCAN_CHANNEL_TIME, &scan_assoc_time,
3474 sizeof(scan_assoc_time));
3476 if (err == -EOPNOTSUPP) {
3477 WL_INFO(("Scan assoc time is not supported\n"));
3479 WL_ERR(("Scan assoc time error (%d)\n", err));
3481 goto dongle_scantime_out;
3483 err = wl_dev_ioctl(ndev, WLC_SET_SCAN_UNASSOC_TIME, &scan_unassoc_time,
3484 sizeof(scan_unassoc_time));
3486 if (err == -EOPNOTSUPP) {
3487 WL_INFO(("Scan unassoc time is not supported\n"));
3489 WL_ERR(("Scan unassoc time error (%d)\n", err));
3491 goto dongle_scantime_out;
3494 dongle_scantime_out:
3499 wl_dongle_offload(struct net_device *ndev, s32 arpoe, s32 arp_ol)
3501 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3505 /* Set ARP offload */
3506 bcm_mkiovar("arpoe", (char *)&arpoe, 4, iovbuf, sizeof(iovbuf));
3507 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3509 if (err == -EOPNOTSUPP)
3510 WL_INFO(("arpoe is not supported\n"));
3512 WL_ERR(("arpoe error (%d)\n", err));
3514 goto dongle_offload_out;
3516 bcm_mkiovar("arp_ol", (char *)&arp_ol, 4, iovbuf, sizeof(iovbuf));
3517 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3519 if (err == -EOPNOTSUPP)
3520 WL_INFO(("arp_ol is not supported\n"));
3522 WL_ERR(("arp_ol error (%d)\n", err));
3524 goto dongle_offload_out;
3531 static s32 wl_pattern_atoh(s8 *src, s8 *dst)
3533 #define strtoul(nptr, endptr, base) bcm_strtoul((nptr), (endptr), (base))
3535 if (strncmp(src, "0x", 2) != 0 && strncmp(src, "0X", 2) != 0) {
3536 WL_ERR(("Mask invalid format. Needs to start with 0x\n"));
3539 src = src + 2; /* Skip past 0x */
3540 if (strlen(src) % 2 != 0) {
3541 WL_ERR(("Mask invalid format. Needs to be of even length\n"));
3544 for (i = 0; *src != '\0'; i++) {
3546 strncpy(num, src, 2);
3548 dst[i] = (u8) strtoul(num, NULL, 16);
3554 static s32 wl_dongle_filter(struct net_device *ndev, u32 filter_mode)
3556 s8 iovbuf[WL_EVENTING_MASK_LEN + 12]; /* Room for "event_msgs" +
3559 struct wl_pkt_filter pkt_filter;
3560 struct wl_pkt_filter *pkt_filterp;
3568 /* add a default packet filter pattern */
3569 str = "pkt_filter_add";
3570 str_len = strlen(str);
3571 strncpy(buf, str, str_len);
3572 buf[str_len] = '\0';
3573 buf_len = str_len + 1;
3575 pkt_filterp = (struct wl_pkt_filter *)(buf + str_len + 1);
3577 /* Parse packet filter id. */
3578 pkt_filter.id = htod32(100);
3580 /* Parse filter polarity. */
3581 pkt_filter.negate_match = htod32(0);
3583 /* Parse filter type. */
3584 pkt_filter.type = htod32(0);
3586 /* Parse pattern filter offset. */
3587 pkt_filter.u.pattern.offset = htod32(0);
3589 /* Parse pattern filter mask. */
3590 mask_size = htod32(wl_pattern_atoh("0xff",
3591 (char *)pkt_filterp->u.pattern.
3594 /* Parse pattern filter pattern. */
3595 pattern_size = htod32(wl_pattern_atoh("0x00",
3596 (char *)&pkt_filterp->u.pattern.
3597 mask_and_pattern[mask_size]));
3599 if (mask_size != pattern_size) {
3600 WL_ERR(("Mask and pattern not the same size\n"));
3602 goto dongle_filter_out;
3605 pkt_filter.u.pattern.size_bytes = mask_size;
3606 buf_len += WL_PKT_FILTER_FIXED_LEN;
3607 buf_len += (WL_PKT_FILTER_PATTERN_FIXED_LEN + 2 * mask_size);
3609 /* Keep-alive attributes are set in local
3610 * variable (keep_alive_pkt), and
3611 * then memcpy'ed into buffer (keep_alive_pktp) since there is no
3612 * guarantee that the buffer is properly aligned.
3614 memcpy((char *)pkt_filterp, &pkt_filter,
3615 WL_PKT_FILTER_FIXED_LEN + WL_PKT_FILTER_PATTERN_FIXED_LEN);
3617 err = wl_dev_ioctl(ndev, WLC_SET_VAR, buf, buf_len);
3619 if (err == -EOPNOTSUPP) {
3620 WL_INFO(("filter not supported\n"));
3622 WL_ERR(("filter (%d)\n", err));
3624 goto dongle_filter_out;
3627 /* set mode to allow pattern */
3628 bcm_mkiovar("pkt_filter_mode", (char *)&filter_mode, 4, iovbuf,
3630 err = wl_dev_ioctl(ndev, WLC_SET_VAR, iovbuf, sizeof(iovbuf));
3632 if (err == -EOPNOTSUPP) {
3633 WL_INFO(("filter_mode not supported\n"));
3635 WL_ERR(("filter_mode (%d)\n", err));
3637 goto dongle_filter_out;
3643 #endif /* !EMBEDDED_PLATFORM */
3645 s32 wl_config_dongle(struct wl_priv *wl, bool need_lock)
3648 #define DHD_SDALIGN 32
3650 struct net_device *ndev;
3651 struct wireless_dev *wdev;
3657 ndev = wl_to_ndev(wl);
3658 wdev = ndev->ieee80211_ptr;
3662 #ifndef EMBEDDED_PLATFORM
3663 err = wl_dongle_up(ndev, 0);
3665 goto default_conf_out;
3666 err = wl_dongle_country(ndev, 0);
3668 goto default_conf_out;
3669 err = wl_dongle_power(ndev, PM_FAST);
3671 goto default_conf_out;
3672 err = wl_dongle_glom(ndev, 0, DHD_SDALIGN);
3674 goto default_conf_out;
3675 err = wl_dongle_roam(ndev, (wl->roam_on ? 0 : 1), 3);
3677 goto default_conf_out;
3678 err = wl_dongle_eventmsg(ndev);
3680 goto default_conf_out;
3682 wl_dongle_scantime(ndev, 40, 80);
3683 wl_dongle_offload(ndev, 1, 0xf);
3684 wl_dongle_filter(ndev, 1);
3685 #endif /* !EMBEDDED_PLATFORM */
3687 err = wl_dongle_mode(ndev, wdev->iftype);
3688 if (unlikely(err && err != -EINPROGRESS))
3689 goto default_conf_out;
3690 err = wl_dongle_probecap(wl);
3692 goto default_conf_out;
3694 /* -EINPROGRESS: Call commit handler */
3700 wl->dongle_up = TRUE;
3706 static s32 wl_update_wiphybands(struct wl_priv *wl)
3708 struct wiphy *wiphy;
3713 err = wl_dev_ioctl(wl_to_ndev(wl), WLC_GET_PHYLIST, &phy_list,
3715 if (unlikely(err)) {
3716 WL_ERR(("error (%d)\n", err));
3720 phy = ((char *)&phy_list)[1];
3721 WL_DBG(("%c phy\n", phy));
3722 if (phy == 'n' || phy == 'a') {
3723 wiphy = wl_to_wiphy(wl);
3724 wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
3730 static s32 __wl_cfg80211_up(struct wl_priv *wl)
3734 err = wl_config_dongle(wl, FALSE);
3738 wl_invoke_iscan(wl);
3739 set_bit(WL_STATUS_READY, &wl->status);
3743 static s32 __wl_cfg80211_down(struct wl_priv *wl)
3747 /* Check if cfg80211 interface is already down */
3748 if (!test_bit(WL_STATUS_READY, &wl->status))
3749 return err; /* it is even not ready */
3751 set_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
3753 if (wl->scan_request) {
3754 cfg80211_scan_done(wl->scan_request, TRUE); /* TRUE
3756 wl->scan_request = NULL;
3758 clear_bit(WL_STATUS_READY, &wl->status);
3759 clear_bit(WL_STATUS_SCANNING, &wl->status);
3760 clear_bit(WL_STATUS_SCAN_ABORTING, &wl->status);
3761 clear_bit(WL_STATUS_CONNECTED, &wl->status);
3766 s32 wl_cfg80211_up(void)
3772 mutex_lock(&wl->usr_sync);
3773 err = __wl_cfg80211_up(wl);
3774 mutex_unlock(&wl->usr_sync);
3779 s32 wl_cfg80211_down(void)
3785 mutex_lock(&wl->usr_sync);
3786 err = __wl_cfg80211_down(wl);
3787 mutex_unlock(&wl->usr_sync);
3792 static s32 wl_dongle_probecap(struct wl_priv *wl)
3796 err = wl_update_wiphybands(wl);
3803 static void *wl_read_prof(struct wl_priv *wl, s32 item)
3807 return &wl->profile->sec;
3809 return &wl->profile->active;
3811 return &wl->profile->bssid;
3813 return &wl->profile->ssid;
3815 WL_ERR(("invalid item (%d)\n", item));
3820 wl_update_prof(struct wl_priv *wl, const wl_event_msg_t *e, void *data,
3824 struct wlc_ssid *ssid;
3828 ssid = (wlc_ssid_t *) data;
3829 memset(wl->profile->ssid.SSID, 0,
3830 sizeof(wl->profile->ssid.SSID));
3831 memcpy(wl->profile->ssid.SSID, ssid->SSID, ssid->SSID_len);
3832 wl->profile->ssid.SSID_len = ssid->SSID_len;
3836 memcpy(wl->profile->bssid, data, ETHER_ADDR_LEN);
3838 memset(wl->profile->bssid, 0, ETHER_ADDR_LEN);
3841 memcpy(&wl->profile->sec, data, sizeof(wl->profile->sec));
3844 wl->profile->active = *(bool *) data;
3847 WL_ERR(("unsupported item (%d)\n", item));
3855 void wl_cfg80211_dbg_level(u32 level)
3858 * prohibit to change debug level
3859 * by insmod parameter.
3860 * eventually debug level will be configured
3861 * in compile time by using CONFIG_XXX
3863 /* wl_dbg_level = level; */
3866 static bool wl_is_ibssmode(struct wl_priv *wl)
3868 return wl->conf->mode == WL_MODE_IBSS;
3871 static bool wl_is_ibssstarter(struct wl_priv *wl)
3873 return wl->ibss_starter;
3876 static void wl_rst_ie(struct wl_priv *wl)
3878 struct wl_ie *ie = wl_to_ie(wl);
3883 static s32 wl_add_ie(struct wl_priv *wl, u8 t, u8 l, u8 *v)
3885 struct wl_ie *ie = wl_to_ie(wl);
3888 if (unlikely(ie->offset + l + 2 > WL_TLV_INFO_MAX)) {
3889 WL_ERR(("ei crosses buffer boundary\n"));
3892 ie->buf[ie->offset] = t;
3893 ie->buf[ie->offset + 1] = l;
3894 memcpy(&ie->buf[ie->offset + 2], v, l);
3895 ie->offset += l + 2;
3900 static s32 wl_mrg_ie(struct wl_priv *wl, u8 *ie_stream, u16 ie_size)
3902 struct wl_ie *ie = wl_to_ie(wl);
3905 if (unlikely(ie->offset + ie_size > WL_TLV_INFO_MAX)) {
3906 WL_ERR(("ei_stream crosses buffer boundary\n"));
3909 memcpy(&ie->buf[ie->offset], ie_stream, ie_size);
3910 ie->offset += ie_size;
3915 static s32 wl_cp_ie(struct wl_priv *wl, u8 *dst, u16 dst_size)
3917 struct wl_ie *ie = wl_to_ie(wl);
3920 if (unlikely(ie->offset > dst_size)) {
3921 WL_ERR(("dst_size is not enough\n"));
3924 memcpy(dst, &ie->buf[0], ie->offset);
3929 static u32 wl_get_ielen(struct wl_priv *wl)
3931 struct wl_ie *ie = wl_to_ie(wl);
3936 static void wl_link_up(struct wl_priv *wl)
3941 static void wl_link_down(struct wl_priv *wl)
3943 struct wl_connect_info *conn_info = wl_to_conn(wl);
3945 wl->link_up = FALSE;
3946 kfree(conn_info->req_ie);
3947 conn_info->req_ie = NULL;
3948 conn_info->req_ie_len = 0;
3949 kfree(conn_info->resp_ie);
3950 conn_info->resp_ie = NULL;
3951 conn_info->resp_ie_len = 0;
3954 static void wl_lock_eq(struct wl_priv *wl)
3956 spin_lock_irq(&wl->eq_lock);
3959 static void wl_unlock_eq(struct wl_priv *wl)
3961 spin_unlock_irq(&wl->eq_lock);
3964 static void wl_init_eq_lock(struct wl_priv *wl)
3966 spin_lock_init(&wl->eq_lock);
3969 static void wl_delay(u32 ms)
3971 if (ms < 1000 / HZ) {
3979 static void wl_set_drvdata(struct wl_dev *dev, void *data)
3981 dev->driver_data = data;
3984 static void *wl_get_drvdata(struct wl_dev *dev)
3986 return dev->driver_data;
3989 s32 wl_cfg80211_read_fw(s8 *buf, u32 size)
3991 const struct firmware *fw_entry;
3996 fw_entry = wl->fw->fw_entry;
3998 if (fw_entry->size < wl->fw->ptr + size)
3999 size = fw_entry->size - wl->fw->ptr;
4001 memcpy(buf, &fw_entry->data[wl->fw->ptr], size);
4002 wl->fw->ptr += size;
4006 void wl_cfg80211_release_fw(void)
4011 release_firmware(wl->fw->fw_entry);
4015 void *wl_cfg80211_request_fw(s8 *file_name)
4018 const struct firmware *fw_entry = NULL;
4021 WL_DBG(("file name : \"%s\"\n", file_name));
4024 if (!test_bit(WL_FW_LOADING_DONE, &wl->fw->status)) {
4025 err = request_firmware(&wl->fw->fw_entry, file_name,
4026 &wl_cfg80211_get_sdio_func()->dev);
4027 if (unlikely(err)) {
4028 WL_ERR(("Could not download fw (%d)\n", err));
4031 set_bit(WL_FW_LOADING_DONE, &wl->fw->status);
4032 fw_entry = wl->fw->fw_entry;
4034 WL_DBG(("fw size (%zd), data (%p)\n", fw_entry->size,
4037 } else if (!test_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status)) {
4038 err = request_firmware(&wl->fw->fw_entry, file_name,
4039 &wl_cfg80211_get_sdio_func()->dev);
4040 if (unlikely(err)) {
4041 WL_ERR(("Could not download nvram (%d)\n", err));
4044 set_bit(WL_NVRAM_LOADING_DONE, &wl->fw->status);
4045 fw_entry = wl->fw->fw_entry;
4047 WL_DBG(("nvram size (%zd), data (%p)\n", fw_entry->size,
4051 WL_DBG(("Downloading already done. Nothing to do more\n"));
4056 if (unlikely(err)) {
4060 return (void *)fw_entry->data;
4063 s8 *wl_cfg80211_get_fwname(void)
4068 strcpy(wl->fw->fw_name, WL_4329_FW_FILE);
4069 return wl->fw->fw_name;
4072 s8 *wl_cfg80211_get_nvramname(void)
4077 strcpy(wl->fw->nvram_name, WL_4329_NVRAM_FILE);
4078 return wl->fw->nvram_name;