?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
staging: brcm80211: remove brcmf_find_msb() function
[linux-2.6/kvm.git] / drivers / staging / brcm80211 / brcmfmac / wl_cfg80211.c
blob4f7b0816af7b6fed4775dbec0e6a60771adf8d13
1 /*
2 * Copyright (c) 2010 Broadcom Corporation
3 *
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.
7 *
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.
15 */
16
17 #include <linux/kernel.h>
18 #include <linux/if_arp.h>
19 #include <linux/sched.h>
20 #include <linux/kthread.h>
21 #include <linux/netdevice.h>
22 #include <linux/sched.h>
23 #include <linux/bitops.h>
24 #include <linux/etherdevice.h>
25 #include <linux/ieee80211.h>
26 #include <linux/mmc/sdio_func.h>
27 #include <linux/uaccess.h>
28 #include <net/cfg80211.h>
29 #include <net/rtnetlink.h>
30
31 #include <brcmu_utils.h>
32 #include <defs.h>
33 #include <brcmu_wifi.h>
34 #include "dhd.h"
35 #include "wl_cfg80211.h"
36
37 static struct sdio_func *cfg80211_sdio_func;
38 static struct brcmf_cfg80211_dev *cfg80211_dev;
39 static const u8 ether_bcast[ETH_ALEN] = {255, 255, 255, 255, 255, 255};
40
41 u32 brcmf_dbg_level = WL_DBG_ERR;
42
43 /*
44 ** cfg80211_ops api/callback list
45 */
46 static s32 brcmf_cfg80211_change_iface(struct wiphy *wiphy,
47 struct net_device *ndev,
48 enum nl80211_iftype type, u32 *flags,
49 struct vif_params *params);
50 static s32 __brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
51 struct cfg80211_scan_request *request,
52 struct cfg80211_ssid *this_ssid);
53 static s32 brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
54 struct cfg80211_scan_request *request);
55 static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed);
56 static s32 brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
57 struct cfg80211_ibss_params *params);
58 static s32 brcmf_cfg80211_leave_ibss(struct wiphy *wiphy,
59 struct net_device *dev);
60 static s32 brcmf_cfg80211_get_station(struct wiphy *wiphy,
61 struct net_device *dev, u8 *mac,
62 struct station_info *sinfo);
63 static s32 brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy,
64 struct net_device *dev, bool enabled,
65 s32 timeout);
66 static s32 brcmf_cfg80211_set_bitrate_mask(struct wiphy *wiphy,
67 struct net_device *dev,
68 const u8 *addr,
69 const struct cfg80211_bitrate_mask
70 *mask);
71 static int brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
72 struct cfg80211_connect_params *sme);
73 static s32 brcmf_cfg80211_disconnect(struct wiphy *wiphy,
74 struct net_device *dev,
75 u16 reason_code);
76 static s32 brcmf_cfg80211_set_tx_power(struct wiphy *wiphy,
77 enum nl80211_tx_power_setting type,
78 s32 dbm);
79 static s32 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm);
80 static s32 brcmf_cfg80211_config_default_key(struct wiphy *wiphy,
81 struct net_device *dev, u8 key_idx,
82 bool unicast, bool multicast);
83 static s32 brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
84 u8 key_idx, bool pairwise, const u8 *mac_addr,
85 struct key_params *params);
86 static s32 brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
87 u8 key_idx, bool pairwise, const u8 *mac_addr);
88 static s32 brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
89 u8 key_idx, bool pairwise, const u8 *mac_addr,
90 void *cookie, void (*callback) (void *cookie,
91 struct
92 key_params *
93 params));
94 static s32 brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
95 struct net_device *dev,
96 u8 key_idx);
97 static s32 brcmf_cfg80211_resume(struct wiphy *wiphy);
98 static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
99 struct cfg80211_wowlan *wow);
100 static s32 brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
101 struct cfg80211_pmksa *pmksa);
102 static s32 brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
103 struct cfg80211_pmksa *pmksa);
104 static s32 brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy,
105 struct net_device *dev);
106 /*
107 ** event & event Q handlers for cfg80211 interfaces
108 */
109 static s32 brcmf_create_event_handler(struct brcmf_cfg80211_priv *cfg_priv);
110 static void brcmf_destroy_event_handler(struct brcmf_cfg80211_priv *cfg_priv);
111 static s32 brcmf_event_handler(void *data);
112 static void brcmf_init_eq(struct brcmf_cfg80211_priv *cfg_priv);
113 static void brcmf_flush_eq(struct brcmf_cfg80211_priv *cfg_priv);
114 static void brcmf_lock_eq(struct brcmf_cfg80211_priv *cfg_priv);
115 static void brcmf_unlock_eq(struct brcmf_cfg80211_priv *cfg_priv);
116 static void brcmf_init_eq_lock(struct brcmf_cfg80211_priv *cfg_priv);
117 static void brcmf_init_eloop_handler(struct brcmf_cfg80211_event_loop *el);
118 static struct brcmf_cfg80211_event_q *
119 brcmf_deq_event(struct brcmf_cfg80211_priv *cfg_priv);
120 static s32 brcmf_enq_event(struct brcmf_cfg80211_priv *cfg_priv, u32 type,
121 const struct brcmf_event_msg *msg);
122 static void brcmf_put_event(struct brcmf_cfg80211_event_q *e);
123 static void brcmf_wakeup_event(struct brcmf_cfg80211_priv *cfg_priv);
124 static s32 brcmf_notify_connect_status(struct brcmf_cfg80211_priv *cfg_priv,
125 struct net_device *ndev,
126 const struct brcmf_event_msg *e,
127 void *data);
128 static s32 brcmf_notify_roaming_status(struct brcmf_cfg80211_priv *cfg_priv,
129 struct net_device *ndev,
130 const struct brcmf_event_msg *e,
131 void *data);
132 static s32 brcmf_notify_scan_status(struct brcmf_cfg80211_priv *cfg_priv,
133 struct net_device *ndev,
134 const struct brcmf_event_msg *e,
135 void *data);
136 static s32 brcmf_bss_connect_done(struct brcmf_cfg80211_priv *cfg_priv,
137 struct net_device *ndev,
138 const struct brcmf_event_msg *e,
139 bool completed);
140 static s32 brcmf_bss_roaming_done(struct brcmf_cfg80211_priv *cfg_priv,
141 struct net_device *ndev,
142 const struct brcmf_event_msg *e);
143 static s32 brcmf_notify_mic_status(struct brcmf_cfg80211_priv *cfg_priv,
144 struct net_device *ndev,
145 const struct brcmf_event_msg *e, void *data);
146
147 /*
148 ** register/deregister sdio function
149 */
150 static void brcmf_clear_sdio_func(void);
151
152 /*
153 ** ioctl utilites
154 */
155 static s32 brcmf_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
156 s32 buf_len);
157 static __used s32 brcmf_dev_bufvar_set(struct net_device *dev, s8 *name,
158 s8 *buf, s32 len);
159 static s32 brcmf_dev_intvar_set(struct net_device *dev, s8 *name, s32 val);
160 static s32 brcmf_dev_intvar_get(struct net_device *dev, s8 *name,
161 s32 *retval);
162 static s32 brcmf_dev_ioctl(struct net_device *dev, u32 cmd, void *arg,
163 u32 len);
164
165 /*
166 ** cfg80211 set_wiphy_params utilities
167 */
168 static s32 brcmf_set_frag(struct net_device *dev, u32 frag_threshold);
169 static s32 brcmf_set_rts(struct net_device *dev, u32 frag_threshold);
170 static s32 brcmf_set_retry(struct net_device *dev, u32 retry, bool l);
171
172 /*
173 ** wl profile utilities
174 */
175 static s32 brcmf_update_prof(struct brcmf_cfg80211_priv *cfg_priv,
176 const struct brcmf_event_msg *e,
177 void *data, s32 item);
178 static void *brcmf_read_prof(struct brcmf_cfg80211_priv *cfg_priv, s32 item);
179 static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof);
180
181 /*
182 ** cfg80211 connect utilites
183 */
184 static s32 brcmf_set_wpa_version(struct net_device *dev,
185 struct cfg80211_connect_params *sme);
186 static s32 brcmf_set_auth_type(struct net_device *dev,
187 struct cfg80211_connect_params *sme);
188 static s32 brcmf_set_set_cipher(struct net_device *dev,
189 struct cfg80211_connect_params *sme);
190 static s32 brcmf_set_key_mgmt(struct net_device *dev,
191 struct cfg80211_connect_params *sme);
192 static s32 brcmf_set_set_sharedkey(struct net_device *dev,
193 struct cfg80211_connect_params *sme);
194 static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv);
195 static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv);
196 static void brcmf_ch_to_chanspec(int ch,
197 struct brcmf_join_params *join_params, size_t *join_params_size);
198
199 /*
200 ** information element utilities
201 */
202 static __used s32 brcmf_add_ie(struct brcmf_cfg80211_priv *cfg_priv,
203 u8 t, u8 l, u8 *v);
204 static s32 brcmf_mode_to_nl80211_iftype(s32 mode);
205 static struct wireless_dev *brcmf_alloc_wdev(s32 sizeof_iface,
206 struct device *dev);
207 static void brcmf_free_wdev(struct brcmf_cfg80211_priv *cfg_priv);
208 static s32 brcmf_inform_bss(struct brcmf_cfg80211_priv *cfg_priv);
209 static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_priv *cfg_priv,
210 struct brcmf_bss_info *bi);
211 static s32 brcmf_update_bss_info(struct brcmf_cfg80211_priv *cfg_priv);
212 static s32 brcmf_add_keyext(struct wiphy *wiphy, struct net_device *dev,
213 u8 key_idx, const u8 *mac_addr,
214 struct key_params *params);
215
216 /*
217 ** key indianess swap utilities
218 */
219 static void convert_key_from_CPU(struct brcmf_wsec_key *key);
220 static void convert_key_to_CPU(struct brcmf_wsec_key *key);
221
222 /*
223 ** brcmf_cfg80211_priv memory init/deinit utilities
224 */
225 static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_priv *cfg_priv);
226 static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_priv *cfg_priv);
227
228 static void brcmf_delay(u32 ms);
229
230 /*
231 ** store/restore cfg80211 instance data
232 */
233 static void brcmf_set_drvdata(struct brcmf_cfg80211_dev *dev, void *data);
234 static void *brcmf_get_drvdata(struct brcmf_cfg80211_dev *dev);
235
236 /*
237 ** ibss mode utilities
238 */
239 static bool brcmf_is_ibssmode(struct brcmf_cfg80211_priv *cfg_priv);
240
241 /*
242 ** dongle up/down , default configuration utilities
243 */
244 static bool brcmf_is_linkdown(struct brcmf_cfg80211_priv *cfg_priv,
245 const struct brcmf_event_msg *e);
246 static bool brcmf_is_linkup(struct brcmf_cfg80211_priv *cfg_priv,
247 const struct brcmf_event_msg *e);
248 static bool brcmf_is_nonetwork(struct brcmf_cfg80211_priv *cfg_priv,
249 const struct brcmf_event_msg *e);
250 static void brcmf_link_down(struct brcmf_cfg80211_priv *cfg_priv);
251 static s32 brcmf_dongle_mode(struct net_device *ndev, s32 iftype);
252 static s32 __brcmf_cfg80211_up(struct brcmf_cfg80211_priv *cfg_priv);
253 static s32 __brcmf_cfg80211_down(struct brcmf_cfg80211_priv *cfg_priv);
254 static s32 brcmf_dongle_probecap(struct brcmf_cfg80211_priv *cfg_priv);
255 static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf);
256
257 /*
258 ** dongle configuration utilities
259 */
260 static s32 brcmf_dongle_eventmsg(struct net_device *ndev);
261 static s32 brcmf_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
262 s32 scan_unassoc_time, s32 scan_passive_time);
263 static s32 brcmf_config_dongle(struct brcmf_cfg80211_priv *cfg_priv,
264 bool need_lock);
265 static s32 brcmf_dongle_roam(struct net_device *ndev, u32 roamvar,
266 u32 bcn_timeout);
267
268 /*
269 ** iscan handler
270 */
271 static void brcmf_iscan_timer(unsigned long data);
272 static void brcmf_term_iscan(struct brcmf_cfg80211_priv *cfg_priv);
273 static s32 brcmf_init_iscan(struct brcmf_cfg80211_priv *cfg_priv);
274 static s32 brcmf_iscan_thread(void *data);
275 static s32 brcmf_dev_iovar_setbuf(struct net_device *dev, s8 *iovar,
276 void *param, s32 paramlen, void *bufptr,
277 s32 buflen);
278 static s32 brcmf_dev_iovar_getbuf(struct net_device *dev, s8 *iovar,
279 void *param, s32 paramlen, void *bufptr,
280 s32 buflen);
281 static s32 brcmf_run_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan,
282 struct brcmf_ssid *ssid, u16 action);
283 static s32 brcmf_do_iscan(struct brcmf_cfg80211_priv *cfg_priv);
284 static s32 brcmf_wakeup_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan);
285 static s32 brcmf_invoke_iscan(struct brcmf_cfg80211_priv *cfg_priv);
286 static s32 brcmf_get_iscan_results(struct brcmf_cfg80211_iscan_ctrl *iscan,
287 u32 *status,
288 struct brcmf_scan_results **bss_list);
289 static void brcmf_notify_iscan_complete(struct brcmf_cfg80211_iscan_ctrl *iscan,
290 bool aborted);
291 static void brcmf_init_iscan_eloop(struct brcmf_cfg80211_iscan_eloop *el);
292 static s32 brcmf_iscan_done(struct brcmf_cfg80211_priv *cfg_priv);
293 static s32 brcmf_iscan_pending(struct brcmf_cfg80211_priv *cfg_priv);
294 static s32 brcmf_iscan_inprogress(struct brcmf_cfg80211_priv *cfg_priv);
295 static s32 brcmf_iscan_aborted(struct brcmf_cfg80211_priv *cfg_priv);
296
297 /*
298 * update pmklist to dongle
299 */
300 static __used s32 brcmf_update_pmklist(struct net_device *dev,
301 struct brcmf_cfg80211_pmk_list *pmk_list,
302 s32 err);
303
304 static void brcmf_set_mpc(struct net_device *ndev, int mpc);
305
306 /*
307 * debufs support
308 */
309 static int
310 brcmf_debugfs_add_netdev_params(struct brcmf_cfg80211_priv *cfg_priv);
311 static void brcmf_debugfs_remove_netdev(struct brcmf_cfg80211_priv *cfg_priv);
312
313 #define WL_PRIV_GET() \
314 ({ \
315 struct brcmf_cfg80211_iface *ci = brcmf_get_drvdata(cfg80211_dev); \
316 if (unlikely(!ci)) { \
317 WL_ERR("wl_cfg80211_dev is unavailable\n"); \
318 BUG(); \
319 } \
320 ci->cfg_priv; \
321 })
322
323 #define CHECK_SYS_UP() \
324 do { \
325 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy); \
326 if (unlikely(!test_bit(WL_STATUS_READY, &cfg_priv->status))) { \
327 WL_INFO("device is not ready : status (%d)\n", \
328 (int)cfg_priv->status); \
329 return -EIO; \
330 } \
331 } while (0)
332
333 #define CHAN2G(_channel, _freq, _flags) { \
334 .band = IEEE80211_BAND_2GHZ, \
335 .center_freq = (_freq), \
336 .hw_value = (_channel), \
337 .flags = (_flags), \
338 .max_antenna_gain = 0, \
339 .max_power = 30, \
340 }
341
342 #define CHAN5G(_channel, _flags) { \
343 .band = IEEE80211_BAND_5GHZ, \
344 .center_freq = 5000 + (5 * (_channel)), \
345 .hw_value = (_channel), \
346 .flags = (_flags), \
347 .max_antenna_gain = 0, \
348 .max_power = 30, \
349 }
350
351 #define RATE_TO_BASE100KBPS(rate) (((rate) * 10) / 2)
352 #define RATETAB_ENT(_rateid, _flags) \
353 { \
354 .bitrate = RATE_TO_BASE100KBPS(_rateid), \
355 .hw_value = (_rateid), \
356 .flags = (_flags), \
357 }
358
359 static struct ieee80211_rate __wl_rates[] = {
360 RATETAB_ENT(BRCM_RATE_1M, 0),
361 RATETAB_ENT(BRCM_RATE_2M, IEEE80211_RATE_SHORT_PREAMBLE),
362 RATETAB_ENT(BRCM_RATE_5M5, IEEE80211_RATE_SHORT_PREAMBLE),
363 RATETAB_ENT(BRCM_RATE_11M, IEEE80211_RATE_SHORT_PREAMBLE),
364 RATETAB_ENT(BRCM_RATE_6M, 0),
365 RATETAB_ENT(BRCM_RATE_9M, 0),
366 RATETAB_ENT(BRCM_RATE_12M, 0),
367 RATETAB_ENT(BRCM_RATE_18M, 0),
368 RATETAB_ENT(BRCM_RATE_24M, 0),
369 RATETAB_ENT(BRCM_RATE_36M, 0),
370 RATETAB_ENT(BRCM_RATE_48M, 0),
371 RATETAB_ENT(BRCM_RATE_54M, 0),
372 };
373
374 #define wl_a_rates (__wl_rates + 4)
375 #define wl_a_rates_size 8
376 #define wl_g_rates (__wl_rates + 0)
377 #define wl_g_rates_size 12
378
379 static struct ieee80211_channel __wl_2ghz_channels[] = {
380 CHAN2G(1, 2412, 0),
381 CHAN2G(2, 2417, 0),
382 CHAN2G(3, 2422, 0),
383 CHAN2G(4, 2427, 0),
384 CHAN2G(5, 2432, 0),
385 CHAN2G(6, 2437, 0),
386 CHAN2G(7, 2442, 0),
387 CHAN2G(8, 2447, 0),
388 CHAN2G(9, 2452, 0),
389 CHAN2G(10, 2457, 0),
390 CHAN2G(11, 2462, 0),
391 CHAN2G(12, 2467, 0),
392 CHAN2G(13, 2472, 0),
393 CHAN2G(14, 2484, 0),
394 };
395
396 static struct ieee80211_channel __wl_5ghz_a_channels[] = {
397 CHAN5G(34, 0), CHAN5G(36, 0),
398 CHAN5G(38, 0), CHAN5G(40, 0),
399 CHAN5G(42, 0), CHAN5G(44, 0),
400 CHAN5G(46, 0), CHAN5G(48, 0),
401 CHAN5G(52, 0), CHAN5G(56, 0),
402 CHAN5G(60, 0), CHAN5G(64, 0),
403 CHAN5G(100, 0), CHAN5G(104, 0),
404 CHAN5G(108, 0), CHAN5G(112, 0),
405 CHAN5G(116, 0), CHAN5G(120, 0),
406 CHAN5G(124, 0), CHAN5G(128, 0),
407 CHAN5G(132, 0), CHAN5G(136, 0),
408 CHAN5G(140, 0), CHAN5G(149, 0),
409 CHAN5G(153, 0), CHAN5G(157, 0),
410 CHAN5G(161, 0), CHAN5G(165, 0),
411 CHAN5G(184, 0), CHAN5G(188, 0),
412 CHAN5G(192, 0), CHAN5G(196, 0),
413 CHAN5G(200, 0), CHAN5G(204, 0),
414 CHAN5G(208, 0), CHAN5G(212, 0),
415 CHAN5G(216, 0),
416 };
417
418 static struct ieee80211_channel __wl_5ghz_n_channels[] = {
419 CHAN5G(32, 0), CHAN5G(34, 0),
420 CHAN5G(36, 0), CHAN5G(38, 0),
421 CHAN5G(40, 0), CHAN5G(42, 0),
422 CHAN5G(44, 0), CHAN5G(46, 0),
423 CHAN5G(48, 0), CHAN5G(50, 0),
424 CHAN5G(52, 0), CHAN5G(54, 0),
425 CHAN5G(56, 0), CHAN5G(58, 0),
426 CHAN5G(60, 0), CHAN5G(62, 0),
427 CHAN5G(64, 0), CHAN5G(66, 0),
428 CHAN5G(68, 0), CHAN5G(70, 0),
429 CHAN5G(72, 0), CHAN5G(74, 0),
430 CHAN5G(76, 0), CHAN5G(78, 0),
431 CHAN5G(80, 0), CHAN5G(82, 0),
432 CHAN5G(84, 0), CHAN5G(86, 0),
433 CHAN5G(88, 0), CHAN5G(90, 0),
434 CHAN5G(92, 0), CHAN5G(94, 0),
435 CHAN5G(96, 0), CHAN5G(98, 0),
436 CHAN5G(100, 0), CHAN5G(102, 0),
437 CHAN5G(104, 0), CHAN5G(106, 0),
438 CHAN5G(108, 0), CHAN5G(110, 0),
439 CHAN5G(112, 0), CHAN5G(114, 0),
440 CHAN5G(116, 0), CHAN5G(118, 0),
441 CHAN5G(120, 0), CHAN5G(122, 0),
442 CHAN5G(124, 0), CHAN5G(126, 0),
443 CHAN5G(128, 0), CHAN5G(130, 0),
444 CHAN5G(132, 0), CHAN5G(134, 0),
445 CHAN5G(136, 0), CHAN5G(138, 0),
446 CHAN5G(140, 0), CHAN5G(142, 0),
447 CHAN5G(144, 0), CHAN5G(145, 0),
448 CHAN5G(146, 0), CHAN5G(147, 0),
449 CHAN5G(148, 0), CHAN5G(149, 0),
450 CHAN5G(150, 0), CHAN5G(151, 0),
451 CHAN5G(152, 0), CHAN5G(153, 0),
452 CHAN5G(154, 0), CHAN5G(155, 0),
453 CHAN5G(156, 0), CHAN5G(157, 0),
454 CHAN5G(158, 0), CHAN5G(159, 0),
455 CHAN5G(160, 0), CHAN5G(161, 0),
456 CHAN5G(162, 0), CHAN5G(163, 0),
457 CHAN5G(164, 0), CHAN5G(165, 0),
458 CHAN5G(166, 0), CHAN5G(168, 0),
459 CHAN5G(170, 0), CHAN5G(172, 0),
460 CHAN5G(174, 0), CHAN5G(176, 0),
461 CHAN5G(178, 0), CHAN5G(180, 0),
462 CHAN5G(182, 0), CHAN5G(184, 0),
463 CHAN5G(186, 0), CHAN5G(188, 0),
464 CHAN5G(190, 0), CHAN5G(192, 0),
465 CHAN5G(194, 0), CHAN5G(196, 0),
466 CHAN5G(198, 0), CHAN5G(200, 0),
467 CHAN5G(202, 0), CHAN5G(204, 0),
468 CHAN5G(206, 0), CHAN5G(208, 0),
469 CHAN5G(210, 0), CHAN5G(212, 0),
470 CHAN5G(214, 0), CHAN5G(216, 0),
471 CHAN5G(218, 0), CHAN5G(220, 0),
472 CHAN5G(222, 0), CHAN5G(224, 0),
473 CHAN5G(226, 0), CHAN5G(228, 0),
474 };
475
476 static struct ieee80211_supported_band __wl_band_2ghz = {
477 .band = IEEE80211_BAND_2GHZ,
478 .channels = __wl_2ghz_channels,
479 .n_channels = ARRAY_SIZE(__wl_2ghz_channels),
480 .bitrates = wl_g_rates,
481 .n_bitrates = wl_g_rates_size,
482 };
483
484 static struct ieee80211_supported_band __wl_band_5ghz_a = {
485 .band = IEEE80211_BAND_5GHZ,
486 .channels = __wl_5ghz_a_channels,
487 .n_channels = ARRAY_SIZE(__wl_5ghz_a_channels),
488 .bitrates = wl_a_rates,
489 .n_bitrates = wl_a_rates_size,
490 };
491
492 static struct ieee80211_supported_band __wl_band_5ghz_n = {
493 .band = IEEE80211_BAND_5GHZ,
494 .channels = __wl_5ghz_n_channels,
495 .n_channels = ARRAY_SIZE(__wl_5ghz_n_channels),
496 .bitrates = wl_a_rates,
497 .n_bitrates = wl_a_rates_size,
498 };
499
500 static const u32 __wl_cipher_suites[] = {
501 WLAN_CIPHER_SUITE_WEP40,
502 WLAN_CIPHER_SUITE_WEP104,
503 WLAN_CIPHER_SUITE_TKIP,
504 WLAN_CIPHER_SUITE_CCMP,
505 WLAN_CIPHER_SUITE_AES_CMAC,
506 };
507
508 static void convert_key_from_CPU(struct brcmf_wsec_key *key)
509 {
510 key->index = cpu_to_le32(key->index);
511 key->len = cpu_to_le32(key->len);
512 key->algo = cpu_to_le32(key->algo);
513 key->flags = cpu_to_le32(key->flags);
514 key->rxiv.hi = cpu_to_le32(key->rxiv.hi);
515 key->rxiv.lo = cpu_to_le16(key->rxiv.lo);
516 key->iv_initialized = cpu_to_le32(key->iv_initialized);
517 }
518
519 static void convert_key_to_CPU(struct brcmf_wsec_key *key)
520 {
521 key->index = le32_to_cpu(key->index);
522 key->len = le32_to_cpu(key->len);
523 key->algo = le32_to_cpu(key->algo);
524 key->flags = le32_to_cpu(key->flags);
525 key->rxiv.hi = le32_to_cpu(key->rxiv.hi);
526 key->rxiv.lo = le16_to_cpu(key->rxiv.lo);
527 key->iv_initialized = le32_to_cpu(key->iv_initialized);
528 }
529
530 static s32
531 brcmf_dev_ioctl(struct net_device *dev, u32 cmd, void *arg, u32 len)
532 {
533 struct ifreq ifr;
534 struct brcmf_ioctl ioc;
535 mm_segment_t fs;
536 s32 err = 0;
537
538 memset(&ioc, 0, sizeof(ioc));
539 ioc.cmd = cmd;
540 ioc.buf = arg;
541 ioc.len = len;
542 strcpy(ifr.ifr_name, dev->name);
543 ifr.ifr_data = (caddr_t)&ioc;
544
545 fs = get_fs();
546 set_fs(get_ds());
547 err = dev->netdev_ops->ndo_do_ioctl(dev, &ifr, SIOCDEVPRIVATE);
548 set_fs(fs);
549
550 return err;
551 }
552
553 static s32
554 brcmf_cfg80211_change_iface(struct wiphy *wiphy, struct net_device *ndev,
555 enum nl80211_iftype type, u32 *flags,
556 struct vif_params *params)
557 {
558 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
559 struct wireless_dev *wdev;
560 s32 infra = 0;
561 s32 err = 0;
562
563 WL_TRACE("Enter\n");
564 CHECK_SYS_UP();
565
566 switch (type) {
567 case NL80211_IFTYPE_MONITOR:
568 case NL80211_IFTYPE_WDS:
569 WL_ERR("type (%d) : currently we do not support this type\n",
570 type);
571 return -EOPNOTSUPP;
572 case NL80211_IFTYPE_ADHOC:
573 cfg_priv->conf->mode = WL_MODE_IBSS;
574 infra = 0;
575 break;
576 case NL80211_IFTYPE_STATION:
577 cfg_priv->conf->mode = WL_MODE_BSS;
578 infra = 1;
579 break;
580 default:
581 err = -EINVAL;
582 goto done;
583 }
584
585 infra = cpu_to_le32(infra);
586 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_INFRA, &infra, sizeof(infra));
587 if (unlikely(err)) {
588 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
589 err = -EAGAIN;
590 } else {
591 wdev = ndev->ieee80211_ptr;
592 wdev->iftype = type;
593 }
594
595 WL_INFO("IF Type = %s\n",
596 (cfg_priv->conf->mode == WL_MODE_IBSS) ? "Adhoc" : "Infra");
597
598 done:
599 WL_TRACE("Exit\n");
600
601 return err;
602 }
603
604 static void wl_iscan_prep(struct brcmf_scan_params *params,
605 struct brcmf_ssid *ssid)
606 {
607 memcpy(params->bssid, ether_bcast, ETH_ALEN);
608 params->bss_type = DOT11_BSSTYPE_ANY;
609 params->scan_type = 0;
610 params->nprobes = -1;
611 params->active_time = -1;
612 params->passive_time = -1;
613 params->home_time = -1;
614 params->channel_num = 0;
615
616 params->nprobes = cpu_to_le32(params->nprobes);
617 params->active_time = cpu_to_le32(params->active_time);
618 params->passive_time = cpu_to_le32(params->passive_time);
619 params->home_time = cpu_to_le32(params->home_time);
620 if (ssid && ssid->SSID_len)
621 memcpy(&params->ssid, ssid, sizeof(struct brcmf_ssid));
622
623 }
624
625 static s32
626 brcmf_dev_iovar_setbuf(struct net_device *dev, s8 * iovar, void *param,
627 s32 paramlen, void *bufptr, s32 buflen)
628 {
629 s32 iolen;
630
631 iolen = brcmu_mkiovar(iovar, param, paramlen, bufptr, buflen);
632 BUG_ON(!iolen);
633
634 return brcmf_dev_ioctl(dev, BRCMF_C_SET_VAR, bufptr, iolen);
635 }
636
637 static s32
638 brcmf_dev_iovar_getbuf(struct net_device *dev, s8 * iovar, void *param,
639 s32 paramlen, void *bufptr, s32 buflen)
640 {
641 s32 iolen;
642
643 iolen = brcmu_mkiovar(iovar, param, paramlen, bufptr, buflen);
644 BUG_ON(!iolen);
645
646 return brcmf_dev_ioctl(dev, BRCMF_C_GET_VAR, bufptr, buflen);
647 }
648
649 static s32
650 brcmf_run_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan,
651 struct brcmf_ssid *ssid, u16 action)
652 {
653 s32 params_size = (BRCMF_SCAN_PARAMS_FIXED_SIZE +
654 offsetof(struct brcmf_iscan_params, params));
655 struct brcmf_iscan_params *params;
656 s32 err = 0;
657
658 if (ssid && ssid->SSID_len)
659 params_size += sizeof(struct brcmf_ssid);
660 params = kzalloc(params_size, GFP_KERNEL);
661 if (unlikely(!params))
662 return -ENOMEM;
663 BUG_ON(params_size >= BRCMF_C_IOCTL_SMLEN);
664
665 wl_iscan_prep(&params->params, ssid);
666
667 params->version = cpu_to_le32(BRCMF_ISCAN_REQ_VERSION);
668 params->action = cpu_to_le16(action);
669 params->scan_duration = cpu_to_le16(0);
670
671 /* params_size += offsetof(struct brcmf_iscan_params, params); */
672 err = brcmf_dev_iovar_setbuf(iscan->dev, "iscan", params, params_size,
673 iscan->ioctl_buf, BRCMF_C_IOCTL_SMLEN);
674 if (unlikely(err)) {
675 if (err == -EBUSY)
676 WL_INFO("system busy : iscan canceled\n");
677 else
678 WL_ERR("error (%d)\n", err);
679 }
680
681 kfree(params);
682 return err;
683 }
684
685 static s32 brcmf_do_iscan(struct brcmf_cfg80211_priv *cfg_priv)
686 {
687 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
688 struct net_device *ndev = cfg_to_ndev(cfg_priv);
689 struct brcmf_ssid ssid;
690 s32 passive_scan;
691 s32 err = 0;
692
693 /* Broadcast scan by default */
694 memset(&ssid, 0, sizeof(ssid));
695
696 iscan->state = WL_ISCAN_STATE_SCANING;
697
698 passive_scan = cfg_priv->active_scan ? 0 : 1;
699 err = brcmf_dev_ioctl(cfg_to_ndev(cfg_priv), BRCMF_C_SET_PASSIVE_SCAN,
700 &passive_scan, sizeof(passive_scan));
701 if (unlikely(err)) {
702 WL_ERR("error (%d)\n", err);
703 return err;
704 }
705 brcmf_set_mpc(ndev, 0);
706 cfg_priv->iscan_kickstart = true;
707 err = brcmf_run_iscan(iscan, &ssid, BRCMF_SCAN_ACTION_START);
708 if (err) {
709 brcmf_set_mpc(ndev, 1);
710 cfg_priv->iscan_kickstart = false;
711 return err;
712 }
713 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
714 iscan->timer_on = 1;
715 return err;
716 }
717
718 static s32
719 __brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
720 struct cfg80211_scan_request *request,
721 struct cfg80211_ssid *this_ssid)
722 {
723 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
724 struct cfg80211_ssid *ssids;
725 struct brcmf_cfg80211_scan_req *sr = cfg_priv->scan_req_int;
726 s32 passive_scan;
727 bool iscan_req;
728 bool spec_scan;
729 s32 err = 0;
730
731 if (unlikely(test_bit(WL_STATUS_SCANNING, &cfg_priv->status))) {
732 WL_ERR("Scanning already : status (%lu)\n", cfg_priv->status);
733 return -EAGAIN;
734 }
735 if (unlikely(test_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status))) {
736 WL_ERR("Scanning being aborted : status (%lu)\n",
737 cfg_priv->status);
738 return -EAGAIN;
739 }
740 if (test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) {
741 WL_ERR("Connecting : status (%lu)\n",
742 cfg_priv->status);
743 return -EAGAIN;
744 }
745
746 iscan_req = false;
747 spec_scan = false;
748 if (request) {
749 /* scan bss */
750 ssids = request->ssids;
751 if (cfg_priv->iscan_on && (!ssids || !ssids->ssid_len))
752 iscan_req = true;
753 } else {
754 /* scan in ibss */
755 /* we don't do iscan in ibss */
756 ssids = this_ssid;
757 }
758
759 cfg_priv->scan_request = request;
760 set_bit(WL_STATUS_SCANNING, &cfg_priv->status);
761 if (iscan_req) {
762 err = brcmf_do_iscan(cfg_priv);
763 if (likely(!err))
764 return err;
765 else
766 goto scan_out;
767 } else {
768 WL_SCAN("ssid \"%s\", ssid_len (%d)\n",
769 ssids->ssid, ssids->ssid_len);
770 memset(&sr->ssid, 0, sizeof(sr->ssid));
771 sr->ssid.SSID_len =
772 min_t(u8, sizeof(sr->ssid.SSID), ssids->ssid_len);
773 if (sr->ssid.SSID_len) {
774 memcpy(sr->ssid.SSID, ssids->ssid, sr->ssid.SSID_len);
775 sr->ssid.SSID_len = cpu_to_le32(sr->ssid.SSID_len);
776 spec_scan = true;
777 } else {
778 WL_SCAN("Broadcast scan\n");
779 }
780
781 passive_scan = cfg_priv->active_scan ? 0 : 1;
782 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_PASSIVE_SCAN,
783 &passive_scan, sizeof(passive_scan));
784 if (unlikely(err)) {
785 WL_ERR("WLC_SET_PASSIVE_SCAN error (%d)\n", err);
786 goto scan_out;
787 }
788 brcmf_set_mpc(ndev, 0);
789 err = brcmf_dev_ioctl(ndev, BRCMF_C_SCAN, &sr->ssid,
790 sizeof(sr->ssid));
791 if (err) {
792 if (err == -EBUSY)
793 WL_INFO("system busy : scan for \"%s\" "
794 "canceled\n", sr->ssid.SSID);
795 else
796 WL_ERR("WLC_SCAN error (%d)\n", err);
797
798 brcmf_set_mpc(ndev, 1);
799 goto scan_out;
800 }
801 }
802
803 return 0;
804
805 scan_out:
806 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
807 cfg_priv->scan_request = NULL;
808 return err;
809 }
810
811 static s32
812 brcmf_cfg80211_scan(struct wiphy *wiphy, struct net_device *ndev,
813 struct cfg80211_scan_request *request)
814 {
815 s32 err = 0;
816
817 WL_TRACE("Enter\n");
818
819 CHECK_SYS_UP();
820
821 err = __brcmf_cfg80211_scan(wiphy, ndev, request, NULL);
822 if (unlikely(err))
823 WL_ERR("scan error (%d)\n", err);
824
825 WL_TRACE("Exit\n");
826 return err;
827 }
828
829 static s32 brcmf_dev_intvar_set(struct net_device *dev, s8 *name, s32 val)
830 {
831 s8 buf[BRCMF_C_IOCTL_SMLEN];
832 u32 len;
833 s32 err = 0;
834
835 val = cpu_to_le32(val);
836 len = brcmu_mkiovar(name, (char *)(&val), sizeof(val), buf,
837 sizeof(buf));
838 BUG_ON(!len);
839
840 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_VAR, buf, len);
841 if (unlikely(err))
842 WL_ERR("error (%d)\n", err);
843
844 return err;
845 }
846
847 static s32
848 brcmf_dev_intvar_get(struct net_device *dev, s8 *name, s32 *retval)
849 {
850 union {
851 s8 buf[BRCMF_C_IOCTL_SMLEN];
852 s32 val;
853 } var;
854 u32 len;
855 u32 data_null;
856 s32 err = 0;
857
858 len =
859 brcmu_mkiovar(name, (char *)(&data_null), 0, (char *)(&var),
860 sizeof(var.buf));
861 BUG_ON(!len);
862 err = brcmf_dev_ioctl(dev, BRCMF_C_GET_VAR, &var, len);
863 if (unlikely(err))
864 WL_ERR("error (%d)\n", err);
865
866 *retval = le32_to_cpu(var.val);
867
868 return err;
869 }
870
871 static s32 brcmf_set_rts(struct net_device *dev, u32 rts_threshold)
872 {
873 s32 err = 0;
874
875 err = brcmf_dev_intvar_set(dev, "rtsthresh", rts_threshold);
876 if (unlikely(err))
877 WL_ERR("Error (%d)\n", err);
878
879 return err;
880 }
881
882 static s32 brcmf_set_frag(struct net_device *dev, u32 frag_threshold)
883 {
884 s32 err = 0;
885
886 err = brcmf_dev_intvar_set(dev, "fragthresh", frag_threshold);
887 if (unlikely(err))
888 WL_ERR("Error (%d)\n", err);
889
890 return err;
891 }
892
893 static s32 brcmf_set_retry(struct net_device *dev, u32 retry, bool l)
894 {
895 s32 err = 0;
896 u32 cmd = (l ? BRCM_SET_LRL : BRCM_SET_SRL);
897
898 retry = cpu_to_le32(retry);
899 err = brcmf_dev_ioctl(dev, cmd, &retry, sizeof(retry));
900 if (unlikely(err)) {
901 WL_ERR("cmd (%d) , error (%d)\n", cmd, err);
902 return err;
903 }
904 return err;
905 }
906
907 static s32 brcmf_cfg80211_set_wiphy_params(struct wiphy *wiphy, u32 changed)
908 {
909 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
910 struct net_device *ndev = cfg_to_ndev(cfg_priv);
911 s32 err = 0;
912
913 WL_TRACE("Enter\n");
914 CHECK_SYS_UP();
915
916 if (changed & WIPHY_PARAM_RTS_THRESHOLD &&
917 (cfg_priv->conf->rts_threshold != wiphy->rts_threshold)) {
918 cfg_priv->conf->rts_threshold = wiphy->rts_threshold;
919 err = brcmf_set_rts(ndev, cfg_priv->conf->rts_threshold);
920 if (!err)
921 goto done;
922 }
923 if (changed & WIPHY_PARAM_FRAG_THRESHOLD &&
924 (cfg_priv->conf->frag_threshold != wiphy->frag_threshold)) {
925 cfg_priv->conf->frag_threshold = wiphy->frag_threshold;
926 err = brcmf_set_frag(ndev, cfg_priv->conf->frag_threshold);
927 if (!err)
928 goto done;
929 }
930 if (changed & WIPHY_PARAM_RETRY_LONG
931 && (cfg_priv->conf->retry_long != wiphy->retry_long)) {
932 cfg_priv->conf->retry_long = wiphy->retry_long;
933 err = brcmf_set_retry(ndev, cfg_priv->conf->retry_long, true);
934 if (!err)
935 goto done;
936 }
937 if (changed & WIPHY_PARAM_RETRY_SHORT
938 && (cfg_priv->conf->retry_short != wiphy->retry_short)) {
939 cfg_priv->conf->retry_short = wiphy->retry_short;
940 err = brcmf_set_retry(ndev, cfg_priv->conf->retry_short, false);
941 if (!err)
942 goto done;
943 }
944
945 done:
946 WL_TRACE("Exit\n");
947 return err;
948 }
949
950 static s32
951 brcmf_cfg80211_join_ibss(struct wiphy *wiphy, struct net_device *dev,
952 struct cfg80211_ibss_params *params)
953 {
954 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
955 struct brcmf_join_params join_params;
956 size_t join_params_size = 0;
957 s32 err = 0;
958 s32 wsec = 0;
959 s32 bcnprd;
960
961 WL_TRACE("Enter\n");
962 CHECK_SYS_UP();
963
964 if (params->ssid)
965 WL_CONN("SSID: %s\n", params->ssid);
966 else {
967 WL_CONN("SSID: NULL, Not supported\n");
968 return -EOPNOTSUPP;
969 }
970
971 set_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
972
973 if (params->bssid)
974 WL_CONN("BSSID: %02X %02X %02X %02X %02X %02X\n",
975 params->bssid[0], params->bssid[1], params->bssid[2],
976 params->bssid[3], params->bssid[4], params->bssid[5]);
977 else
978 WL_CONN("No BSSID specified\n");
979
980 if (params->channel)
981 WL_CONN("channel: %d\n", params->channel->center_freq);
982 else
983 WL_CONN("no channel specified\n");
984
985 if (params->channel_fixed)
986 WL_CONN("fixed channel required\n");
987 else
988 WL_CONN("no fixed channel required\n");
989
990 if (params->ie && params->ie_len)
991 WL_CONN("ie len: %d\n", params->ie_len);
992 else
993 WL_CONN("no ie specified\n");
994
995 if (params->beacon_interval)
996 WL_CONN("beacon interval: %d\n", params->beacon_interval);
997 else
998 WL_CONN("no beacon interval specified\n");
999
1000 if (params->basic_rates)
1001 WL_CONN("basic rates: %08X\n", params->basic_rates);
1002 else
1003 WL_CONN("no basic rates specified\n");
1004
1005 if (params->privacy)
1006 WL_CONN("privacy required\n");
1007 else
1008 WL_CONN("no privacy required\n");
1009
1010 /* Configure Privacy for starter */
1011 if (params->privacy)
1012 wsec |= WEP_ENABLED;
1013
1014 err = brcmf_dev_intvar_set(dev, "wsec", wsec);
1015 if (unlikely(err)) {
1016 WL_ERR("wsec failed (%d)\n", err);
1017 goto done;
1018 }
1019
1020 /* Configure Beacon Interval for starter */
1021 if (params->beacon_interval)
1022 bcnprd = cpu_to_le32(params->beacon_interval);
1023 else
1024 bcnprd = cpu_to_le32(100);
1025
1026 err = brcmf_dev_ioctl(dev, BRCM_SET_BCNPRD, &bcnprd, sizeof(bcnprd));
1027 if (unlikely(err)) {
1028 WL_ERR("WLC_SET_BCNPRD failed (%d)\n", err);
1029 goto done;
1030 }
1031
1032 /* Configure required join parameter */
1033 memset(&join_params, 0, sizeof(struct brcmf_join_params));
1034
1035 /* SSID */
1036 join_params.ssid.SSID_len =
1037 (params->ssid_len > 32) ? 32 : params->ssid_len;
1038 memcpy(join_params.ssid.SSID, params->ssid, join_params.ssid.SSID_len);
1039 join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1040 join_params_size = sizeof(join_params.ssid);
1041 brcmf_update_prof(cfg_priv, NULL, &join_params.ssid, WL_PROF_SSID);
1042
1043 /* BSSID */
1044 if (params->bssid) {
1045 memcpy(join_params.params.bssid, params->bssid, ETH_ALEN);
1046 join_params_size = sizeof(join_params.ssid) +
1047 BRCMF_ASSOC_PARAMS_FIXED_SIZE;
1048 } else {
1049 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1050 }
1051
1052 brcmf_update_prof(cfg_priv, NULL,
1053 &join_params.params.bssid, WL_PROF_BSSID);
1054
1055 /* Channel */
1056 if (params->channel) {
1057 u32 target_channel;
1058
1059 cfg_priv->channel =
1060 ieee80211_frequency_to_channel(
1061 params->channel->center_freq);
1062 if (params->channel_fixed) {
1063 /* adding chanspec */
1064 brcmf_ch_to_chanspec(cfg_priv->channel,
1065 &join_params, &join_params_size);
1066 }
1067
1068 /* set channel for starter */
1069 target_channel = cpu_to_le32(cfg_priv->channel);
1070 err = brcmf_dev_ioctl(dev, BRCM_SET_CHANNEL,
1071 &target_channel, sizeof(target_channel));
1072 if (unlikely(err)) {
1073 WL_ERR("WLC_SET_CHANNEL failed (%d)\n", err);
1074 goto done;
1075 }
1076 } else
1077 cfg_priv->channel = 0;
1078
1079 cfg_priv->ibss_starter = false;
1080
1081
1082 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_SSID,
1083 &join_params, join_params_size);
1084 if (unlikely(err)) {
1085 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1086 goto done;
1087 }
1088
1089 done:
1090 if (err)
1091 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1092 WL_TRACE("Exit\n");
1093 return err;
1094 }
1095
1096 static s32
1097 brcmf_cfg80211_leave_ibss(struct wiphy *wiphy, struct net_device *dev)
1098 {
1099 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1100 s32 err = 0;
1101
1102 WL_TRACE("Enter\n");
1103 CHECK_SYS_UP();
1104
1105 brcmf_link_down(cfg_priv);
1106
1107 WL_TRACE("Exit\n");
1108
1109 return err;
1110 }
1111
1112 static s32 brcmf_set_wpa_version(struct net_device *dev,
1113 struct cfg80211_connect_params *sme)
1114 {
1115 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
1116 struct brcmf_cfg80211_security *sec;
1117 s32 val = 0;
1118 s32 err = 0;
1119
1120 if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_1)
1121 val = WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED;
1122 else if (sme->crypto.wpa_versions & NL80211_WPA_VERSION_2)
1123 val = WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED;
1124 else
1125 val = WPA_AUTH_DISABLED;
1126 WL_CONN("setting wpa_auth to 0x%0x\n", val);
1127 err = brcmf_dev_intvar_set(dev, "wpa_auth", val);
1128 if (unlikely(err)) {
1129 WL_ERR("set wpa_auth failed (%d)\n", err);
1130 return err;
1131 }
1132 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1133 sec->wpa_versions = sme->crypto.wpa_versions;
1134 return err;
1135 }
1136
1137 static s32
1138 brcmf_set_auth_type(struct net_device *dev, struct cfg80211_connect_params *sme)
1139 {
1140 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
1141 struct brcmf_cfg80211_security *sec;
1142 s32 val = 0;
1143 s32 err = 0;
1144
1145 switch (sme->auth_type) {
1146 case NL80211_AUTHTYPE_OPEN_SYSTEM:
1147 val = 0;
1148 WL_CONN("open system\n");
1149 break;
1150 case NL80211_AUTHTYPE_SHARED_KEY:
1151 val = 1;
1152 WL_CONN("shared key\n");
1153 break;
1154 case NL80211_AUTHTYPE_AUTOMATIC:
1155 val = 2;
1156 WL_CONN("automatic\n");
1157 break;
1158 case NL80211_AUTHTYPE_NETWORK_EAP:
1159 WL_CONN("network eap\n");
1160 default:
1161 val = 2;
1162 WL_ERR("invalid auth type (%d)\n", sme->auth_type);
1163 break;
1164 }
1165
1166 err = brcmf_dev_intvar_set(dev, "auth", val);
1167 if (unlikely(err)) {
1168 WL_ERR("set auth failed (%d)\n", err);
1169 return err;
1170 }
1171 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1172 sec->auth_type = sme->auth_type;
1173 return err;
1174 }
1175
1176 static s32
1177 brcmf_set_set_cipher(struct net_device *dev,
1178 struct cfg80211_connect_params *sme)
1179 {
1180 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
1181 struct brcmf_cfg80211_security *sec;
1182 s32 pval = 0;
1183 s32 gval = 0;
1184 s32 err = 0;
1185
1186 if (sme->crypto.n_ciphers_pairwise) {
1187 switch (sme->crypto.ciphers_pairwise[0]) {
1188 case WLAN_CIPHER_SUITE_WEP40:
1189 case WLAN_CIPHER_SUITE_WEP104:
1190 pval = WEP_ENABLED;
1191 break;
1192 case WLAN_CIPHER_SUITE_TKIP:
1193 pval = TKIP_ENABLED;
1194 break;
1195 case WLAN_CIPHER_SUITE_CCMP:
1196 pval = AES_ENABLED;
1197 break;
1198 case WLAN_CIPHER_SUITE_AES_CMAC:
1199 pval = AES_ENABLED;
1200 break;
1201 default:
1202 WL_ERR("invalid cipher pairwise (%d)\n",
1203 sme->crypto.ciphers_pairwise[0]);
1204 return -EINVAL;
1205 }
1206 }
1207 if (sme->crypto.cipher_group) {
1208 switch (sme->crypto.cipher_group) {
1209 case WLAN_CIPHER_SUITE_WEP40:
1210 case WLAN_CIPHER_SUITE_WEP104:
1211 gval = WEP_ENABLED;
1212 break;
1213 case WLAN_CIPHER_SUITE_TKIP:
1214 gval = TKIP_ENABLED;
1215 break;
1216 case WLAN_CIPHER_SUITE_CCMP:
1217 gval = AES_ENABLED;
1218 break;
1219 case WLAN_CIPHER_SUITE_AES_CMAC:
1220 gval = AES_ENABLED;
1221 break;
1222 default:
1223 WL_ERR("invalid cipher group (%d)\n",
1224 sme->crypto.cipher_group);
1225 return -EINVAL;
1226 }
1227 }
1228
1229 WL_CONN("pval (%d) gval (%d)\n", pval, gval);
1230 err = brcmf_dev_intvar_set(dev, "wsec", pval | gval);
1231 if (unlikely(err)) {
1232 WL_ERR("error (%d)\n", err);
1233 return err;
1234 }
1235
1236 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1237 sec->cipher_pairwise = sme->crypto.ciphers_pairwise[0];
1238 sec->cipher_group = sme->crypto.cipher_group;
1239
1240 return err;
1241 }
1242
1243 static s32
1244 brcmf_set_key_mgmt(struct net_device *dev, struct cfg80211_connect_params *sme)
1245 {
1246 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
1247 struct brcmf_cfg80211_security *sec;
1248 s32 val = 0;
1249 s32 err = 0;
1250
1251 if (sme->crypto.n_akm_suites) {
1252 err = brcmf_dev_intvar_get(dev, "wpa_auth", &val);
1253 if (unlikely(err)) {
1254 WL_ERR("could not get wpa_auth (%d)\n", err);
1255 return err;
1256 }
1257 if (val & (WPA_AUTH_PSK | WPA_AUTH_UNSPECIFIED)) {
1258 switch (sme->crypto.akm_suites[0]) {
1259 case WLAN_AKM_SUITE_8021X:
1260 val = WPA_AUTH_UNSPECIFIED;
1261 break;
1262 case WLAN_AKM_SUITE_PSK:
1263 val = WPA_AUTH_PSK;
1264 break;
1265 default:
1266 WL_ERR("invalid cipher group (%d)\n",
1267 sme->crypto.cipher_group);
1268 return -EINVAL;
1269 }
1270 } else if (val & (WPA2_AUTH_PSK | WPA2_AUTH_UNSPECIFIED)) {
1271 switch (sme->crypto.akm_suites[0]) {
1272 case WLAN_AKM_SUITE_8021X:
1273 val = WPA2_AUTH_UNSPECIFIED;
1274 break;
1275 case WLAN_AKM_SUITE_PSK:
1276 val = WPA2_AUTH_PSK;
1277 break;
1278 default:
1279 WL_ERR("invalid cipher group (%d)\n",
1280 sme->crypto.cipher_group);
1281 return -EINVAL;
1282 }
1283 }
1284
1285 WL_CONN("setting wpa_auth to %d\n", val);
1286 err = brcmf_dev_intvar_set(dev, "wpa_auth", val);
1287 if (unlikely(err)) {
1288 WL_ERR("could not set wpa_auth (%d)\n", err);
1289 return err;
1290 }
1291 }
1292 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1293 sec->wpa_auth = sme->crypto.akm_suites[0];
1294
1295 return err;
1296 }
1297
1298 static s32
1299 brcmf_set_set_sharedkey(struct net_device *dev,
1300 struct cfg80211_connect_params *sme)
1301 {
1302 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
1303 struct brcmf_cfg80211_security *sec;
1304 struct brcmf_wsec_key key;
1305 s32 val;
1306 s32 err = 0;
1307
1308 WL_CONN("key len (%d)\n", sme->key_len);
1309 if (sme->key_len) {
1310 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1311 WL_CONN("wpa_versions 0x%x cipher_pairwise 0x%x\n",
1312 sec->wpa_versions, sec->cipher_pairwise);
1313 if (!
1314 (sec->wpa_versions & (NL80211_WPA_VERSION_1 |
1315 NL80211_WPA_VERSION_2))
1316 && (sec->cipher_pairwise & (WLAN_CIPHER_SUITE_WEP40 |
1317 WLAN_CIPHER_SUITE_WEP104))) {
1318 memset(&key, 0, sizeof(key));
1319 key.len = (u32) sme->key_len;
1320 key.index = (u32) sme->key_idx;
1321 if (unlikely(key.len > sizeof(key.data))) {
1322 WL_ERR("Too long key length (%u)\n", key.len);
1323 return -EINVAL;
1324 }
1325 memcpy(key.data, sme->key, key.len);
1326 key.flags = BRCMF_PRIMARY_KEY;
1327 switch (sec->cipher_pairwise) {
1328 case WLAN_CIPHER_SUITE_WEP40:
1329 key.algo = CRYPTO_ALGO_WEP1;
1330 break;
1331 case WLAN_CIPHER_SUITE_WEP104:
1332 key.algo = CRYPTO_ALGO_WEP128;
1333 break;
1334 default:
1335 WL_ERR("Invalid algorithm (%d)\n",
1336 sme->crypto.ciphers_pairwise[0]);
1337 return -EINVAL;
1338 }
1339 /* Set the new key/index */
1340 WL_CONN("key length (%d) key index (%d) algo (%d)\n",
1341 key.len, key.index, key.algo);
1342 WL_CONN("key \"%s\"\n", key.data);
1343 convert_key_from_CPU(&key);
1344 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY, &key,
1345 sizeof(key));
1346 if (unlikely(err)) {
1347 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1348 return err;
1349 }
1350 if (sec->auth_type == NL80211_AUTHTYPE_OPEN_SYSTEM) {
1351 WL_CONN("set auth_type to shared key\n");
1352 val = 1; /* shared key */
1353 err = brcmf_dev_intvar_set(dev, "auth", val);
1354 if (unlikely(err)) {
1355 WL_ERR("set auth failed (%d)\n", err);
1356 return err;
1357 }
1358 }
1359 }
1360 }
1361 return err;
1362 }
1363
1364 static s32
1365 brcmf_cfg80211_connect(struct wiphy *wiphy, struct net_device *dev,
1366 struct cfg80211_connect_params *sme)
1367 {
1368 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1369 struct ieee80211_channel *chan = sme->channel;
1370 struct brcmf_join_params join_params;
1371 size_t join_params_size;
1372
1373 s32 err = 0;
1374
1375 WL_TRACE("Enter\n");
1376 CHECK_SYS_UP();
1377
1378 if (unlikely(!sme->ssid)) {
1379 WL_ERR("Invalid ssid\n");
1380 return -EOPNOTSUPP;
1381 }
1382
1383 set_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1384
1385 if (chan) {
1386 cfg_priv->channel =
1387 ieee80211_frequency_to_channel(chan->center_freq);
1388 WL_CONN("channel (%d), center_req (%d)\n",
1389 cfg_priv->channel, chan->center_freq);
1390 } else
1391 cfg_priv->channel = 0;
1392
1393 WL_INFO("ie (%p), ie_len (%zd)\n", sme->ie, sme->ie_len);
1394
1395 err = brcmf_set_wpa_version(dev, sme);
1396 if (err) {
1397 WL_ERR("wl_set_wpa_version failed (%d)\n", err);
1398 goto done;
1399 }
1400
1401 err = brcmf_set_auth_type(dev, sme);
1402 if (err) {
1403 WL_ERR("wl_set_auth_type failed (%d)\n", err);
1404 goto done;
1405 }
1406
1407 err = brcmf_set_set_cipher(dev, sme);
1408 if (err) {
1409 WL_ERR("wl_set_set_cipher failed (%d)\n", err);
1410 goto done;
1411 }
1412
1413 err = brcmf_set_key_mgmt(dev, sme);
1414 if (err) {
1415 WL_ERR("wl_set_key_mgmt failed (%d)\n", err);
1416 goto done;
1417 }
1418
1419 err = brcmf_set_set_sharedkey(dev, sme);
1420 if (err) {
1421 WL_ERR("wl_set_set_sharedkey failed (%d)\n", err);
1422 goto done;
1423 }
1424
1425 memset(&join_params, 0, sizeof(join_params));
1426 join_params_size = sizeof(join_params.ssid);
1427
1428 join_params.ssid.SSID_len =
1429 min(sizeof(join_params.ssid.SSID), sme->ssid_len);
1430 memcpy(&join_params.ssid.SSID, sme->ssid, join_params.ssid.SSID_len);
1431 join_params.ssid.SSID_len = cpu_to_le32(join_params.ssid.SSID_len);
1432 brcmf_update_prof(cfg_priv, NULL, &join_params.ssid, WL_PROF_SSID);
1433
1434 memcpy(join_params.params.bssid, ether_bcast, ETH_ALEN);
1435
1436 if (join_params.ssid.SSID_len < IEEE80211_MAX_SSID_LEN)
1437 WL_CONN("ssid \"%s\", len (%d)\n",
1438 join_params.ssid.SSID, join_params.ssid.SSID_len);
1439
1440 brcmf_ch_to_chanspec(cfg_priv->channel,
1441 &join_params, &join_params_size);
1442 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_SSID,
1443 &join_params, join_params_size);
1444 if (err)
1445 WL_ERR("WLC_SET_SSID failed (%d)\n", err);
1446
1447 done:
1448 if (err)
1449 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
1450 WL_TRACE("Exit\n");
1451 return err;
1452 }
1453
1454 static s32
1455 brcmf_cfg80211_disconnect(struct wiphy *wiphy, struct net_device *dev,
1456 u16 reason_code)
1457 {
1458 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1459 struct brcmf_scb_val scbval;
1460 s32 err = 0;
1461
1462 WL_TRACE("Enter. Reason code = %d\n", reason_code);
1463 CHECK_SYS_UP();
1464
1465 clear_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
1466
1467 scbval.val = reason_code;
1468 memcpy(&scbval.ea, brcmf_read_prof(cfg_priv, WL_PROF_BSSID), ETH_ALEN);
1469 scbval.val = cpu_to_le32(scbval.val);
1470 err = brcmf_dev_ioctl(dev, BRCMF_C_DISASSOC, &scbval,
1471 sizeof(struct brcmf_scb_val));
1472 if (unlikely(err))
1473 WL_ERR("error (%d)\n", err);
1474
1475 cfg_priv->link_up = false;
1476
1477 WL_TRACE("Exit\n");
1478 return err;
1479 }
1480
1481 static s32
1482 brcmf_cfg80211_set_tx_power(struct wiphy *wiphy,
1483 enum nl80211_tx_power_setting type, s32 dbm)
1484 {
1485
1486 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1487 struct net_device *ndev = cfg_to_ndev(cfg_priv);
1488 u16 txpwrmw;
1489 s32 err = 0;
1490 s32 disable = 0;
1491
1492 WL_TRACE("Enter\n");
1493 CHECK_SYS_UP();
1494
1495 switch (type) {
1496 case NL80211_TX_POWER_AUTOMATIC:
1497 break;
1498 case NL80211_TX_POWER_LIMITED:
1499 if (dbm < 0) {
1500 WL_ERR("TX_POWER_LIMITED - dbm is negative\n");
1501 err = -EINVAL;
1502 goto done;
1503 }
1504 break;
1505 case NL80211_TX_POWER_FIXED:
1506 if (dbm < 0) {
1507 WL_ERR("TX_POWER_FIXED - dbm is negative\n");
1508 err = -EINVAL;
1509 goto done;
1510 }
1511 break;
1512 }
1513 /* Make sure radio is off or on as far as software is concerned */
1514 disable = WL_RADIO_SW_DISABLE << 16;
1515 disable = cpu_to_le32(disable);
1516 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_RADIO, &disable,
1517 sizeof(disable));
1518 if (unlikely(err))
1519 WL_ERR("WLC_SET_RADIO error (%d)\n", err);
1520
1521 if (dbm > 0xffff)
1522 txpwrmw = 0xffff;
1523 else
1524 txpwrmw = (u16) dbm;
1525 err = brcmf_dev_intvar_set(ndev, "qtxpower",
1526 (s32) (brcmu_mw_to_qdbm(txpwrmw)));
1527 if (unlikely(err))
1528 WL_ERR("qtxpower error (%d)\n", err);
1529 cfg_priv->conf->tx_power = dbm;
1530
1531 done:
1532 WL_TRACE("Exit\n");
1533 return err;
1534 }
1535
1536 static s32 brcmf_cfg80211_get_tx_power(struct wiphy *wiphy, s32 *dbm)
1537 {
1538 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1539 struct net_device *ndev = cfg_to_ndev(cfg_priv);
1540 s32 txpwrdbm;
1541 u8 result;
1542 s32 err = 0;
1543
1544 WL_TRACE("Enter\n");
1545 CHECK_SYS_UP();
1546
1547 err = brcmf_dev_intvar_get(ndev, "qtxpower", &txpwrdbm);
1548 if (unlikely(err)) {
1549 WL_ERR("error (%d)\n", err);
1550 goto done;
1551 }
1552
1553 result = (u8) (txpwrdbm & ~WL_TXPWR_OVERRIDE);
1554 *dbm = (s32) brcmu_qdbm_to_mw(result);
1555
1556 done:
1557 WL_TRACE("Exit\n");
1558 return err;
1559 }
1560
1561 static s32
1562 brcmf_cfg80211_config_default_key(struct wiphy *wiphy, struct net_device *dev,
1563 u8 key_idx, bool unicast, bool multicast)
1564 {
1565 u32 index;
1566 s32 wsec;
1567 s32 err = 0;
1568
1569 WL_TRACE("Enter\n");
1570 WL_CONN("key index (%d)\n", key_idx);
1571 CHECK_SYS_UP();
1572
1573 err = brcmf_dev_ioctl(dev, BRCMF_C_GET_WSEC, &wsec, sizeof(wsec));
1574 if (unlikely(err)) {
1575 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1576 goto done;
1577 }
1578
1579 wsec = le32_to_cpu(wsec);
1580 if (wsec & WEP_ENABLED) {
1581 /* Just select a new current key */
1582 index = (u32) key_idx;
1583 index = cpu_to_le32(index);
1584 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY_PRIMARY, &index,
1585 sizeof(index));
1586 if (unlikely(err))
1587 WL_ERR("error (%d)\n", err);
1588 }
1589 done:
1590 WL_TRACE("Exit\n");
1591 return err;
1592 }
1593
1594 static s32
1595 brcmf_add_keyext(struct wiphy *wiphy, struct net_device *dev,
1596 u8 key_idx, const u8 *mac_addr, struct key_params *params)
1597 {
1598 struct brcmf_wsec_key key;
1599 s32 err = 0;
1600
1601 memset(&key, 0, sizeof(key));
1602 key.index = (u32) key_idx;
1603 /* Instead of bcast for ea address for default wep keys,
1604 driver needs it to be Null */
1605 if (!is_multicast_ether_addr(mac_addr))
1606 memcpy((char *)&key.ea, (void *)mac_addr, ETH_ALEN);
1607 key.len = (u32) params->key_len;
1608 /* check for key index change */
1609 if (key.len == 0) {
1610 /* key delete */
1611 convert_key_from_CPU(&key);
1612 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1613 if (unlikely(err)) {
1614 WL_ERR("key delete error (%d)\n", err);
1615 return err;
1616 }
1617 } else {
1618 if (key.len > sizeof(key.data)) {
1619 WL_ERR("Invalid key length (%d)\n", key.len);
1620 return -EINVAL;
1621 }
1622
1623 WL_CONN("Setting the key index %d\n", key.index);
1624 memcpy(key.data, params->key, key.len);
1625
1626 if (params->cipher == WLAN_CIPHER_SUITE_TKIP) {
1627 u8 keybuf[8];
1628 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1629 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1630 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1631 }
1632
1633 /* if IW_ENCODE_EXT_RX_SEQ_VALID set */
1634 if (params->seq && params->seq_len == 6) {
1635 /* rx iv */
1636 u8 *ivptr;
1637 ivptr = (u8 *) params->seq;
1638 key.rxiv.hi = (ivptr[5] << 24) | (ivptr[4] << 16) |
1639 (ivptr[3] << 8) | ivptr[2];
1640 key.rxiv.lo = (ivptr[1] << 8) | ivptr[0];
1641 key.iv_initialized = true;
1642 }
1643
1644 switch (params->cipher) {
1645 case WLAN_CIPHER_SUITE_WEP40:
1646 key.algo = CRYPTO_ALGO_WEP1;
1647 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1648 break;
1649 case WLAN_CIPHER_SUITE_WEP104:
1650 key.algo = CRYPTO_ALGO_WEP128;
1651 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1652 break;
1653 case WLAN_CIPHER_SUITE_TKIP:
1654 key.algo = CRYPTO_ALGO_TKIP;
1655 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1656 break;
1657 case WLAN_CIPHER_SUITE_AES_CMAC:
1658 key.algo = CRYPTO_ALGO_AES_CCM;
1659 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1660 break;
1661 case WLAN_CIPHER_SUITE_CCMP:
1662 key.algo = CRYPTO_ALGO_AES_CCM;
1663 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1664 break;
1665 default:
1666 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1667 return -EINVAL;
1668 }
1669 convert_key_from_CPU(&key);
1670
1671 brcmf_netdev_wait_pend8021x(dev);
1672 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1673 if (unlikely(err)) {
1674 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1675 return err;
1676 }
1677 }
1678 return err;
1679 }
1680
1681 static s32
1682 brcmf_cfg80211_add_key(struct wiphy *wiphy, struct net_device *dev,
1683 u8 key_idx, bool pairwise, const u8 *mac_addr,
1684 struct key_params *params)
1685 {
1686 struct brcmf_wsec_key key;
1687 s32 val;
1688 s32 wsec;
1689 s32 err = 0;
1690 u8 keybuf[8];
1691
1692 WL_TRACE("Enter\n");
1693 WL_CONN("key index (%d)\n", key_idx);
1694 CHECK_SYS_UP();
1695
1696 if (mac_addr) {
1697 WL_TRACE("Exit");
1698 return brcmf_add_keyext(wiphy, dev, key_idx, mac_addr, params);
1699 }
1700 memset(&key, 0, sizeof(key));
1701
1702 key.len = (u32) params->key_len;
1703 key.index = (u32) key_idx;
1704
1705 if (unlikely(key.len > sizeof(key.data))) {
1706 WL_ERR("Too long key length (%u)\n", key.len);
1707 err = -EINVAL;
1708 goto done;
1709 }
1710 memcpy(key.data, params->key, key.len);
1711
1712 key.flags = BRCMF_PRIMARY_KEY;
1713 switch (params->cipher) {
1714 case WLAN_CIPHER_SUITE_WEP40:
1715 key.algo = CRYPTO_ALGO_WEP1;
1716 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1717 break;
1718 case WLAN_CIPHER_SUITE_WEP104:
1719 key.algo = CRYPTO_ALGO_WEP128;
1720 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1721 break;
1722 case WLAN_CIPHER_SUITE_TKIP:
1723 memcpy(keybuf, &key.data[24], sizeof(keybuf));
1724 memcpy(&key.data[24], &key.data[16], sizeof(keybuf));
1725 memcpy(&key.data[16], keybuf, sizeof(keybuf));
1726 key.algo = CRYPTO_ALGO_TKIP;
1727 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1728 break;
1729 case WLAN_CIPHER_SUITE_AES_CMAC:
1730 key.algo = CRYPTO_ALGO_AES_CCM;
1731 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1732 break;
1733 case WLAN_CIPHER_SUITE_CCMP:
1734 key.algo = CRYPTO_ALGO_AES_CCM;
1735 WL_CONN("WLAN_CIPHER_SUITE_CCMP\n");
1736 break;
1737 default:
1738 WL_ERR("Invalid cipher (0x%x)\n", params->cipher);
1739 err = -EINVAL;
1740 goto done;
1741 }
1742
1743 /* Set the new key/index */
1744 convert_key_from_CPU(&key);
1745 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1746 if (unlikely(err)) {
1747 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1748 goto done;
1749 }
1750
1751 val = WEP_ENABLED;
1752 err = brcmf_dev_intvar_get(dev, "wsec", &wsec);
1753 if (unlikely(err)) {
1754 WL_ERR("get wsec error (%d)\n", err);
1755 goto done;
1756 }
1757 wsec &= ~(WEP_ENABLED);
1758 wsec |= val;
1759 err = brcmf_dev_intvar_set(dev, "wsec", wsec);
1760 if (unlikely(err)) {
1761 WL_ERR("set wsec error (%d)\n", err);
1762 goto done;
1763 }
1764
1765 val = 1; /* assume shared key. otherwise 0 */
1766 val = cpu_to_le32(val);
1767 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_AUTH, &val, sizeof(val));
1768 if (unlikely(err))
1769 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1770 done:
1771 WL_TRACE("Exit\n");
1772 return err;
1773 }
1774
1775 static s32
1776 brcmf_cfg80211_del_key(struct wiphy *wiphy, struct net_device *dev,
1777 u8 key_idx, bool pairwise, const u8 *mac_addr)
1778 {
1779 struct brcmf_wsec_key key;
1780 s32 err = 0;
1781 s32 val;
1782 s32 wsec;
1783
1784 WL_TRACE("Enter\n");
1785 CHECK_SYS_UP();
1786 memset(&key, 0, sizeof(key));
1787
1788 key.index = (u32) key_idx;
1789 key.flags = BRCMF_PRIMARY_KEY;
1790 key.algo = CRYPTO_ALGO_OFF;
1791
1792 WL_CONN("key index (%d)\n", key_idx);
1793 /* Set the new key/index */
1794 convert_key_from_CPU(&key);
1795 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_KEY, &key, sizeof(key));
1796 if (unlikely(err)) {
1797 if (err == -EINVAL) {
1798 if (key.index >= DOT11_MAX_DEFAULT_KEYS)
1799 /* we ignore this key index in this case */
1800 WL_ERR("invalid key index (%d)\n", key_idx);
1801 } else
1802 WL_ERR("WLC_SET_KEY error (%d)\n", err);
1803
1804 /* Ignore this error, may happen during DISASSOC */
1805 err = -EAGAIN;
1806 goto done;
1807 }
1808
1809 val = 0;
1810 err = brcmf_dev_intvar_get(dev, "wsec", &wsec);
1811 if (unlikely(err)) {
1812 WL_ERR("get wsec error (%d)\n", err);
1813 /* Ignore this error, may happen during DISASSOC */
1814 err = -EAGAIN;
1815 goto done;
1816 }
1817 wsec &= ~(WEP_ENABLED);
1818 wsec |= val;
1819 err = brcmf_dev_intvar_set(dev, "wsec", wsec);
1820 if (unlikely(err)) {
1821 WL_ERR("set wsec error (%d)\n", err);
1822 /* Ignore this error, may happen during DISASSOC */
1823 err = -EAGAIN;
1824 goto done;
1825 }
1826
1827 val = 0; /* assume open key. otherwise 1 */
1828 val = cpu_to_le32(val);
1829 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_AUTH, &val, sizeof(val));
1830 if (unlikely(err)) {
1831 WL_ERR("WLC_SET_AUTH error (%d)\n", err);
1832 /* Ignore this error, may happen during DISASSOC */
1833 err = -EAGAIN;
1834 }
1835 done:
1836 WL_TRACE("Exit\n");
1837 return err;
1838 }
1839
1840 static s32
1841 brcmf_cfg80211_get_key(struct wiphy *wiphy, struct net_device *dev,
1842 u8 key_idx, bool pairwise, const u8 *mac_addr, void *cookie,
1843 void (*callback) (void *cookie, struct key_params * params))
1844 {
1845 struct key_params params;
1846 struct brcmf_wsec_key key;
1847 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1848 struct brcmf_cfg80211_security *sec;
1849 s32 wsec;
1850 s32 err = 0;
1851
1852 WL_TRACE("Enter\n");
1853 WL_CONN("key index (%d)\n", key_idx);
1854 CHECK_SYS_UP();
1855
1856 memset(&key, 0, sizeof(key));
1857 key.index = key_idx;
1858 convert_key_to_CPU(&key);
1859 memset(&params, 0, sizeof(params));
1860 params.key_len = (u8) min_t(u8, WLAN_MAX_KEY_LEN, key.len);
1861 memcpy(params.key, key.data, params.key_len);
1862
1863 err = brcmf_dev_ioctl(dev, BRCMF_C_GET_WSEC, &wsec, sizeof(wsec));
1864 if (unlikely(err)) {
1865 WL_ERR("WLC_GET_WSEC error (%d)\n", err);
1866 /* Ignore this error, may happen during DISASSOC */
1867 err = -EAGAIN;
1868 goto done;
1869 }
1870 wsec = le32_to_cpu(wsec);
1871 switch (wsec) {
1872 case WEP_ENABLED:
1873 sec = brcmf_read_prof(cfg_priv, WL_PROF_SEC);
1874 if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP40) {
1875 params.cipher = WLAN_CIPHER_SUITE_WEP40;
1876 WL_CONN("WLAN_CIPHER_SUITE_WEP40\n");
1877 } else if (sec->cipher_pairwise & WLAN_CIPHER_SUITE_WEP104) {
1878 params.cipher = WLAN_CIPHER_SUITE_WEP104;
1879 WL_CONN("WLAN_CIPHER_SUITE_WEP104\n");
1880 }
1881 break;
1882 case TKIP_ENABLED:
1883 params.cipher = WLAN_CIPHER_SUITE_TKIP;
1884 WL_CONN("WLAN_CIPHER_SUITE_TKIP\n");
1885 break;
1886 case AES_ENABLED:
1887 params.cipher = WLAN_CIPHER_SUITE_AES_CMAC;
1888 WL_CONN("WLAN_CIPHER_SUITE_AES_CMAC\n");
1889 break;
1890 default:
1891 WL_ERR("Invalid algo (0x%x)\n", wsec);
1892 err = -EINVAL;
1893 goto done;
1894 }
1895 callback(cookie, &params);
1896
1897 done:
1898 WL_TRACE("Exit\n");
1899 return err;
1900 }
1901
1902 static s32
1903 brcmf_cfg80211_config_default_mgmt_key(struct wiphy *wiphy,
1904 struct net_device *dev, u8 key_idx)
1905 {
1906 WL_INFO("Not supported\n");
1907
1908 CHECK_SYS_UP();
1909 return -EOPNOTSUPP;
1910 }
1911
1912 static s32
1913 brcmf_cfg80211_get_station(struct wiphy *wiphy, struct net_device *dev,
1914 u8 *mac, struct station_info *sinfo)
1915 {
1916 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1917 struct brcmf_scb_val scb_val;
1918 int rssi;
1919 s32 rate;
1920 s32 err = 0;
1921 u8 *bssid = brcmf_read_prof(cfg_priv, WL_PROF_BSSID);
1922
1923 WL_TRACE("Enter\n");
1924 CHECK_SYS_UP();
1925
1926 if (unlikely
1927 (memcmp(mac, bssid, ETH_ALEN))) {
1928 WL_ERR("Wrong Mac address cfg_mac-%X:%X:%X:%X:%X:%X"
1929 "wl_bssid-%X:%X:%X:%X:%X:%X\n",
1930 mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
1931 bssid[0], bssid[1], bssid[2], bssid[3],
1932 bssid[4], bssid[5]);
1933 err = -ENOENT;
1934 goto done;
1935 }
1936
1937 /* Report the current tx rate */
1938 err = brcmf_dev_ioctl(dev, BRCMF_C_GET_RATE, &rate, sizeof(rate));
1939 if (err) {
1940 WL_ERR("Could not get rate (%d)\n", err);
1941 } else {
1942 rate = le32_to_cpu(rate);
1943 sinfo->filled |= STATION_INFO_TX_BITRATE;
1944 sinfo->txrate.legacy = rate * 5;
1945 WL_CONN("Rate %d Mbps\n", rate / 2);
1946 }
1947
1948 if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status)) {
1949 scb_val.val = 0;
1950 err = brcmf_dev_ioctl(dev, BRCMF_C_GET_RSSI, &scb_val,
1951 sizeof(struct brcmf_scb_val));
1952 if (unlikely(err))
1953 WL_ERR("Could not get rssi (%d)\n", err);
1954
1955 rssi = le32_to_cpu(scb_val.val);
1956 sinfo->filled |= STATION_INFO_SIGNAL;
1957 sinfo->signal = rssi;
1958 WL_CONN("RSSI %d dBm\n", rssi);
1959 }
1960
1961 done:
1962 WL_TRACE("Exit\n");
1963 return err;
1964 }
1965
1966 static s32
1967 brcmf_cfg80211_set_power_mgmt(struct wiphy *wiphy, struct net_device *dev,
1968 bool enabled, s32 timeout)
1969 {
1970 s32 pm;
1971 s32 err = 0;
1972 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
1973
1974 WL_TRACE("Enter\n");
1975
1976 /*
1977 * Powersave enable/disable request is coming from the
1978 * cfg80211 even before the interface is up. In that
1979 * scenario, driver will be storing the power save
1980 * preference in cfg_priv struct to apply this to
1981 * FW later while initializing the dongle
1982 */
1983 cfg_priv->pwr_save = enabled;
1984 if (!test_bit(WL_STATUS_READY, &cfg_priv->status)) {
1985
1986 WL_INFO("Device is not ready,"
1987 "storing the value in cfg_priv struct\n");
1988 goto done;
1989 }
1990
1991 pm = enabled ? PM_FAST : PM_OFF;
1992 pm = cpu_to_le32(pm);
1993 WL_INFO("power save %s\n", (pm ? "enabled" : "disabled"));
1994
1995 err = brcmf_dev_ioctl(dev, BRCMF_C_SET_PM, &pm, sizeof(pm));
1996 if (unlikely(err)) {
1997 if (err == -ENODEV)
1998 WL_ERR("net_device is not ready yet\n");
1999 else
2000 WL_ERR("error (%d)\n", err);
2001 }
2002 done:
2003 WL_TRACE("Exit\n");
2004 return err;
2005 }
2006
2007 static s32
2008 brcmf_cfg80211_set_bitrate_mask(struct wiphy *wiphy, struct net_device *dev,
2009 const u8 *addr,
2010 const struct cfg80211_bitrate_mask *mask)
2011 {
2012 struct brcm_rateset rateset;
2013 s32 rate;
2014 s32 val;
2015 s32 err_bg;
2016 s32 err_a;
2017 u32 legacy;
2018 s32 err = 0;
2019
2020 WL_TRACE("Enter\n");
2021 CHECK_SYS_UP();
2022
2023 /* addr param is always NULL. ignore it */
2024 /* Get current rateset */
2025 err = brcmf_dev_ioctl(dev, BRCM_GET_CURR_RATESET, &rateset,
2026 sizeof(rateset));
2027 if (unlikely(err)) {
2028 WL_ERR("could not get current rateset (%d)\n", err);
2029 goto done;
2030 }
2031
2032 rateset.count = le32_to_cpu(rateset.count);
2033
2034 legacy = ffs(mask->control[IEEE80211_BAND_2GHZ].legacy & 0xFFFF);
2035 if (!legacy)
2036 legacy = ffs(mask->control[IEEE80211_BAND_5GHZ].legacy &
2037 0xFFFF);
2038
2039 val = wl_g_rates[legacy - 1].bitrate * 100000;
2040
2041 if (val < rateset.count)
2042 /* Select rate by rateset index */
2043 rate = rateset.rates[val] & 0x7f;
2044 else
2045 /* Specified rate in bps */
2046 rate = val / 500000;
2047
2048 WL_CONN("rate %d mbps\n", rate / 2);
2049
2050 /*
2051 *
2052 * Set rate override,
2053 * Since the is a/b/g-blind, both a/bg_rate are enforced.
2054 */
2055 err_bg = brcmf_dev_intvar_set(dev, "bg_rate", rate);
2056 err_a = brcmf_dev_intvar_set(dev, "a_rate", rate);
2057 if (unlikely(err_bg && err_a)) {
2058 WL_ERR("could not set fixed rate (%d) (%d)\n", err_bg, err_a);
2059 err = err_bg | err_a;
2060 }
2061
2062 done:
2063 WL_TRACE("Exit\n");
2064 return err;
2065 }
2066
2067 static s32 brcmf_cfg80211_resume(struct wiphy *wiphy)
2068 {
2069 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2070
2071 /*
2072 * Check for WL_STATUS_READY before any function call which
2073 * could result is bus access. Don't block the resume for
2074 * any driver error conditions
2075 */
2076 WL_TRACE("Enter\n");
2077
2078 if (test_bit(WL_STATUS_READY, &cfg_priv->status))
2079 brcmf_invoke_iscan(wiphy_to_cfg(wiphy));
2080
2081 WL_TRACE("Exit\n");
2082 return 0;
2083 }
2084
2085 static s32 brcmf_cfg80211_suspend(struct wiphy *wiphy,
2086 struct cfg80211_wowlan *wow)
2087 {
2088 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2089 struct net_device *ndev = cfg_to_ndev(cfg_priv);
2090
2091 WL_TRACE("Enter\n");
2092
2093 /*
2094 * Check for WL_STATUS_READY before any function call which
2095 * could result is bus access. Don't block the suspend for
2096 * any driver error conditions
2097 */
2098
2099 /*
2100 * While going to suspend if associated with AP disassociate
2101 * from AP to save power while system is in suspended state
2102 */
2103 if ((test_bit(WL_STATUS_CONNECTED, &cfg_priv->status) ||
2104 test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) &&
2105 test_bit(WL_STATUS_READY, &cfg_priv->status)) {
2106 WL_INFO("Disassociating from AP"
2107 " while entering suspend state\n");
2108 brcmf_link_down(cfg_priv);
2109
2110 /*
2111 * Make sure WPA_Supplicant receives all the event
2112 * generated due to DISASSOC call to the fw to keep
2113 * the state fw and WPA_Supplicant state consistent
2114 */
2115 rtnl_unlock();
2116 brcmf_delay(500);
2117 rtnl_lock();
2118 }
2119
2120 set_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
2121 if (test_bit(WL_STATUS_READY, &cfg_priv->status))
2122 brcmf_term_iscan(cfg_priv);
2123
2124 if (cfg_priv->scan_request) {
2125 /* Indidate scan abort to cfg80211 layer */
2126 WL_INFO("Terminating scan in progress\n");
2127 cfg80211_scan_done(cfg_priv->scan_request, true);
2128 cfg_priv->scan_request = NULL;
2129 }
2130 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
2131 clear_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
2132
2133 /* Turn off watchdog timer */
2134 if (test_bit(WL_STATUS_READY, &cfg_priv->status)) {
2135 WL_INFO("Enable MPC\n");
2136 brcmf_set_mpc(ndev, 1);
2137 }
2138
2139 WL_TRACE("Exit\n");
2140
2141 return 0;
2142 }
2143
2144 static __used s32
2145 brcmf_update_pmklist(struct net_device *dev,
2146 struct brcmf_cfg80211_pmk_list *pmk_list, s32 err)
2147 {
2148 int i, j;
2149
2150 WL_CONN("No of elements %d\n", pmk_list->pmkids.npmkid);
2151 for (i = 0; i < pmk_list->pmkids.npmkid; i++) {
2152 WL_CONN("PMKID[%d]: %pM =\n", i,
2153 &pmk_list->pmkids.pmkid[i].BSSID);
2154 for (j = 0; j < WLAN_PMKID_LEN; j++)
2155 WL_CONN("%02x\n", pmk_list->pmkids.pmkid[i].PMKID[j]);
2156 }
2157
2158 if (likely(!err))
2159 brcmf_dev_bufvar_set(dev, "pmkid_info", (char *)pmk_list,
2160 sizeof(*pmk_list));
2161
2162 return err;
2163 }
2164
2165 static s32
2166 brcmf_cfg80211_set_pmksa(struct wiphy *wiphy, struct net_device *dev,
2167 struct cfg80211_pmksa *pmksa)
2168 {
2169 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2170 struct pmkid_list *pmkids = &cfg_priv->pmk_list->pmkids;
2171 s32 err = 0;
2172 int i;
2173
2174 WL_TRACE("Enter\n");
2175 CHECK_SYS_UP();
2176
2177 for (i = 0; i < pmkids->npmkid; i++)
2178 if (!memcmp(pmksa->bssid, pmkids->pmkid[i].BSSID, ETH_ALEN))
2179 break;
2180 if (i < WL_NUM_PMKIDS_MAX) {
2181 memcpy(pmkids->pmkid[i].BSSID, pmksa->bssid, ETH_ALEN);
2182 memcpy(pmkids->pmkid[i].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2183 if (i == pmkids->npmkid)
2184 pmkids->npmkid++;
2185 } else
2186 err = -EINVAL;
2187
2188 WL_CONN("set_pmksa,IW_PMKSA_ADD - PMKID: %pM =\n",
2189 pmkids->pmkid[pmkids->npmkid].BSSID);
2190 for (i = 0; i < WLAN_PMKID_LEN; i++)
2191 WL_CONN("%02x\n", pmkids->pmkid[pmkids->npmkid].PMKID[i]);
2192
2193 err = brcmf_update_pmklist(dev, cfg_priv->pmk_list, err);
2194
2195 WL_TRACE("Exit\n");
2196 return err;
2197 }
2198
2199 static s32
2200 brcmf_cfg80211_del_pmksa(struct wiphy *wiphy, struct net_device *dev,
2201 struct cfg80211_pmksa *pmksa)
2202 {
2203 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2204 struct pmkid_list pmkid;
2205 s32 err = 0;
2206 int i;
2207
2208 WL_TRACE("Enter\n");
2209 CHECK_SYS_UP();
2210 memcpy(&pmkid.pmkid[0].BSSID, pmksa->bssid, ETH_ALEN);
2211 memcpy(&pmkid.pmkid[0].PMKID, pmksa->pmkid, WLAN_PMKID_LEN);
2212
2213 WL_CONN("del_pmksa,IW_PMKSA_REMOVE - PMKID: %pM =\n",
2214 &pmkid.pmkid[0].BSSID);
2215 for (i = 0; i < WLAN_PMKID_LEN; i++)
2216 WL_CONN("%02x\n", pmkid.pmkid[0].PMKID[i]);
2217
2218 for (i = 0; i < cfg_priv->pmk_list->pmkids.npmkid; i++)
2219 if (!memcmp
2220 (pmksa->bssid, &cfg_priv->pmk_list->pmkids.pmkid[i].BSSID,
2221 ETH_ALEN))
2222 break;
2223
2224 if ((cfg_priv->pmk_list->pmkids.npmkid > 0)
2225 && (i < cfg_priv->pmk_list->pmkids.npmkid)) {
2226 memset(&cfg_priv->pmk_list->pmkids.pmkid[i], 0,
2227 sizeof(struct pmkid));
2228 for (; i < (cfg_priv->pmk_list->pmkids.npmkid - 1); i++) {
2229 memcpy(&cfg_priv->pmk_list->pmkids.pmkid[i].BSSID,
2230 &cfg_priv->pmk_list->pmkids.pmkid[i + 1].BSSID,
2231 ETH_ALEN);
2232 memcpy(&cfg_priv->pmk_list->pmkids.pmkid[i].PMKID,
2233 &cfg_priv->pmk_list->pmkids.pmkid[i + 1].PMKID,
2234 WLAN_PMKID_LEN);
2235 }
2236 cfg_priv->pmk_list->pmkids.npmkid--;
2237 } else
2238 err = -EINVAL;
2239
2240 err = brcmf_update_pmklist(dev, cfg_priv->pmk_list, err);
2241
2242 WL_TRACE("Exit\n");
2243 return err;
2244
2245 }
2246
2247 static s32
2248 brcmf_cfg80211_flush_pmksa(struct wiphy *wiphy, struct net_device *dev)
2249 {
2250 struct brcmf_cfg80211_priv *cfg_priv = wiphy_to_cfg(wiphy);
2251 s32 err = 0;
2252
2253 WL_TRACE("Enter\n");
2254 CHECK_SYS_UP();
2255
2256 memset(cfg_priv->pmk_list, 0, sizeof(*cfg_priv->pmk_list));
2257 err = brcmf_update_pmklist(dev, cfg_priv->pmk_list, err);
2258
2259 WL_TRACE("Exit\n");
2260 return err;
2261
2262 }
2263
2264 static struct cfg80211_ops wl_cfg80211_ops = {
2265 .change_virtual_intf = brcmf_cfg80211_change_iface,
2266 .scan = brcmf_cfg80211_scan,
2267 .set_wiphy_params = brcmf_cfg80211_set_wiphy_params,
2268 .join_ibss = brcmf_cfg80211_join_ibss,
2269 .leave_ibss = brcmf_cfg80211_leave_ibss,
2270 .get_station = brcmf_cfg80211_get_station,
2271 .set_tx_power = brcmf_cfg80211_set_tx_power,
2272 .get_tx_power = brcmf_cfg80211_get_tx_power,
2273 .add_key = brcmf_cfg80211_add_key,
2274 .del_key = brcmf_cfg80211_del_key,
2275 .get_key = brcmf_cfg80211_get_key,
2276 .set_default_key = brcmf_cfg80211_config_default_key,
2277 .set_default_mgmt_key = brcmf_cfg80211_config_default_mgmt_key,
2278 .set_power_mgmt = brcmf_cfg80211_set_power_mgmt,
2279 .set_bitrate_mask = brcmf_cfg80211_set_bitrate_mask,
2280 .connect = brcmf_cfg80211_connect,
2281 .disconnect = brcmf_cfg80211_disconnect,
2282 .suspend = brcmf_cfg80211_suspend,
2283 .resume = brcmf_cfg80211_resume,
2284 .set_pmksa = brcmf_cfg80211_set_pmksa,
2285 .del_pmksa = brcmf_cfg80211_del_pmksa,
2286 .flush_pmksa = brcmf_cfg80211_flush_pmksa
2287 };
2288
2289 static s32 brcmf_mode_to_nl80211_iftype(s32 mode)
2290 {
2291 s32 err = 0;
2292
2293 switch (mode) {
2294 case WL_MODE_BSS:
2295 return NL80211_IFTYPE_STATION;
2296 case WL_MODE_IBSS:
2297 return NL80211_IFTYPE_ADHOC;
2298 default:
2299 return NL80211_IFTYPE_UNSPECIFIED;
2300 }
2301
2302 return err;
2303 }
2304
2305 static struct wireless_dev *brcmf_alloc_wdev(s32 sizeof_iface,
2306 struct device *dev)
2307 {
2308 struct wireless_dev *wdev;
2309 s32 err = 0;
2310
2311 wdev = kzalloc(sizeof(*wdev), GFP_KERNEL);
2312 if (unlikely(!wdev)) {
2313 WL_ERR("Could not allocate wireless device\n");
2314 return ERR_PTR(-ENOMEM);
2315 }
2316 wdev->wiphy =
2317 wiphy_new(&wl_cfg80211_ops,
2318 sizeof(struct brcmf_cfg80211_priv) + sizeof_iface);
2319 if (unlikely(!wdev->wiphy)) {
2320 WL_ERR("Couldn not allocate wiphy device\n");
2321 err = -ENOMEM;
2322 goto wiphy_new_out;
2323 }
2324 set_wiphy_dev(wdev->wiphy, dev);
2325 wdev->wiphy->max_scan_ssids = WL_NUM_SCAN_MAX;
2326 wdev->wiphy->max_num_pmkids = WL_NUM_PMKIDS_MAX;
2327 wdev->wiphy->interface_modes =
2328 BIT(NL80211_IFTYPE_STATION) | BIT(NL80211_IFTYPE_ADHOC);
2329 wdev->wiphy->bands[IEEE80211_BAND_2GHZ] = &__wl_band_2ghz;
2330 wdev->wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_a; /* Set
2331 * it as 11a by default.
2332 * This will be updated with
2333 * 11n phy tables in
2334 * "ifconfig up"
2335 * if phy has 11n capability
2336 */
2337 wdev->wiphy->signal_type = CFG80211_SIGNAL_TYPE_MBM;
2338 wdev->wiphy->cipher_suites = __wl_cipher_suites;
2339 wdev->wiphy->n_cipher_suites = ARRAY_SIZE(__wl_cipher_suites);
2340 #ifndef WL_POWERSAVE_DISABLED
2341 wdev->wiphy->flags |= WIPHY_FLAG_PS_ON_BY_DEFAULT; /* enable power
2342 * save mode
2343 * by default
2344 */
2345 #else
2346 wdev->wiphy->flags &= ~WIPHY_FLAG_PS_ON_BY_DEFAULT;
2347 #endif /* !WL_POWERSAVE_DISABLED */
2348 err = wiphy_register(wdev->wiphy);
2349 if (unlikely(err < 0)) {
2350 WL_ERR("Couldn not register wiphy device (%d)\n", err);
2351 goto wiphy_register_out;
2352 }
2353 return wdev;
2354
2355 wiphy_register_out:
2356 wiphy_free(wdev->wiphy);
2357
2358 wiphy_new_out:
2359 kfree(wdev);
2360
2361 return ERR_PTR(err);
2362 }
2363
2364 static void brcmf_free_wdev(struct brcmf_cfg80211_priv *cfg_priv)
2365 {
2366 struct wireless_dev *wdev = cfg_to_wdev(cfg_priv);
2367
2368 if (unlikely(!wdev)) {
2369 WL_ERR("wdev is invalid\n");
2370 return;
2371 }
2372 wiphy_unregister(wdev->wiphy);
2373 wiphy_free(wdev->wiphy);
2374 kfree(wdev);
2375 cfg_to_wdev(cfg_priv) = NULL;
2376 }
2377
2378 static s32 brcmf_inform_bss(struct brcmf_cfg80211_priv *cfg_priv)
2379 {
2380 struct brcmf_scan_results *bss_list;
2381 struct brcmf_bss_info *bi = NULL; /* must be initialized */
2382 s32 err = 0;
2383 int i;
2384
2385 bss_list = cfg_priv->bss_list;
2386 if (unlikely(bss_list->version != BRCMF_BSS_INFO_VERSION)) {
2387 WL_ERR("Version %d != WL_BSS_INFO_VERSION\n",
2388 bss_list->version);
2389 return -EOPNOTSUPP;
2390 }
2391 WL_SCAN("scanned AP count (%d)\n", bss_list->count);
2392 bi = next_bss(bss_list, bi);
2393 for_each_bss(bss_list, bi, i) {
2394 err = brcmf_inform_single_bss(cfg_priv, bi);
2395 if (unlikely(err))
2396 break;
2397 }
2398 return err;
2399 }
2400
2401
2402 static s32 brcmf_inform_single_bss(struct brcmf_cfg80211_priv *cfg_priv,
2403 struct brcmf_bss_info *bi)
2404 {
2405 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2406 struct ieee80211_channel *notify_channel;
2407 struct cfg80211_bss *bss;
2408 struct ieee80211_supported_band *band;
2409 s32 err = 0;
2410 u16 channel;
2411 u32 freq;
2412 u64 notify_timestamp;
2413 u16 notify_capability;
2414 u16 notify_interval;
2415 u8 *notify_ie;
2416 size_t notify_ielen;
2417 s32 notify_signal;
2418
2419 if (unlikely(le32_to_cpu(bi->length) > WL_BSS_INFO_MAX)) {
2420 WL_ERR("Bss info is larger than buffer. Discarding\n");
2421 return 0;
2422 }
2423
2424 channel = bi->ctl_ch ? bi->ctl_ch :
2425 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2426
2427 if (channel <= CH_MAX_2G_CHANNEL)
2428 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2429 else
2430 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2431
2432 freq = ieee80211_channel_to_frequency(channel, band->band);
2433 notify_channel = ieee80211_get_channel(wiphy, freq);
2434
2435 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2436 notify_capability = le16_to_cpu(bi->capability);
2437 notify_interval = le16_to_cpu(bi->beacon_period);
2438 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2439 notify_ielen = le16_to_cpu(bi->ie_length);
2440 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2441
2442 WL_CONN("bssid: %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
2443 bi->BSSID[0], bi->BSSID[1], bi->BSSID[2],
2444 bi->BSSID[3], bi->BSSID[4], bi->BSSID[5]);
2445 WL_CONN("Channel: %d(%d)\n", channel, freq);
2446 WL_CONN("Capability: %X\n", notify_capability);
2447 WL_CONN("Beacon interval: %d\n", notify_interval);
2448 WL_CONN("Signal: %d\n", notify_signal);
2449 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2450
2451 bss = cfg80211_inform_bss(wiphy, notify_channel, (const u8 *)bi->BSSID,
2452 notify_timestamp, notify_capability, notify_interval, notify_ie,
2453 notify_ielen, notify_signal, GFP_KERNEL);
2454
2455 if (unlikely(!bss)) {
2456 WL_ERR("cfg80211_inform_bss_frame error\n");
2457 return -EINVAL;
2458 }
2459
2460 return err;
2461 }
2462
2463 static s32 wl_inform_ibss(struct brcmf_cfg80211_priv *cfg_priv,
2464 struct net_device *dev, const u8 *bssid)
2465 {
2466 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2467 struct ieee80211_channel *notify_channel;
2468 struct brcmf_bss_info *bi = NULL;
2469 struct ieee80211_supported_band *band;
2470 u8 *buf = NULL;
2471 s32 err = 0;
2472 u16 channel;
2473 u32 freq;
2474 u64 notify_timestamp;
2475 u16 notify_capability;
2476 u16 notify_interval;
2477 u8 *notify_ie;
2478 size_t notify_ielen;
2479 s32 notify_signal;
2480
2481 WL_TRACE("Enter\n");
2482
2483 buf = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
2484 if (buf == NULL) {
2485 WL_ERR("kzalloc() failed\n");
2486 err = -ENOMEM;
2487 goto CleanUp;
2488 }
2489
2490 *(u32 *)buf = cpu_to_le32(WL_BSS_INFO_MAX);
2491
2492 err = brcmf_dev_ioctl(dev, BRCMF_C_GET_BSS_INFO, buf, WL_BSS_INFO_MAX);
2493 if (unlikely(err)) {
2494 WL_ERR("WLC_GET_BSS_INFO failed: %d\n", err);
2495 goto CleanUp;
2496 }
2497
2498 bi = (struct brcmf_bss_info *)(buf + 4);
2499
2500 channel = bi->ctl_ch ? bi->ctl_ch :
2501 CHSPEC_CHANNEL(le16_to_cpu(bi->chanspec));
2502
2503 if (channel <= CH_MAX_2G_CHANNEL)
2504 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2505 else
2506 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2507
2508 freq = ieee80211_channel_to_frequency(channel, band->band);
2509 notify_channel = ieee80211_get_channel(wiphy, freq);
2510
2511 notify_timestamp = jiffies_to_msecs(jiffies)*1000; /* uSec */
2512 notify_capability = le16_to_cpu(bi->capability);
2513 notify_interval = le16_to_cpu(bi->beacon_period);
2514 notify_ie = (u8 *)bi + le16_to_cpu(bi->ie_offset);
2515 notify_ielen = le16_to_cpu(bi->ie_length);
2516 notify_signal = (s16)le16_to_cpu(bi->RSSI) * 100;
2517
2518 WL_CONN("channel: %d(%d)\n", channel, freq);
2519 WL_CONN("capability: %X\n", notify_capability);
2520 WL_CONN("beacon interval: %d\n", notify_interval);
2521 WL_CONN("signal: %d\n", notify_signal);
2522 WL_CONN("notify_timestamp: %#018llx\n", notify_timestamp);
2523
2524 cfg80211_inform_bss(wiphy, notify_channel, bssid,
2525 notify_timestamp, notify_capability, notify_interval,
2526 notify_ie, notify_ielen, notify_signal, GFP_KERNEL);
2527
2528 CleanUp:
2529
2530 kfree(buf);
2531
2532 WL_TRACE("Exit\n");
2533
2534 return err;
2535 }
2536
2537 static bool brcmf_is_linkup(struct brcmf_cfg80211_priv *cfg_priv,
2538 const struct brcmf_event_msg *e)
2539 {
2540 u32 event = be32_to_cpu(e->event_type);
2541 u32 status = be32_to_cpu(e->status);
2542
2543 if (event == BRCMF_E_SET_SSID && status == BRCMF_E_STATUS_SUCCESS) {
2544 WL_CONN("Processing set ssid\n");
2545 cfg_priv->link_up = true;
2546 return true;
2547 }
2548
2549 return false;
2550 }
2551
2552 static bool brcmf_is_linkdown(struct brcmf_cfg80211_priv *cfg_priv,
2553 const struct brcmf_event_msg *e)
2554 {
2555 u32 event = be32_to_cpu(e->event_type);
2556 u16 flags = be16_to_cpu(e->flags);
2557
2558 if (event == BRCMF_E_LINK && (!(flags & BRCMF_EVENT_MSG_LINK))) {
2559 WL_CONN("Processing link down\n");
2560 return true;
2561 }
2562 return false;
2563 }
2564
2565 static bool brcmf_is_nonetwork(struct brcmf_cfg80211_priv *cfg_priv,
2566 const struct brcmf_event_msg *e)
2567 {
2568 u32 event = be32_to_cpu(e->event_type);
2569 u32 status = be32_to_cpu(e->status);
2570
2571 if (event == BRCMF_E_LINK && status == BRCMF_E_STATUS_NO_NETWORKS) {
2572 WL_CONN("Processing Link %s & no network found\n",
2573 be16_to_cpu(e->flags) & BRCMF_EVENT_MSG_LINK ?
2574 "up" : "down");
2575 return true;
2576 }
2577
2578 if (event == BRCMF_E_SET_SSID && status != BRCMF_E_STATUS_SUCCESS) {
2579 WL_CONN("Processing connecting & no network found\n");
2580 return true;
2581 }
2582
2583 return false;
2584 }
2585
2586 static s32
2587 brcmf_notify_connect_status(struct brcmf_cfg80211_priv *cfg_priv,
2588 struct net_device *ndev,
2589 const struct brcmf_event_msg *e, void *data)
2590 {
2591 s32 err = 0;
2592
2593 if (brcmf_is_linkup(cfg_priv, e)) {
2594 WL_CONN("Linkup\n");
2595 if (brcmf_is_ibssmode(cfg_priv)) {
2596 brcmf_update_prof(cfg_priv, NULL, (void *)e->addr,
2597 WL_PROF_BSSID);
2598 wl_inform_ibss(cfg_priv, ndev, e->addr);
2599 cfg80211_ibss_joined(ndev, e->addr, GFP_KERNEL);
2600 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
2601 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
2602 } else
2603 brcmf_bss_connect_done(cfg_priv, ndev, e, true);
2604 } else if (brcmf_is_linkdown(cfg_priv, e)) {
2605 WL_CONN("Linkdown\n");
2606 if (brcmf_is_ibssmode(cfg_priv)) {
2607 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
2608 if (test_and_clear_bit(WL_STATUS_CONNECTED,
2609 &cfg_priv->status))
2610 brcmf_link_down(cfg_priv);
2611 } else {
2612 brcmf_bss_connect_done(cfg_priv, ndev, e, false);
2613 if (test_and_clear_bit(WL_STATUS_CONNECTED,
2614 &cfg_priv->status)) {
2615 cfg80211_disconnected(ndev, 0, NULL, 0,
2616 GFP_KERNEL);
2617 brcmf_link_down(cfg_priv);
2618 }
2619 }
2620 brcmf_init_prof(cfg_priv->profile);
2621 } else if (brcmf_is_nonetwork(cfg_priv, e)) {
2622 if (brcmf_is_ibssmode(cfg_priv))
2623 clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status);
2624 else
2625 brcmf_bss_connect_done(cfg_priv, ndev, e, false);
2626 }
2627
2628 return err;
2629 }
2630
2631 static s32
2632 brcmf_notify_roaming_status(struct brcmf_cfg80211_priv *cfg_priv,
2633 struct net_device *ndev,
2634 const struct brcmf_event_msg *e, void *data)
2635 {
2636 s32 err = 0;
2637 u32 event = be32_to_cpu(e->event_type);
2638 u32 status = be32_to_cpu(e->status);
2639
2640 if (event == BRCMF_E_ROAM && status == BRCMF_E_STATUS_SUCCESS) {
2641 if (test_bit(WL_STATUS_CONNECTED, &cfg_priv->status))
2642 brcmf_bss_roaming_done(cfg_priv, ndev, e);
2643 else
2644 brcmf_bss_connect_done(cfg_priv, ndev, e, true);
2645 }
2646
2647 return err;
2648 }
2649
2650 static __used s32
2651 brcmf_dev_bufvar_set(struct net_device *dev, s8 *name, s8 *buf, s32 len)
2652 {
2653 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
2654 u32 buflen;
2655
2656 buflen = brcmu_mkiovar(name, buf, len, cfg_priv->ioctl_buf,
2657 WL_IOCTL_LEN_MAX);
2658 BUG_ON(!buflen);
2659
2660 return brcmf_dev_ioctl(dev, BRCMF_C_SET_VAR, cfg_priv->ioctl_buf,
2661 buflen);
2662 }
2663
2664 static s32
2665 brcmf_dev_bufvar_get(struct net_device *dev, s8 *name, s8 *buf,
2666 s32 buf_len)
2667 {
2668 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(dev);
2669 u32 len;
2670 s32 err = 0;
2671
2672 len = brcmu_mkiovar(name, NULL, 0, cfg_priv->ioctl_buf,
2673 WL_IOCTL_LEN_MAX);
2674 BUG_ON(!len);
2675 err = brcmf_dev_ioctl(dev, BRCMF_C_GET_VAR, (void *)cfg_priv->ioctl_buf,
2676 WL_IOCTL_LEN_MAX);
2677 if (unlikely(err)) {
2678 WL_ERR("error (%d)\n", err);
2679 return err;
2680 }
2681 memcpy(buf, cfg_priv->ioctl_buf, buf_len);
2682
2683 return err;
2684 }
2685
2686 static s32 brcmf_get_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv)
2687 {
2688 struct net_device *ndev = cfg_to_ndev(cfg_priv);
2689 struct brcmf_cfg80211_assoc_ielen *assoc_info;
2690 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2691 u32 req_len;
2692 u32 resp_len;
2693 s32 err = 0;
2694
2695 brcmf_clear_assoc_ies(cfg_priv);
2696
2697 err = brcmf_dev_bufvar_get(ndev, "assoc_info", cfg_priv->extra_buf,
2698 WL_ASSOC_INFO_MAX);
2699 if (unlikely(err)) {
2700 WL_ERR("could not get assoc info (%d)\n", err);
2701 return err;
2702 }
2703 assoc_info = (struct brcmf_cfg80211_assoc_ielen *)cfg_priv->extra_buf;
2704 req_len = assoc_info->req_len;
2705 resp_len = assoc_info->resp_len;
2706 if (req_len) {
2707 err = brcmf_dev_bufvar_get(ndev, "assoc_req_ies",
2708 cfg_priv->extra_buf,
2709 WL_ASSOC_INFO_MAX);
2710 if (unlikely(err)) {
2711 WL_ERR("could not get assoc req (%d)\n", err);
2712 return err;
2713 }
2714 conn_info->req_ie_len = req_len;
2715 conn_info->req_ie =
2716 kmemdup(cfg_priv->extra_buf, conn_info->req_ie_len,
2717 GFP_KERNEL);
2718 } else {
2719 conn_info->req_ie_len = 0;
2720 conn_info->req_ie = NULL;
2721 }
2722 if (resp_len) {
2723 err = brcmf_dev_bufvar_get(ndev, "assoc_resp_ies",
2724 cfg_priv->extra_buf,
2725 WL_ASSOC_INFO_MAX);
2726 if (unlikely(err)) {
2727 WL_ERR("could not get assoc resp (%d)\n", err);
2728 return err;
2729 }
2730 conn_info->resp_ie_len = resp_len;
2731 conn_info->resp_ie =
2732 kmemdup(cfg_priv->extra_buf, conn_info->resp_ie_len,
2733 GFP_KERNEL);
2734 } else {
2735 conn_info->resp_ie_len = 0;
2736 conn_info->resp_ie = NULL;
2737 }
2738 WL_CONN("req len (%d) resp len (%d)\n",
2739 conn_info->req_ie_len, conn_info->resp_ie_len);
2740
2741 return err;
2742 }
2743
2744 static void brcmf_clear_assoc_ies(struct brcmf_cfg80211_priv *cfg_priv)
2745 {
2746 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2747
2748 kfree(conn_info->req_ie);
2749 conn_info->req_ie = NULL;
2750 conn_info->req_ie_len = 0;
2751 kfree(conn_info->resp_ie);
2752 conn_info->resp_ie = NULL;
2753 conn_info->resp_ie_len = 0;
2754 }
2755
2756
2757 static void brcmf_ch_to_chanspec(int ch, struct brcmf_join_params *join_params,
2758 size_t *join_params_size)
2759 {
2760 u16 chanspec = 0;
2761
2762 if (ch != 0) {
2763 join_params->params.chanspec_num = 1;
2764 join_params->params.chanspec_list[0] = ch;
2765
2766 if (join_params->params.chanspec_list[0] <= CH_MAX_2G_CHANNEL)
2767 chanspec |= WL_CHANSPEC_BAND_2G;
2768 else
2769 chanspec |= WL_CHANSPEC_BAND_5G;
2770
2771 chanspec |= WL_CHANSPEC_BW_20;
2772 chanspec |= WL_CHANSPEC_CTL_SB_NONE;
2773
2774 *join_params_size += BRCMF_ASSOC_PARAMS_FIXED_SIZE +
2775 join_params->params.chanspec_num * sizeof(u16);
2776
2777 join_params->params.chanspec_list[0] &= WL_CHANSPEC_CHAN_MASK;
2778 join_params->params.chanspec_list[0] |= chanspec;
2779 join_params->params.chanspec_list[0] =
2780 cpu_to_le16(join_params->params.chanspec_list[0]);
2781
2782 join_params->params.chanspec_num =
2783 cpu_to_le32(join_params->params.chanspec_num);
2784
2785 WL_CONN("join_params->params.chanspec_list[0]= %#X,"
2786 "channel %d, chanspec %#X\n",
2787 join_params->params.chanspec_list[0], ch, chanspec);
2788 }
2789 }
2790
2791 static s32 brcmf_update_bss_info(struct brcmf_cfg80211_priv *cfg_priv)
2792 {
2793 struct brcmf_bss_info *bi;
2794 struct brcmf_ssid *ssid;
2795 struct brcmu_tlv *tim;
2796 u16 beacon_interval;
2797 u8 dtim_period;
2798 size_t ie_len;
2799 u8 *ie;
2800 s32 err = 0;
2801
2802 WL_TRACE("Enter\n");
2803 if (brcmf_is_ibssmode(cfg_priv))
2804 return err;
2805
2806 ssid = (struct brcmf_ssid *)brcmf_read_prof(cfg_priv, WL_PROF_SSID);
2807
2808 *(u32 *)cfg_priv->extra_buf = cpu_to_le32(WL_EXTRA_BUF_MAX);
2809 err = brcmf_dev_ioctl(cfg_to_ndev(cfg_priv), BRCMF_C_GET_BSS_INFO,
2810 cfg_priv->extra_buf, WL_EXTRA_BUF_MAX);
2811 if (unlikely(err)) {
2812 WL_ERR("Could not get bss info %d\n", err);
2813 goto update_bss_info_out;
2814 }
2815
2816 bi = (struct brcmf_bss_info *)(cfg_priv->extra_buf + 4);
2817 err = brcmf_inform_single_bss(cfg_priv, bi);
2818 if (unlikely(err))
2819 goto update_bss_info_out;
2820
2821 ie = ((u8 *)bi) + bi->ie_offset;
2822 ie_len = bi->ie_length;
2823 beacon_interval = cpu_to_le16(bi->beacon_period);
2824
2825 tim = brcmu_parse_tlvs(ie, ie_len, WLAN_EID_TIM);
2826 if (tim)
2827 dtim_period = tim->data[1];
2828 else {
2829 /*
2830 * active scan was done so we could not get dtim
2831 * information out of probe response.
2832 * so we speficially query dtim information to dongle.
2833 */
2834 u32 var;
2835 err = brcmf_dev_intvar_get(cfg_to_ndev(cfg_priv),
2836 "dtim_assoc", &var);
2837 if (unlikely(err)) {
2838 WL_ERR("wl dtim_assoc failed (%d)\n", err);
2839 goto update_bss_info_out;
2840 }
2841 dtim_period = (u8)var;
2842 }
2843
2844 brcmf_update_prof(cfg_priv, NULL, &beacon_interval, WL_PROF_BEACONINT);
2845 brcmf_update_prof(cfg_priv, NULL, &dtim_period, WL_PROF_DTIMPERIOD);
2846
2847 update_bss_info_out:
2848 WL_TRACE("Exit");
2849 return err;
2850 }
2851
2852 static s32
2853 brcmf_bss_roaming_done(struct brcmf_cfg80211_priv *cfg_priv,
2854 struct net_device *ndev,
2855 const struct brcmf_event_msg *e)
2856 {
2857 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2858 struct wiphy *wiphy = cfg_to_wiphy(cfg_priv);
2859 struct brcmf_channel_info channel;
2860 struct ieee80211_channel *notify_channel;
2861 struct ieee80211_supported_band *band;
2862 u32 freq;
2863 s32 err = 0;
2864
2865 WL_TRACE("Enter\n");
2866
2867 brcmf_get_assoc_ies(cfg_priv);
2868 brcmf_update_prof(cfg_priv, NULL, &e->addr, WL_PROF_BSSID);
2869 brcmf_update_bss_info(cfg_priv);
2870
2871 brcmf_dev_ioctl(ndev, BRCMF_C_GET_CHANNEL, &channel, sizeof(channel));
2872
2873 channel.target_channel = le32_to_cpu(channel.target_channel);
2874 WL_CONN("Roamed to channel %d\n", channel.target_channel);
2875
2876 if (channel.target_channel <= CH_MAX_2G_CHANNEL)
2877 band = wiphy->bands[IEEE80211_BAND_2GHZ];
2878 else
2879 band = wiphy->bands[IEEE80211_BAND_5GHZ];
2880
2881 freq = ieee80211_channel_to_frequency(channel.target_channel,
2882 band->band);
2883 notify_channel = ieee80211_get_channel(wiphy, freq);
2884
2885 cfg80211_roamed(ndev, notify_channel,
2886 (u8 *)brcmf_read_prof(cfg_priv, WL_PROF_BSSID),
2887 conn_info->req_ie, conn_info->req_ie_len,
2888 conn_info->resp_ie, conn_info->resp_ie_len, GFP_KERNEL);
2889 WL_CONN("Report roaming result\n");
2890
2891 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
2892 WL_TRACE("Exit\n");
2893 return err;
2894 }
2895
2896 static s32
2897 brcmf_bss_connect_done(struct brcmf_cfg80211_priv *cfg_priv,
2898 struct net_device *ndev, const struct brcmf_event_msg *e,
2899 bool completed)
2900 {
2901 struct brcmf_cfg80211_connect_info *conn_info = cfg_to_conn(cfg_priv);
2902 s32 err = 0;
2903
2904 WL_TRACE("Enter\n");
2905
2906 if (test_and_clear_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) {
2907 if (completed) {
2908 brcmf_get_assoc_ies(cfg_priv);
2909 brcmf_update_prof(cfg_priv, NULL, &e->addr,
2910 WL_PROF_BSSID);
2911 brcmf_update_bss_info(cfg_priv);
2912 }
2913 cfg80211_connect_result(ndev,
2914 (u8 *)brcmf_read_prof(cfg_priv,
2915 WL_PROF_BSSID),
2916 conn_info->req_ie,
2917 conn_info->req_ie_len,
2918 conn_info->resp_ie,
2919 conn_info->resp_ie_len,
2920 completed ? WLAN_STATUS_SUCCESS :
2921 WLAN_STATUS_AUTH_TIMEOUT,
2922 GFP_KERNEL);
2923 if (completed)
2924 set_bit(WL_STATUS_CONNECTED, &cfg_priv->status);
2925 WL_CONN("Report connect result - connection %s\n",
2926 completed ? "succeeded" : "failed");
2927 }
2928 WL_TRACE("Exit\n");
2929 return err;
2930 }
2931
2932 static s32
2933 brcmf_notify_mic_status(struct brcmf_cfg80211_priv *cfg_priv,
2934 struct net_device *ndev,
2935 const struct brcmf_event_msg *e, void *data)
2936 {
2937 u16 flags = be16_to_cpu(e->flags);
2938 enum nl80211_key_type key_type;
2939
2940 rtnl_lock();
2941 if (flags & BRCMF_EVENT_MSG_GROUP)
2942 key_type = NL80211_KEYTYPE_GROUP;
2943 else
2944 key_type = NL80211_KEYTYPE_PAIRWISE;
2945
2946 cfg80211_michael_mic_failure(ndev, (u8 *)&e->addr, key_type, -1,
2947 NULL, GFP_KERNEL);
2948 rtnl_unlock();
2949
2950 return 0;
2951 }
2952
2953 static s32
2954 brcmf_notify_scan_status(struct brcmf_cfg80211_priv *cfg_priv,
2955 struct net_device *ndev,
2956 const struct brcmf_event_msg *e, void *data)
2957 {
2958 struct brcmf_channel_info channel_inform;
2959 struct brcmf_scan_results *bss_list;
2960 u32 len = WL_SCAN_BUF_MAX;
2961 s32 err = 0;
2962 bool scan_abort = false;
2963
2964 WL_TRACE("Enter\n");
2965
2966 if (cfg_priv->iscan_on && cfg_priv->iscan_kickstart) {
2967 WL_TRACE("Exit\n");
2968 return brcmf_wakeup_iscan(cfg_to_iscan(cfg_priv));
2969 }
2970
2971 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING,
2972 &cfg_priv->status))) {
2973 WL_ERR("Scan complete while device not scanning\n");
2974 scan_abort = true;
2975 err = -EINVAL;
2976 goto scan_done_out;
2977 }
2978
2979 err = brcmf_dev_ioctl(ndev, BRCMF_C_GET_CHANNEL, &channel_inform,
2980 sizeof(channel_inform));
2981 if (unlikely(err)) {
2982 WL_ERR("scan busy (%d)\n", err);
2983 scan_abort = true;
2984 goto scan_done_out;
2985 }
2986 channel_inform.scan_channel = le32_to_cpu(channel_inform.scan_channel);
2987 if (unlikely(channel_inform.scan_channel)) {
2988
2989 WL_CONN("channel_inform.scan_channel (%d)\n",
2990 channel_inform.scan_channel);
2991 }
2992 cfg_priv->bss_list = cfg_priv->scan_results;
2993 bss_list = cfg_priv->bss_list;
2994 memset(bss_list, 0, len);
2995 bss_list->buflen = cpu_to_le32(len);
2996
2997 err = brcmf_dev_ioctl(ndev, BRCMF_C_SCAN_RESULTS, bss_list, len);
2998 if (unlikely(err)) {
2999 WL_ERR("%s Scan_results error (%d)\n", ndev->name, err);
3000 err = -EINVAL;
3001 scan_abort = true;
3002 goto scan_done_out;
3003 }
3004 bss_list->buflen = le32_to_cpu(bss_list->buflen);
3005 bss_list->version = le32_to_cpu(bss_list->version);
3006 bss_list->count = le32_to_cpu(bss_list->count);
3007
3008 err = brcmf_inform_bss(cfg_priv);
3009 if (err) {
3010 scan_abort = true;
3011 goto scan_done_out;
3012 }
3013
3014 scan_done_out:
3015 if (cfg_priv->scan_request) {
3016 WL_SCAN("calling cfg80211_scan_done\n");
3017 cfg80211_scan_done(cfg_priv->scan_request, scan_abort);
3018 brcmf_set_mpc(ndev, 1);
3019 cfg_priv->scan_request = NULL;
3020 }
3021
3022 WL_TRACE("Exit\n");
3023
3024 return err;
3025 }
3026
3027 static void brcmf_init_conf(struct brcmf_cfg80211_conf *conf)
3028 {
3029 conf->mode = (u32)-1;
3030 conf->frag_threshold = (u32)-1;
3031 conf->rts_threshold = (u32)-1;
3032 conf->retry_short = (u32)-1;
3033 conf->retry_long = (u32)-1;
3034 conf->tx_power = -1;
3035 }
3036
3037 static void brcmf_init_prof(struct brcmf_cfg80211_profile *prof)
3038 {
3039 memset(prof, 0, sizeof(*prof));
3040 }
3041
3042 static void brcmf_init_eloop_handler(struct brcmf_cfg80211_event_loop *el)
3043 {
3044 memset(el, 0, sizeof(*el));
3045 el->handler[BRCMF_E_SCAN_COMPLETE] = brcmf_notify_scan_status;
3046 el->handler[BRCMF_E_LINK] = brcmf_notify_connect_status;
3047 el->handler[BRCMF_E_ROAM] = brcmf_notify_roaming_status;
3048 el->handler[BRCMF_E_MIC_ERROR] = brcmf_notify_mic_status;
3049 el->handler[BRCMF_E_SET_SSID] = brcmf_notify_connect_status;
3050 }
3051
3052 static s32 brcmf_init_priv_mem(struct brcmf_cfg80211_priv *cfg_priv)
3053 {
3054 cfg_priv->scan_results = kzalloc(WL_SCAN_BUF_MAX, GFP_KERNEL);
3055 if (unlikely(!cfg_priv->scan_results)) {
3056 WL_ERR("Scan results alloc failed\n");
3057 goto init_priv_mem_out;
3058 }
3059 cfg_priv->conf = kzalloc(sizeof(*cfg_priv->conf), GFP_KERNEL);
3060 if (unlikely(!cfg_priv->conf)) {
3061 WL_ERR("wl_conf alloc failed\n");
3062 goto init_priv_mem_out;
3063 }
3064 cfg_priv->profile = kzalloc(sizeof(*cfg_priv->profile), GFP_KERNEL);
3065 if (unlikely(!cfg_priv->profile)) {
3066 WL_ERR("wl_profile alloc failed\n");
3067 goto init_priv_mem_out;
3068 }
3069 cfg_priv->bss_info = kzalloc(WL_BSS_INFO_MAX, GFP_KERNEL);
3070 if (unlikely(!cfg_priv->bss_info)) {
3071 WL_ERR("Bss information alloc failed\n");
3072 goto init_priv_mem_out;
3073 }
3074 cfg_priv->scan_req_int = kzalloc(sizeof(*cfg_priv->scan_req_int),
3075 GFP_KERNEL);
3076 if (unlikely(!cfg_priv->scan_req_int)) {
3077 WL_ERR("Scan req alloc failed\n");
3078 goto init_priv_mem_out;
3079 }
3080 cfg_priv->ioctl_buf = kzalloc(WL_IOCTL_LEN_MAX, GFP_KERNEL);
3081 if (unlikely(!cfg_priv->ioctl_buf)) {
3082 WL_ERR("Ioctl buf alloc failed\n");
3083 goto init_priv_mem_out;
3084 }
3085 cfg_priv->extra_buf = kzalloc(WL_EXTRA_BUF_MAX, GFP_KERNEL);
3086 if (unlikely(!cfg_priv->extra_buf)) {
3087 WL_ERR("Extra buf alloc failed\n");
3088 goto init_priv_mem_out;
3089 }
3090 cfg_priv->iscan = kzalloc(sizeof(*cfg_priv->iscan), GFP_KERNEL);
3091 if (unlikely(!cfg_priv->iscan)) {
3092 WL_ERR("Iscan buf alloc failed\n");
3093 goto init_priv_mem_out;
3094 }
3095 cfg_priv->pmk_list = kzalloc(sizeof(*cfg_priv->pmk_list), GFP_KERNEL);
3096 if (unlikely(!cfg_priv->pmk_list)) {
3097 WL_ERR("pmk list alloc failed\n");
3098 goto init_priv_mem_out;
3099 }
3100
3101 return 0;
3102
3103 init_priv_mem_out:
3104 brcmf_deinit_priv_mem(cfg_priv);
3105
3106 return -ENOMEM;
3107 }
3108
3109 static void brcmf_deinit_priv_mem(struct brcmf_cfg80211_priv *cfg_priv)
3110 {
3111 kfree(cfg_priv->scan_results);
3112 cfg_priv->scan_results = NULL;
3113 kfree(cfg_priv->bss_info);
3114 cfg_priv->bss_info = NULL;
3115 kfree(cfg_priv->conf);
3116 cfg_priv->conf = NULL;
3117 kfree(cfg_priv->profile);
3118 cfg_priv->profile = NULL;
3119 kfree(cfg_priv->scan_req_int);
3120 cfg_priv->scan_req_int = NULL;
3121 kfree(cfg_priv->ioctl_buf);
3122 cfg_priv->ioctl_buf = NULL;
3123 kfree(cfg_priv->extra_buf);
3124 cfg_priv->extra_buf = NULL;
3125 kfree(cfg_priv->iscan);
3126 cfg_priv->iscan = NULL;
3127 kfree(cfg_priv->pmk_list);
3128 cfg_priv->pmk_list = NULL;
3129 }
3130
3131 static s32 brcmf_create_event_handler(struct brcmf_cfg80211_priv *cfg_priv)
3132 {
3133 init_waitqueue_head(&cfg_priv->event_waitq);
3134 cfg_priv->event_tsk = kthread_run(brcmf_event_handler, cfg_priv,
3135 "wl_event_handler");
3136 if (IS_ERR(cfg_priv->event_tsk)) {
3137 cfg_priv->event_tsk = NULL;
3138 WL_ERR("failed to create event thread\n");
3139 return -ENOMEM;
3140 }
3141 return 0;
3142 }
3143
3144 static void brcmf_destroy_event_handler(struct brcmf_cfg80211_priv *cfg_priv)
3145 {
3146 if (cfg_priv->event_tsk) {
3147 send_sig(SIGTERM, cfg_priv->event_tsk, 1);
3148 kthread_stop(cfg_priv->event_tsk);
3149 cfg_priv->event_tsk = NULL;
3150 }
3151 }
3152
3153 static void brcmf_term_iscan(struct brcmf_cfg80211_priv *cfg_priv)
3154 {
3155 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
3156 struct brcmf_ssid ssid;
3157
3158 if (cfg_priv->iscan_on && iscan->tsk) {
3159 iscan->state = WL_ISCAN_STATE_IDLE;
3160 send_sig(SIGTERM, iscan->tsk, 1);
3161
3162 /*
3163 * The iscan task may want to acquire the rtnl_lock
3164 * so release it here upon stopping the task.
3165 */
3166 rtnl_unlock();
3167 kthread_stop(iscan->tsk);
3168 rtnl_lock();
3169 iscan->tsk = NULL;
3170
3171 /* Abort iscan running in FW */
3172 memset(&ssid, 0, sizeof(ssid));
3173 brcmf_run_iscan(iscan, &ssid, WL_SCAN_ACTION_ABORT);
3174 }
3175 }
3176
3177 static void brcmf_notify_iscan_complete(struct brcmf_cfg80211_iscan_ctrl *iscan,
3178 bool aborted)
3179 {
3180 struct brcmf_cfg80211_priv *cfg_priv = iscan_to_cfg(iscan);
3181 struct net_device *ndev = cfg_to_ndev(cfg_priv);
3182
3183 if (unlikely(!test_and_clear_bit(WL_STATUS_SCANNING,
3184 &cfg_priv->status))) {
3185 WL_ERR("Scan complete while device not scanning\n");
3186 return;
3187 }
3188 if (likely(cfg_priv->scan_request)) {
3189 WL_SCAN("ISCAN Completed scan: %s\n",
3190 aborted ? "Aborted" : "Done");
3191 cfg80211_scan_done(cfg_priv->scan_request, aborted);
3192 brcmf_set_mpc(ndev, 1);
3193 cfg_priv->scan_request = NULL;
3194 }
3195 cfg_priv->iscan_kickstart = false;
3196 }
3197
3198 static s32 brcmf_wakeup_iscan(struct brcmf_cfg80211_iscan_ctrl *iscan)
3199 {
3200 if (likely(iscan->state != WL_ISCAN_STATE_IDLE)) {
3201 WL_SCAN("wake up iscan\n");
3202 wake_up(&iscan->waitq);
3203 return 0;
3204 }
3205
3206 return -EIO;
3207 }
3208
3209 static s32
3210 brcmf_get_iscan_results(struct brcmf_cfg80211_iscan_ctrl *iscan, u32 *status,
3211 struct brcmf_scan_results **bss_list)
3212 {
3213 struct brcmf_iscan_results list;
3214 struct brcmf_scan_results *results;
3215 struct brcmf_iscan_results *list_buf;
3216 s32 err = 0;
3217
3218 memset(iscan->scan_buf, 0, WL_ISCAN_BUF_MAX);
3219 list_buf = (struct brcmf_iscan_results *)iscan->scan_buf;
3220 results = &list_buf->results;
3221 results->buflen = BRCMF_ISCAN_RESULTS_FIXED_SIZE;
3222 results->version = 0;
3223 results->count = 0;
3224
3225 memset(&list, 0, sizeof(list));
3226 list.results.buflen = cpu_to_le32(WL_ISCAN_BUF_MAX);
3227 err = brcmf_dev_iovar_getbuf(iscan->dev, "iscanresults", &list,
3228 BRCMF_ISCAN_RESULTS_FIXED_SIZE, iscan->scan_buf,
3229 WL_ISCAN_BUF_MAX);
3230 if (unlikely(err)) {
3231 WL_ERR("error (%d)\n", err);
3232 return err;
3233 }
3234 results->buflen = le32_to_cpu(results->buflen);
3235 results->version = le32_to_cpu(results->version);
3236 results->count = le32_to_cpu(results->count);
3237 WL_SCAN("results->count = %d\n", results->count);
3238 WL_SCAN("results->buflen = %d\n", results->buflen);
3239 *status = le32_to_cpu(list_buf->status);
3240 WL_SCAN("status = %d\n", *status);
3241 *bss_list = results;
3242
3243 return err;
3244 }
3245
3246 static s32 brcmf_iscan_done(struct brcmf_cfg80211_priv *cfg_priv)
3247 {
3248 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
3249 s32 err = 0;
3250
3251 iscan->state = WL_ISCAN_STATE_IDLE;
3252 rtnl_lock();
3253 brcmf_inform_bss(cfg_priv);
3254 brcmf_notify_iscan_complete(iscan, false);
3255 rtnl_unlock();
3256
3257 return err;
3258 }
3259
3260 static s32 brcmf_iscan_pending(struct brcmf_cfg80211_priv *cfg_priv)
3261 {
3262 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
3263 s32 err = 0;
3264
3265 /* Reschedule the timer */
3266 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3267 iscan->timer_on = 1;
3268
3269 return err;
3270 }
3271
3272 static s32 brcmf_iscan_inprogress(struct brcmf_cfg80211_priv *cfg_priv)
3273 {
3274 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
3275 s32 err = 0;
3276
3277 rtnl_lock();
3278 brcmf_inform_bss(cfg_priv);
3279 brcmf_run_iscan(iscan, NULL, BRCMF_SCAN_ACTION_CONTINUE);
3280 rtnl_unlock();
3281 /* Reschedule the timer */
3282 mod_timer(&iscan->timer, jiffies + iscan->timer_ms * HZ / 1000);
3283 iscan->timer_on = 1;
3284
3285 return err;
3286 }
3287
3288 static s32 brcmf_iscan_aborted(struct brcmf_cfg80211_priv *cfg_priv)
3289 {
3290 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_priv->iscan;
3291 s32 err = 0;
3292
3293 iscan->state = WL_ISCAN_STATE_IDLE;
3294 rtnl_lock();
3295 brcmf_notify_iscan_complete(iscan, true);
3296 rtnl_unlock();
3297
3298 return err;
3299 }
3300
3301 static s32 brcmf_iscan_thread(void *data)
3302 {
3303 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3304 struct brcmf_cfg80211_iscan_ctrl *iscan =
3305 (struct brcmf_cfg80211_iscan_ctrl *)data;
3306 struct brcmf_cfg80211_priv *cfg_priv = iscan_to_cfg(iscan);
3307 struct brcmf_cfg80211_iscan_eloop *el = &iscan->el;
3308 DECLARE_WAITQUEUE(wait, current);
3309 u32 status;
3310 int err = 0;
3311
3312 sched_setscheduler(current, SCHED_FIFO, &param);
3313 allow_signal(SIGTERM);
3314 status = BRCMF_SCAN_RESULTS_PARTIAL;
3315 add_wait_queue(&iscan->waitq, &wait);
3316 while (1) {
3317 prepare_to_wait(&iscan->waitq, &wait, TASK_INTERRUPTIBLE);
3318
3319 schedule();
3320
3321 if (kthread_should_stop())
3322 break;
3323 if (iscan->timer_on) {
3324 del_timer_sync(&iscan->timer);
3325 iscan->timer_on = 0;
3326 }
3327 rtnl_lock();
3328 err = brcmf_get_iscan_results(iscan, &status,
3329 &cfg_priv->bss_list);
3330 if (unlikely(err)) {
3331 status = BRCMF_SCAN_RESULTS_ABORTED;
3332 WL_ERR("Abort iscan\n");
3333 }
3334 rtnl_unlock();
3335 el->handler[status](cfg_priv);
3336 }
3337 finish_wait(&iscan->waitq, &wait);
3338 if (iscan->timer_on) {
3339 del_timer_sync(&iscan->timer);
3340 iscan->timer_on = 0;
3341 }
3342 WL_SCAN("ISCAN thread terminated\n");
3343
3344 return 0;
3345 }
3346
3347 static void brcmf_iscan_timer(unsigned long data)
3348 {
3349 struct brcmf_cfg80211_iscan_ctrl *iscan =
3350 (struct brcmf_cfg80211_iscan_ctrl *)data;
3351
3352 if (iscan) {
3353 iscan->timer_on = 0;
3354 WL_SCAN("timer expired\n");
3355 brcmf_wakeup_iscan(iscan);
3356 }
3357 }
3358
3359 static s32 brcmf_invoke_iscan(struct brcmf_cfg80211_priv *cfg_priv)
3360 {
3361 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
3362
3363 if (cfg_priv->iscan_on && !iscan->tsk) {
3364 iscan->state = WL_ISCAN_STATE_IDLE;
3365 init_waitqueue_head(&iscan->waitq);
3366 iscan->tsk = kthread_run(brcmf_iscan_thread, iscan, "wl_iscan");
3367 if (IS_ERR(iscan->tsk)) {
3368 WL_ERR("Could not create iscan thread\n");
3369 iscan->tsk = NULL;
3370 return -ENOMEM;
3371 }
3372 }
3373
3374 return 0;
3375 }
3376
3377 static void brcmf_init_iscan_eloop(struct brcmf_cfg80211_iscan_eloop *el)
3378 {
3379 memset(el, 0, sizeof(*el));
3380 el->handler[BRCMF_SCAN_RESULTS_SUCCESS] = brcmf_iscan_done;
3381 el->handler[BRCMF_SCAN_RESULTS_PARTIAL] = brcmf_iscan_inprogress;
3382 el->handler[BRCMF_SCAN_RESULTS_PENDING] = brcmf_iscan_pending;
3383 el->handler[BRCMF_SCAN_RESULTS_ABORTED] = brcmf_iscan_aborted;
3384 el->handler[BRCMF_SCAN_RESULTS_NO_MEM] = brcmf_iscan_aborted;
3385 }
3386
3387 static s32 brcmf_init_iscan(struct brcmf_cfg80211_priv *cfg_priv)
3388 {
3389 struct brcmf_cfg80211_iscan_ctrl *iscan = cfg_to_iscan(cfg_priv);
3390 int err = 0;
3391
3392 if (cfg_priv->iscan_on) {
3393 iscan->dev = cfg_to_ndev(cfg_priv);
3394 brcmf_init_iscan_eloop(&iscan->el);
3395 iscan->timer_ms = WL_ISCAN_TIMER_INTERVAL_MS;
3396 init_timer(&iscan->timer);
3397 iscan->timer.data = (unsigned long) iscan;
3398 iscan->timer.function = brcmf_iscan_timer;
3399 err = brcmf_invoke_iscan(cfg_priv);
3400 if (!err)
3401 iscan->data = cfg_priv;
3402 }
3403
3404 return err;
3405 }
3406
3407 static s32 wl_init_priv(struct brcmf_cfg80211_priv *cfg_priv)
3408 {
3409 s32 err = 0;
3410
3411 cfg_priv->scan_request = NULL;
3412 #ifndef WL_POWERSAVE_DISABLED
3413 cfg_priv->pwr_save = true;
3414 #endif /* WL_POWERSAVE_DISABLED */
3415 cfg_priv->iscan_on = true; /* iscan on & off switch.
3416 we enable iscan per default */
3417 cfg_priv->roam_on = true; /* roam on & off switch.
3418 we enable roam per default */
3419
3420 cfg_priv->iscan_kickstart = false;
3421 cfg_priv->active_scan = true; /* we do active scan for
3422 specific scan per default */
3423 cfg_priv->dongle_up = false; /* dongle is not up yet */
3424 brcmf_init_eq(cfg_priv);
3425 err = brcmf_init_priv_mem(cfg_priv);
3426 if (unlikely(err))
3427 return err;
3428 if (unlikely(brcmf_create_event_handler(cfg_priv)))
3429 return -ENOMEM;
3430 brcmf_init_eloop_handler(&cfg_priv->el);
3431 mutex_init(&cfg_priv->usr_sync);
3432 err = brcmf_init_iscan(cfg_priv);
3433 if (unlikely(err))
3434 return err;
3435 brcmf_init_conf(cfg_priv->conf);
3436 brcmf_init_prof(cfg_priv->profile);
3437 brcmf_link_down(cfg_priv);
3438
3439 return err;
3440 }
3441
3442 static void wl_deinit_priv(struct brcmf_cfg80211_priv *cfg_priv)
3443 {
3444 brcmf_destroy_event_handler(cfg_priv);
3445 cfg_priv->dongle_up = false; /* dongle down */
3446 brcmf_flush_eq(cfg_priv);
3447 brcmf_link_down(cfg_priv);
3448 brcmf_term_iscan(cfg_priv);
3449 brcmf_deinit_priv_mem(cfg_priv);
3450 }
3451
3452 s32 brcmf_cfg80211_attach(struct net_device *ndev, void *data)
3453 {
3454 struct wireless_dev *wdev;
3455 struct brcmf_cfg80211_priv *cfg_priv;
3456 struct brcmf_cfg80211_iface *ci;
3457 s32 err = 0;
3458
3459 if (unlikely(!ndev)) {
3460 WL_ERR("ndev is invalid\n");
3461 return -ENODEV;
3462 }
3463 cfg80211_dev = kzalloc(sizeof(struct brcmf_cfg80211_dev), GFP_KERNEL);
3464 if (unlikely(!cfg80211_dev)) {
3465 WL_ERR("wl_cfg80211_dev is invalid\n");
3466 return -ENOMEM;
3467 }
3468 WL_INFO("func %p\n", brcmf_cfg80211_get_sdio_func());
3469 wdev = brcmf_alloc_wdev(sizeof(struct brcmf_cfg80211_iface),
3470 &brcmf_cfg80211_get_sdio_func()->dev);
3471 if (IS_ERR(wdev))
3472 return -ENOMEM;
3473
3474 wdev->iftype = brcmf_mode_to_nl80211_iftype(WL_MODE_BSS);
3475 cfg_priv = wdev_to_cfg(wdev);
3476 cfg_priv->wdev = wdev;
3477 cfg_priv->pub = data;
3478 ci = (struct brcmf_cfg80211_iface *)&cfg_priv->ci;
3479 ci->cfg_priv = cfg_priv;
3480 ndev->ieee80211_ptr = wdev;
3481 SET_NETDEV_DEV(ndev, wiphy_dev(wdev->wiphy));
3482 wdev->netdev = ndev;
3483 err = wl_init_priv(cfg_priv);
3484 if (unlikely(err)) {
3485 WL_ERR("Failed to init iwm_priv (%d)\n", err);
3486 goto cfg80211_attach_out;
3487 }
3488 brcmf_set_drvdata(cfg80211_dev, ci);
3489
3490 return err;
3491
3492 cfg80211_attach_out:
3493 brcmf_free_wdev(cfg_priv);
3494 return err;
3495 }
3496
3497 void brcmf_cfg80211_detach(void)
3498 {
3499 struct brcmf_cfg80211_priv *cfg_priv;
3500
3501 cfg_priv = WL_PRIV_GET();
3502
3503 wl_deinit_priv(cfg_priv);
3504 brcmf_free_wdev(cfg_priv);
3505 brcmf_set_drvdata(cfg80211_dev, NULL);
3506 kfree(cfg80211_dev);
3507 cfg80211_dev = NULL;
3508 brcmf_clear_sdio_func();
3509 }
3510
3511 static void brcmf_wakeup_event(struct brcmf_cfg80211_priv *cfg_priv)
3512 {
3513 wake_up(&cfg_priv->event_waitq);
3514 }
3515
3516 static s32 brcmf_event_handler(void *data)
3517 {
3518 struct brcmf_cfg80211_priv *cfg_priv =
3519 (struct brcmf_cfg80211_priv *)data;
3520 struct sched_param param = {.sched_priority = MAX_RT_PRIO - 1 };
3521 struct brcmf_cfg80211_event_q *e;
3522 DECLARE_WAITQUEUE(wait, current);
3523
3524 sched_setscheduler(current, SCHED_FIFO, &param);
3525 allow_signal(SIGTERM);
3526 add_wait_queue(&cfg_priv->event_waitq, &wait);
3527 while (1) {
3528 prepare_to_wait(&cfg_priv->event_waitq, &wait,
3529 TASK_INTERRUPTIBLE);
3530
3531 schedule();
3532
3533 if (kthread_should_stop())
3534 break;
3535
3536 e = brcmf_deq_event(cfg_priv);
3537 if (unlikely(!e)) {
3538 WL_ERR("event queue empty...\n");
3539 continue;
3540 }
3541
3542 do {
3543 WL_INFO("event type (%d)\n", e->etype);
3544 if (cfg_priv->el.handler[e->etype])
3545 cfg_priv->el.handler[e->etype](cfg_priv,
3546 cfg_to_ndev(cfg_priv),
3547 &e->emsg, e->edata);
3548 else
3549 WL_INFO("Unknown Event (%d): ignoring\n",
3550 e->etype);
3551 brcmf_put_event(e);
3552 } while ((e = brcmf_deq_event(cfg_priv)));
3553 }
3554 finish_wait(&cfg_priv->event_waitq, &wait);
3555 WL_INFO("was terminated\n");
3556 return 0;
3557 }
3558
3559 void
3560 brcmf_cfg80211_event(struct net_device *ndev,
3561 const struct brcmf_event_msg *e, void *data)
3562 {
3563 u32 event_type = be32_to_cpu(e->event_type);
3564 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
3565
3566 if (likely(!brcmf_enq_event(cfg_priv, event_type, e)))
3567 brcmf_wakeup_event(cfg_priv);
3568 }
3569
3570 static void brcmf_init_eq(struct brcmf_cfg80211_priv *cfg_priv)
3571 {
3572 brcmf_init_eq_lock(cfg_priv);
3573 INIT_LIST_HEAD(&cfg_priv->eq_list);
3574 }
3575
3576 static void brcmf_flush_eq(struct brcmf_cfg80211_priv *cfg_priv)
3577 {
3578 struct brcmf_cfg80211_event_q *e;
3579
3580 brcmf_lock_eq(cfg_priv);
3581 while (!list_empty(&cfg_priv->eq_list)) {
3582 e = list_first_entry(&cfg_priv->eq_list,
3583 struct brcmf_cfg80211_event_q, eq_list);
3584 list_del(&e->eq_list);
3585 kfree(e);
3586 }
3587 brcmf_unlock_eq(cfg_priv);
3588 }
3589
3590 /*
3591 * retrieve first queued event from head
3592 */
3593
3594 static struct brcmf_cfg80211_event_q *brcmf_deq_event(
3595 struct brcmf_cfg80211_priv *cfg_priv)
3596 {
3597 struct brcmf_cfg80211_event_q *e = NULL;
3598
3599 brcmf_lock_eq(cfg_priv);
3600 if (likely(!list_empty(&cfg_priv->eq_list))) {
3601 e = list_first_entry(&cfg_priv->eq_list,
3602 struct brcmf_cfg80211_event_q, eq_list);
3603 list_del(&e->eq_list);
3604 }
3605 brcmf_unlock_eq(cfg_priv);
3606
3607 return e;
3608 }
3609
3610 /*
3611 ** push event to tail of the queue
3612 */
3613
3614 static s32
3615 brcmf_enq_event(struct brcmf_cfg80211_priv *cfg_priv, u32 event,
3616 const struct brcmf_event_msg *msg)
3617 {
3618 struct brcmf_cfg80211_event_q *e;
3619 s32 err = 0;
3620
3621 e = kzalloc(sizeof(struct brcmf_cfg80211_event_q), GFP_KERNEL);
3622 if (unlikely(!e)) {
3623 WL_ERR("event alloc failed\n");
3624 return -ENOMEM;
3625 }
3626
3627 e->etype = event;
3628 memcpy(&e->emsg, msg, sizeof(struct brcmf_event_msg));
3629
3630 brcmf_lock_eq(cfg_priv);
3631 list_add_tail(&e->eq_list, &cfg_priv->eq_list);
3632 brcmf_unlock_eq(cfg_priv);
3633
3634 return err;
3635 }
3636
3637 static void brcmf_put_event(struct brcmf_cfg80211_event_q *e)
3638 {
3639 kfree(e);
3640 }
3641
3642 void brcmf_cfg80211_sdio_func(void *func)
3643 {
3644 cfg80211_sdio_func = (struct sdio_func *)func;
3645 }
3646
3647 static void brcmf_clear_sdio_func(void)
3648 {
3649 cfg80211_sdio_func = NULL;
3650 }
3651
3652 struct sdio_func *brcmf_cfg80211_get_sdio_func(void)
3653 {
3654 return cfg80211_sdio_func;
3655 }
3656
3657 static s32 brcmf_dongle_mode(struct net_device *ndev, s32 iftype)
3658 {
3659 s32 infra = 0;
3660 s32 err = 0;
3661
3662 switch (iftype) {
3663 case NL80211_IFTYPE_MONITOR:
3664 case NL80211_IFTYPE_WDS:
3665 WL_ERR("type (%d) : currently we do not support this mode\n",
3666 iftype);
3667 err = -EINVAL;
3668 return err;
3669 case NL80211_IFTYPE_ADHOC:
3670 infra = 0;
3671 break;
3672 case NL80211_IFTYPE_STATION:
3673 infra = 1;
3674 break;
3675 default:
3676 err = -EINVAL;
3677 WL_ERR("invalid type (%d)\n", iftype);
3678 return err;
3679 }
3680 infra = cpu_to_le32(infra);
3681 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_INFRA, &infra, sizeof(infra));
3682 if (unlikely(err)) {
3683 WL_ERR("WLC_SET_INFRA error (%d)\n", err);
3684 return err;
3685 }
3686
3687 return 0;
3688 }
3689
3690 static s32 brcmf_dongle_eventmsg(struct net_device *ndev)
3691 {
3692 /* Room for "event_msgs" + '\0' + bitvec */
3693 s8 iovbuf[BRCMF_EVENTING_MASK_LEN + 12];
3694 s8 eventmask[BRCMF_EVENTING_MASK_LEN];
3695 s32 err = 0;
3696
3697 WL_TRACE("Enter\n");
3698
3699 /* Setup event_msgs */
3700 brcmu_mkiovar("event_msgs", eventmask, BRCMF_EVENTING_MASK_LEN, iovbuf,
3701 sizeof(iovbuf));
3702 err = brcmf_dev_ioctl(ndev, BRCMF_C_GET_VAR, iovbuf, sizeof(iovbuf));
3703 if (unlikely(err)) {
3704 WL_ERR("Get event_msgs error (%d)\n", err);
3705 goto dongle_eventmsg_out;
3706 }
3707 memcpy(eventmask, iovbuf, BRCMF_EVENTING_MASK_LEN);
3708
3709 setbit(eventmask, BRCMF_E_SET_SSID);
3710 setbit(eventmask, BRCMF_E_ROAM);
3711 setbit(eventmask, BRCMF_E_PRUNE);
3712 setbit(eventmask, BRCMF_E_AUTH);
3713 setbit(eventmask, BRCMF_E_REASSOC);
3714 setbit(eventmask, BRCMF_E_REASSOC_IND);
3715 setbit(eventmask, BRCMF_E_DEAUTH_IND);
3716 setbit(eventmask, BRCMF_E_DISASSOC_IND);
3717 setbit(eventmask, BRCMF_E_DISASSOC);
3718 setbit(eventmask, BRCMF_E_JOIN);
3719 setbit(eventmask, BRCMF_E_ASSOC_IND);
3720 setbit(eventmask, BRCMF_E_PSK_SUP);
3721 setbit(eventmask, BRCMF_E_LINK);
3722 setbit(eventmask, BRCMF_E_NDIS_LINK);
3723 setbit(eventmask, BRCMF_E_MIC_ERROR);
3724 setbit(eventmask, BRCMF_E_PMKID_CACHE);
3725 setbit(eventmask, BRCMF_E_TXFAIL);
3726 setbit(eventmask, BRCMF_E_JOIN_START);
3727 setbit(eventmask, BRCMF_E_SCAN_COMPLETE);
3728
3729 brcmu_mkiovar("event_msgs", eventmask, BRCMF_EVENTING_MASK_LEN, iovbuf,
3730 sizeof(iovbuf));
3731 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3732 if (unlikely(err)) {
3733 WL_ERR("Set event_msgs error (%d)\n", err);
3734 goto dongle_eventmsg_out;
3735 }
3736
3737 dongle_eventmsg_out:
3738 WL_TRACE("Exit\n");
3739 return err;
3740 }
3741
3742 static s32
3743 brcmf_dongle_roam(struct net_device *ndev, u32 roamvar, u32 bcn_timeout)
3744 {
3745 s8 iovbuf[32];
3746 s32 roamtrigger[2];
3747 s32 roam_delta[2];
3748 s32 err = 0;
3749
3750 /*
3751 * Setup timeout if Beacons are lost and roam is
3752 * off to report link down
3753 */
3754 if (roamvar) {
3755 brcmu_mkiovar("bcn_timeout", (char *)&bcn_timeout,
3756 sizeof(bcn_timeout), iovbuf, sizeof(iovbuf));
3757 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_VAR,
3758 iovbuf, sizeof(iovbuf));
3759 if (unlikely(err)) {
3760 WL_ERR("bcn_timeout error (%d)\n", err);
3761 goto dongle_rom_out;
3762 }
3763 }
3764
3765 /*
3766 * Enable/Disable built-in roaming to allow supplicant
3767 * to take care of roaming
3768 */
3769 WL_INFO("Internal Roaming = %s\n", roamvar ? "Off" : "On");
3770 brcmu_mkiovar("roam_off", (char *)&roamvar,
3771 sizeof(roamvar), iovbuf, sizeof(iovbuf));
3772 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_VAR, iovbuf, sizeof(iovbuf));
3773 if (unlikely(err)) {
3774 WL_ERR("roam_off error (%d)\n", err);
3775 goto dongle_rom_out;
3776 }
3777
3778 roamtrigger[0] = WL_ROAM_TRIGGER_LEVEL;
3779 roamtrigger[1] = BRCM_BAND_ALL;
3780 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_ROAM_TRIGGER,
3781 (void *)roamtrigger, sizeof(roamtrigger));
3782 if (unlikely(err)) {
3783 WL_ERR("WLC_SET_ROAM_TRIGGER error (%d)\n", err);
3784 goto dongle_rom_out;
3785 }
3786
3787 roam_delta[0] = WL_ROAM_DELTA;
3788 roam_delta[1] = BRCM_BAND_ALL;
3789 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_ROAM_DELTA,
3790 (void *)roam_delta, sizeof(roam_delta));
3791 if (unlikely(err)) {
3792 WL_ERR("WLC_SET_ROAM_DELTA error (%d)\n", err);
3793 goto dongle_rom_out;
3794 }
3795
3796 dongle_rom_out:
3797 return err;
3798 }
3799
3800 static s32
3801 brcmf_dongle_scantime(struct net_device *ndev, s32 scan_assoc_time,
3802 s32 scan_unassoc_time, s32 scan_passive_time)
3803 {
3804 s32 err = 0;
3805
3806 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_SCAN_CHANNEL_TIME,
3807 &scan_assoc_time, sizeof(scan_assoc_time));
3808 if (err) {
3809 if (err == -EOPNOTSUPP)
3810 WL_INFO("Scan assoc time is not supported\n");
3811 else
3812 WL_ERR("Scan assoc time error (%d)\n", err);
3813 goto dongle_scantime_out;
3814 }
3815 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_SCAN_UNASSOC_TIME,
3816 &scan_unassoc_time, sizeof(scan_unassoc_time));
3817 if (err) {
3818 if (err == -EOPNOTSUPP)
3819 WL_INFO("Scan unassoc time is not supported\n");
3820 else
3821 WL_ERR("Scan unassoc time error (%d)\n", err);
3822 goto dongle_scantime_out;
3823 }
3824
3825 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_SCAN_PASSIVE_TIME,
3826 &scan_passive_time, sizeof(scan_passive_time));
3827 if (err) {
3828 if (err == -EOPNOTSUPP)
3829 WL_INFO("Scan passive time is not supported\n");
3830 else
3831 WL_ERR("Scan passive time error (%d)\n", err);
3832 goto dongle_scantime_out;
3833 }
3834
3835 dongle_scantime_out:
3836 return err;
3837 }
3838
3839 s32 brcmf_config_dongle(struct brcmf_cfg80211_priv *cfg_priv, bool need_lock)
3840 {
3841 struct net_device *ndev;
3842 struct wireless_dev *wdev;
3843 s32 power_mode;
3844 s32 err = 0;
3845
3846 if (cfg_priv->dongle_up)
3847 return err;
3848
3849 ndev = cfg_to_ndev(cfg_priv);
3850 wdev = ndev->ieee80211_ptr;
3851 if (need_lock)
3852 rtnl_lock();
3853
3854 brcmf_dongle_scantime(ndev, WL_SCAN_CHANNEL_TIME,
3855 WL_SCAN_UNASSOC_TIME, WL_SCAN_PASSIVE_TIME);
3856
3857 err = brcmf_dongle_eventmsg(ndev);
3858 if (unlikely(err))
3859 goto default_conf_out;
3860
3861 power_mode = cfg_priv->pwr_save ? PM_FAST : PM_OFF;
3862 power_mode = cpu_to_le32(power_mode);
3863 err = brcmf_dev_ioctl(ndev, BRCMF_C_SET_PM,
3864 &power_mode, sizeof(power_mode));
3865 if (err)
3866 goto default_conf_out;
3867 WL_INFO("power save set to %s\n",
3868 (power_mode ? "enabled" : "disabled"));
3869
3870 err = brcmf_dongle_roam(ndev, (cfg_priv->roam_on ? 0 : 1),
3871 WL_BEACON_TIMEOUT);
3872 if (unlikely(err))
3873 goto default_conf_out;
3874 err = brcmf_dongle_mode(ndev, wdev->iftype);
3875 if (unlikely(err && err != -EINPROGRESS))
3876 goto default_conf_out;
3877 err = brcmf_dongle_probecap(cfg_priv);
3878 if (unlikely(err))
3879 goto default_conf_out;
3880
3881 /* -EINPROGRESS: Call commit handler */
3882
3883 default_conf_out:
3884 if (need_lock)
3885 rtnl_unlock();
3886
3887 cfg_priv->dongle_up = true;
3888
3889 return err;
3890
3891 }
3892
3893 static s32 wl_update_wiphybands(struct brcmf_cfg80211_priv *cfg_priv)
3894 {
3895 struct wiphy *wiphy;
3896 s32 phy_list;
3897 s8 phy;
3898 s32 err = 0;
3899
3900 err = brcmf_dev_ioctl(cfg_to_ndev(cfg_priv), BRCM_GET_PHYLIST,
3901 &phy_list, sizeof(phy_list));
3902 if (unlikely(err)) {
3903 WL_ERR("error (%d)\n", err);
3904 return err;
3905 }
3906
3907 phy = ((char *)&phy_list)[1];
3908 WL_INFO("%c phy\n", phy);
3909 if (phy == 'n' || phy == 'a') {
3910 wiphy = cfg_to_wiphy(cfg_priv);
3911 wiphy->bands[IEEE80211_BAND_5GHZ] = &__wl_band_5ghz_n;
3912 }
3913
3914 return err;
3915 }
3916
3917 static s32 __brcmf_cfg80211_up(struct brcmf_cfg80211_priv *cfg_priv)
3918 {
3919 s32 err = 0;
3920
3921 set_bit(WL_STATUS_READY, &cfg_priv->status);
3922
3923 brcmf_debugfs_add_netdev_params(cfg_priv);
3924
3925 err = brcmf_config_dongle(cfg_priv, false);
3926 if (unlikely(err))
3927 return err;
3928
3929 brcmf_invoke_iscan(cfg_priv);
3930
3931 return err;
3932 }
3933
3934 static s32 __brcmf_cfg80211_down(struct brcmf_cfg80211_priv *cfg_priv)
3935 {
3936 /*
3937 * While going down, if associated with AP disassociate
3938 * from AP to save power
3939 */
3940 if ((test_bit(WL_STATUS_CONNECTED, &cfg_priv->status) ||
3941 test_bit(WL_STATUS_CONNECTING, &cfg_priv->status)) &&
3942 test_bit(WL_STATUS_READY, &cfg_priv->status)) {
3943 WL_INFO("Disassociating from AP");
3944 brcmf_link_down(cfg_priv);
3945
3946 /* Make sure WPA_Supplicant receives all the event
3947 generated due to DISASSOC call to the fw to keep
3948 the state fw and WPA_Supplicant state consistent
3949 */
3950 rtnl_unlock();
3951 brcmf_delay(500);
3952 rtnl_lock();
3953 }
3954
3955 set_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
3956 brcmf_term_iscan(cfg_priv);
3957 if (cfg_priv->scan_request) {
3958 cfg80211_scan_done(cfg_priv->scan_request, true);
3959 /* May need to perform this to cover rmmod */
3960 /* wl_set_mpc(cfg_to_ndev(wl), 1); */
3961 cfg_priv->scan_request = NULL;
3962 }
3963 clear_bit(WL_STATUS_READY, &cfg_priv->status);
3964 clear_bit(WL_STATUS_SCANNING, &cfg_priv->status);
3965 clear_bit(WL_STATUS_SCAN_ABORTING, &cfg_priv->status);
3966
3967 brcmf_debugfs_remove_netdev(cfg_priv);
3968
3969 return 0;
3970 }
3971
3972 s32 brcmf_cfg80211_up(void)
3973 {
3974 struct brcmf_cfg80211_priv *cfg_priv;
3975 s32 err = 0;
3976
3977 cfg_priv = WL_PRIV_GET();
3978 mutex_lock(&cfg_priv->usr_sync);
3979 err = __brcmf_cfg80211_up(cfg_priv);
3980 mutex_unlock(&cfg_priv->usr_sync);
3981
3982 return err;
3983 }
3984
3985 s32 brcmf_cfg80211_down(void)
3986 {
3987 struct brcmf_cfg80211_priv *cfg_priv;
3988 s32 err = 0;
3989
3990 cfg_priv = WL_PRIV_GET();
3991 mutex_lock(&cfg_priv->usr_sync);
3992 err = __brcmf_cfg80211_down(cfg_priv);
3993 mutex_unlock(&cfg_priv->usr_sync);
3994
3995 return err;
3996 }
3997
3998 static s32 brcmf_dongle_probecap(struct brcmf_cfg80211_priv *cfg_priv)
3999 {
4000 return wl_update_wiphybands(cfg_priv);
4001 }
4002
4003 static void *brcmf_read_prof(struct brcmf_cfg80211_priv *cfg_priv, s32 item)
4004 {
4005 switch (item) {
4006 case WL_PROF_SEC:
4007 return &cfg_priv->profile->sec;
4008 case WL_PROF_BSSID:
4009 return &cfg_priv->profile->bssid;
4010 case WL_PROF_SSID:
4011 return &cfg_priv->profile->ssid;
4012 }
4013 WL_ERR("invalid item (%d)\n", item);
4014 return NULL;
4015 }
4016
4017 static s32
4018 brcmf_update_prof(struct brcmf_cfg80211_priv *cfg_priv,
4019 const struct brcmf_event_msg *e, void *data, s32 item)
4020 {
4021 s32 err = 0;
4022 struct brcmf_ssid *ssid;
4023
4024 switch (item) {
4025 case WL_PROF_SSID:
4026 ssid = (struct brcmf_ssid *) data;
4027 memset(cfg_priv->profile->ssid.SSID, 0,
4028 sizeof(cfg_priv->profile->ssid.SSID));
4029 memcpy(cfg_priv->profile->ssid.SSID,
4030 ssid->SSID, ssid->SSID_len);
4031 cfg_priv->profile->ssid.SSID_len = ssid->SSID_len;
4032 break;
4033 case WL_PROF_BSSID:
4034 if (data)
4035 memcpy(cfg_priv->profile->bssid, data, ETH_ALEN);
4036 else
4037 memset(cfg_priv->profile->bssid, 0, ETH_ALEN);
4038 break;
4039 case WL_PROF_SEC:
4040 memcpy(&cfg_priv->profile->sec, data,
4041 sizeof(cfg_priv->profile->sec));
4042 break;
4043 case WL_PROF_BEACONINT:
4044 cfg_priv->profile->beacon_interval = *(u16 *)data;
4045 break;
4046 case WL_PROF_DTIMPERIOD:
4047 cfg_priv->profile->dtim_period = *(u8 *)data;
4048 break;
4049 default:
4050 WL_ERR("unsupported item (%d)\n", item);
4051 err = -EOPNOTSUPP;
4052 break;
4053 }
4054
4055 return err;
4056 }
4057
4058 static bool brcmf_is_ibssmode(struct brcmf_cfg80211_priv *cfg_priv)
4059 {
4060 return cfg_priv->conf->mode == WL_MODE_IBSS;
4061 }
4062
4063 static __used s32 brcmf_add_ie(struct brcmf_cfg80211_priv *cfg_priv,
4064 u8 t, u8 l, u8 *v)
4065 {
4066 struct brcmf_cfg80211_ie *ie = &cfg_priv->ie;
4067 s32 err = 0;
4068
4069 if (unlikely(ie->offset + l + 2 > WL_TLV_INFO_MAX)) {
4070 WL_ERR("ei crosses buffer boundary\n");
4071 return -ENOSPC;
4072 }
4073 ie->buf[ie->offset] = t;
4074 ie->buf[ie->offset + 1] = l;
4075 memcpy(&ie->buf[ie->offset + 2], v, l);
4076 ie->offset += l + 2;
4077
4078 return err;
4079 }
4080
4081 static void brcmf_link_down(struct brcmf_cfg80211_priv *cfg_priv)
4082 {
4083 struct net_device *dev = NULL;
4084 s32 err = 0;
4085
4086 WL_TRACE("Enter\n");
4087
4088 if (cfg_priv->link_up) {
4089 dev = cfg_to_ndev(cfg_priv);
4090 WL_INFO("Call WLC_DISASSOC to stop excess roaming\n ");
4091 err = brcmf_dev_ioctl(dev, BRCMF_C_DISASSOC, NULL, 0);
4092 if (unlikely(err))
4093 WL_ERR("WLC_DISASSOC failed (%d)\n", err);
4094 cfg_priv->link_up = false;
4095 }
4096 WL_TRACE("Exit\n");
4097 }
4098
4099 static void brcmf_lock_eq(struct brcmf_cfg80211_priv *cfg_priv)
4100 {
4101 spin_lock_irq(&cfg_priv->eq_lock);
4102 }
4103
4104 static void brcmf_unlock_eq(struct brcmf_cfg80211_priv *cfg_priv)
4105 {
4106 spin_unlock_irq(&cfg_priv->eq_lock);
4107 }
4108
4109 static void brcmf_init_eq_lock(struct brcmf_cfg80211_priv *cfg_priv)
4110 {
4111 spin_lock_init(&cfg_priv->eq_lock);
4112 }
4113
4114 static void brcmf_delay(u32 ms)
4115 {
4116 if (ms < 1000 / HZ) {
4117 cond_resched();
4118 mdelay(ms);
4119 } else {
4120 msleep(ms);
4121 }
4122 }
4123
4124 static void brcmf_set_drvdata(struct brcmf_cfg80211_dev *dev, void *data)
4125 {
4126 dev->driver_data = data;
4127 }
4128
4129 static void *brcmf_get_drvdata(struct brcmf_cfg80211_dev *dev)
4130 {
4131 void *data = NULL;
4132
4133 if (dev)
4134 data = dev->driver_data;
4135 return data;
4136 }
4137
4138 static void brcmf_set_mpc(struct net_device *ndev, int mpc)
4139 {
4140 s32 err = 0;
4141 struct brcmf_cfg80211_priv *cfg_priv = ndev_to_cfg(ndev);
4142
4143 if (test_bit(WL_STATUS_READY, &cfg_priv->status)) {
4144 err = brcmf_dev_intvar_set(ndev, "mpc", mpc);
4145 if (unlikely(err)) {
4146 WL_ERR("fail to set mpc\n");
4147 return;
4148 }
4149 WL_INFO("MPC : %d\n", mpc);
4150 }
4151 }
4152
4153 static int brcmf_debugfs_add_netdev_params(struct brcmf_cfg80211_priv *cfg_priv)
4154 {
4155 char buf[10+IFNAMSIZ];
4156 struct dentry *fd;
4157 s32 err = 0;
4158
4159 sprintf(buf, "netdev:%s", cfg_to_ndev(cfg_priv)->name);
4160 cfg_priv->debugfsdir = debugfs_create_dir(buf,
4161 cfg_to_wiphy(cfg_priv)->debugfsdir);
4162
4163 fd = debugfs_create_u16("beacon_int", S_IRUGO, cfg_priv->debugfsdir,
4164 (u16 *)&cfg_priv->profile->beacon_interval);
4165 if (!fd) {
4166 err = -ENOMEM;
4167 goto err_out;
4168 }
4169
4170 fd = debugfs_create_u8("dtim_period", S_IRUGO, cfg_priv->debugfsdir,
4171 (u8 *)&cfg_priv->profile->dtim_period);
4172 if (!fd) {
4173 err = -ENOMEM;
4174 goto err_out;
4175 }
4176
4177 err_out:
4178 return err;
4179 }
4180
4181 static void brcmf_debugfs_remove_netdev(struct brcmf_cfg80211_priv *cfg_priv)
4182 {
4183 debugfs_remove_recursive(cfg_priv->debugfsdir);
4184 cfg_priv->debugfsdir = NULL;
4185 }
kernel-based virtual machine