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