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